import {
  // ============================================================================
  // Extended Public Key Prefixes (15 exports)
  // ============================================================================
  ExtendedPubKeyPrefix, // Enum
  type ExtendedPubKeyPrefixValue, // Type
  type ExtendedPubKeyDisplayLabel, // Type
  type ExtendedPubKeyNetworkClass, // Type
  type ExtendedPubKeyScriptType, // Type
  type Bip32VersionBytes, // Type
  ExtendedPubKeyDisplayMap, // Map
  ExtendedPubKeyNetworkMap, // Map
  ExtendedPubKeyScriptTypeMap, // Map
  ExtendedPubKeyBip32VersionMap, // Map
  isMainnetPrefix, // Function
  isTestnetPrefix, // Function
  getPrefixFromExtendedPublicKey, // Function
  guessScriptTypeFromPrefix, // Function
  getBip32VersionBytes, // Function

  // ============================================================================
  // Network Types (9 exports)
  // ============================================================================
  NetworkType, // Enum
  type NetworkTypeValue, // Type
  type NetworkTypeKey, // Type
  NetworkMap, // Map
  NetworkReverseMap, // Map
  networkKeyToValue, // Function
  networkValueToKey, // Function
  isMainnet, // Function
  isTestnetFamily, // Function

  // ============================================================================
  // Script Types (7 exports)
  // ============================================================================
  ScriptType, // Enum
  type ScriptTypeValue, // Type
  type ScriptTypeUppercaseKey, // Type
  ScriptTypeMap, // Map
  ScriptTypeReverseMap, // Map
  scriptTypeToValue, // Function
  scriptTypeFromValue, // Function

  // ============================================================================
  // BIP Derivation Purposes (7 exports)
  // ============================================================================
  DERIVATION_PURPOSE_PREFIX, // Constant
  DERIVATION_PURPOSE_LIST, // Constant
  ELECTRUM_LEGACY_PURPOSE, // Constant
  type DerivationPurposeNumber, // Type
  type DerivationPurposeLabel, // Type
  DerivationPurposeString, // Map
  DerivationPurposeNumberMap, // Map

  // ============================================================================
  // Derivation Path Variants (8 exports)
  // ============================================================================
  DERIVATION_VARIANTS, // Constant
  type DerivationVariant, // Type
  type DerivationPathIDMainnetValue, // Type
  type DerivationPathIDTestnetValue, // Type
  type DerivationPathIDRegtestValue, // Type
  DerivationPathIDMainnet, // Map
  DerivationPathIDTestnet, // Map
  DerivationPathIDRegtest, // Map

  // ============================================================================
  // Standard Derivation Paths (38 exports)
  // ============================================================================
  AccountIndex, // Enum
  ChangeIndex, // Enum
  AddressIndex, // Enum
  COIN_TYPE_MAINNET, // Constant
  COIN_TYPE_TESTNET, // Constant
  type CoinType, // Type
  type DerivationPathObject, // Type
  type DerivationPathString, // Type
  type StandardDerivationPath, // Type
  type StandardPathsBip44, // Type
  type StandardPathsBip49, // Type
  type StandardPathsBip84, // Type
  type StandardPathsBip86, // Type
  type LegacyPathsType, // Type
  type MultisigPathsType, // Type
  type HistoricalPathsType, // Type
  type PathsByNetworkMainnet, // Type
  type PathsByNetworkTestnet, // Type
  type PathsByNetworkRegtest, // Type
  STANDARD_PATHS_BIP44, // Map
  STANDARD_PATHS_BIP49, // Map
  STANDARD_PATHS_BIP84, // Map
  STANDARD_PATHS_BIP86, // Map
  LEGACY_PATHS, // Map
  MULTISIG_PATHS, // Map
  HISTORICAL_PATHS, // Map
  PATHS_BY_NETWORK_MAINNET, // Map
  PATHS_BY_NETWORK_TESTNET, // Map
  PATHS_BY_NETWORK_REGTEST, // Map
  buildDerivationPath, // Function
  parseDerivationPath, // Function
  getStandardPath, // Function
  getCoinTypeForNetwork, // Function
  getPathsForNetwork, // Function
  getCommonPathsForNetwork, // Function
  getLegacyPathsForNetwork, // Function
  getMultisigPathsForNetwork, // Function
  getAllPathsByNetwork, // Function
} from '@asylia/atlas';

import {
  // Enum
  ExtendedPubKeyPrefix,

  // Types
  type ExtendedPubKeyPrefixValue,
  type ExtendedPubKeyDisplayLabel,
  type ExtendedPubKeyNetworkClass,
  type ExtendedPubKeyScriptType,
  type Bip32VersionBytes,

  // Maps
  ExtendedPubKeyDisplayMap,
  ExtendedPubKeyNetworkMap,
  ExtendedPubKeyScriptTypeMap,
  ExtendedPubKeyBip32VersionMap,

  // Functions
  isMainnetPrefix,
  isTestnetPrefix,
  guessScriptTypeFromPrefix,
  getBip32VersionBytes,
} from '@asylia/atlas';

// Use enum values
const xpub = ExtendedPubKeyPrefix.XPUB; // 'xpub'
const zpub = ExtendedPubKeyPrefix.ZPUB; // 'zpub'
const trpub = ExtendedPubKeyPrefix.TRPUB; // 'trpub'

// Extract prefix from extended public key string
const xpubString = 'xpub6CzbQ5BLF2mngsMXijEf...';
const detectedPrefix = getPrefixFromExtendedPublicKey(xpubString);
console.log(detectedPrefix); // 'xpub'

// Check if a prefix is mainnet/testnet
const isMainnet = isMainnetPrefix('xpub'); // true
const isTestnet = isTestnetPrefix('tpub'); // true

// Get script type from prefix
const scriptType = guessScriptTypeFromPrefix('zpub'); // 'p2wpkh' (Native SegWit)

// Get network from prefix
const network = ExtendedPubKeyNetworkMap[ExtendedPubKeyPrefix.YPUB]; // 'MAINNET'

// Get display label
const label = ExtendedPubKeyDisplayMap[ExtendedPubKeyPrefix.ZPUB]; // 'Zpub'

// Get BIP32 version bytes for serialization
const zpubVersions = ExtendedPubKeyBip32VersionMap.zpub;
console.log(zpubVersions.public.toString(16)); // '4b24746'
console.log(zpubVersions.private.toString(16)); // '4b2430c'

// Or use the helper function
const versions = getBip32VersionBytes('zpub');
if (versions) {
  console.log('Public:', versions.public.toString(16));
  console.log('Private:', versions.private.toString(16));
}

import {
  ExtendedPubKeyBip32VersionMap,
  getBip32VersionBytes,
  type Bip32VersionBytes,
} from '@asylia/atlas';

// Get version bytes directly from the map
const xpubVersions = ExtendedPubKeyBip32VersionMap.xpub;
console.log(xpubVersions.public); // 0x0488b21e (76067358)
console.log(xpubVersions.private); // 0x0488ade4 (76066276)

// All mainnet version bytes
const mainnetVersions = {
  xpub: ExtendedPubKeyBip32VersionMap.xpub, // Legacy (BIP44)
  ypub: ExtendedPubKeyBip32VersionMap.ypub, // Nested SegWit (BIP49)
  zpub: ExtendedPubKeyBip32VersionMap.zpub, // Native SegWit (BIP84)
  trpub: ExtendedPubKeyBip32VersionMap.trpub, // Taproot (BIP86)
};

// All testnet version bytes
const testnetVersions = {
  tpub: ExtendedPubKeyBip32VersionMap.tpub, // Legacy (BIP44)
  upub: ExtendedPubKeyBip32VersionMap.upub, // Nested SegWit (BIP49)
  vpub: ExtendedPubKeyBip32VersionMap.vpub, // Native SegWit (BIP84)
  trpubt: ExtendedPubKeyBip32VersionMap.trpubt, // Taproot (BIP86)
};

// Use the helper function with error handling
function getVersionBytesForPrefix(prefix: string) {
  const versions = getBip32VersionBytes(prefix as any);
  if (versions) {
    return {
      publicHex: '0x' + versions.public.toString(16),
      privateHex: '0x' + versions.private.toString(16),
    };
  }
  return null;
}

const zpubHex = getVersionBytesForPrefix('zpub');
// { publicHex: '0x4b24746', privateHex: '0x4b2430c' }

// Format version bytes for use in extended key serialization
const formatVersionBytes = (versions: Bip32VersionBytes) => {
  const publicBytes = Buffer.allocUnsafe(4);
  const privateBytes = Buffer.allocUnsafe(4);
  publicBytes.writeUInt32BE(versions.public, 0);
  privateBytes.writeUInt32BE(versions.private, 0);
  return { publicBytes, privateBytes };
};

const zpubBytes = formatVersionBytes(ExtendedPubKeyBip32VersionMap.zpub);
// publicBytes: <Buffer 04 b2 47 46>
// privateBytes: <Buffer 04 b2 43 0c>

import {
  // Enum
  NetworkType,

  // Types
  type NetworkTypeValue,
  type NetworkTypeKey,

  // Maps
  NetworkMap,
  NetworkReverseMap,

  // Functions
  networkKeyToValue,
  networkValueToKey,
  isMainnet,
  isTestnetFamily,
} from '@asylia/atlas';

// Use enum values
const mainnet = NetworkType.MAINNET; // 'mainnet'
const testnet = NetworkType.TESTNET; // 'testnet'
const regtest = NetworkType.REGTEST; // 'regtest'

// Convert between formats
const value = networkKeyToValue('MAINNET'); // 'mainnet'
const key = networkValueToKey('testnet'); // 'TESTNET'

// Check network type
const isMain = isMainnet('mainnet'); // true
const isTest = isTestnetFamily('testnet'); // true
const isReg = isTestnetFamily('regtest'); // true

// Use maps
const networkValue = NetworkMap.MAINNET; // 'mainnet'
const networkKey = NetworkReverseMap.mainnet; // 'MAINNET'

import {
  // Enum
  ScriptType,

  // Types
  type ScriptTypeValue,
  type ScriptTypeUppercaseKey,

  // Maps
  ScriptTypeMap,
  ScriptTypeReverseMap,

  // Functions
  scriptTypeToValue,
  scriptTypeFromValue,
} from '@asylia/atlas';

// Use enum values
const legacyScript = ScriptType.P2PKH; // 'p2pkh'
const nestedSegwit = ScriptType.P2SH_P2WPKH; // 'p2sh-p2wpkh'
const segwitScript = ScriptType.P2WPKH; // 'p2wpkh'
const taprootScript = ScriptType.P2TR; // 'p2tr'
const multisigScript = ScriptType.P2SH_MULTISIG; // 'p2sh-multisig'
const wshScript = ScriptType.P2WSH; // 'p2wsh'
const wshP2shScript = ScriptType.P2WSH_P2SH; // 'p2wsh-p2sh'

// Convert between formats
const value = scriptTypeToValue('P2WPKH'); // 'p2wpkh'
const key = scriptTypeFromValue('p2tr'); // 'P2TR'

// Use maps
const scriptValue = ScriptTypeMap.P2WPKH; // 'p2wpkh'
const scriptKey = ScriptTypeReverseMap['p2wpkh']; // 'P2WPKH'

import {
  // Constants
  DERIVATION_PURPOSE_PREFIX,
  DERIVATION_PURPOSE_LIST,

  // Types
  type DerivationPurposeNumber,
  type DerivationPurposeLabel,

  // Maps
  DerivationPurposeString,
  DerivationPurposeNumberMap,
} from '@asylia/atlas';

// Get all supported BIP numbers
const bips = DERIVATION_PURPOSE_LIST; // [44, 45, 48, 49, 84, 86]

// Get the prefix
const prefix = DERIVATION_PURPOSE_PREFIX; // 'BIP'

// Use BIP labels
const bip44 = DerivationPurposeString.BIP_44; // 'BIP_44'
const bip49 = DerivationPurposeString.BIP_49; // 'BIP_49'
const bip84 = DerivationPurposeString.BIP_84; // 'BIP_84'
const bip86 = DerivationPurposeString.BIP_86; // 'BIP_86'
const bip45 = DerivationPurposeString.BIP_45; // 'BIP_45'
const bip48 = DerivationPurposeString.BIP_48; // 'BIP_48'

// Convert label to number
const number44 = DerivationPurposeNumberMap.BIP_44; // 44
const number84 = DerivationPurposeNumberMap.BIP_84; // 84
const number86 = DerivationPurposeNumberMap.BIP_86; // 86

import {
  // Enums
  AccountIndex,
  ChangeIndex,
  AddressIndex,

  // Constants
  COIN_TYPE_MAINNET,
  COIN_TYPE_TESTNET,

  // Types
  type CoinType,
  type DerivationPathObject,
  type DerivationPathString,
  type StandardDerivationPath,

  // Standard path maps
  STANDARD_PATHS_BIP44,
  STANDARD_PATHS_BIP49,
  STANDARD_PATHS_BIP84,
  STANDARD_PATHS_BIP86,

  // Functions
  buildDerivationPath,
  parseDerivationPath,
  getStandardPath,
  getCoinTypeForNetwork,
} from '@asylia/atlas';

// Use enum values for type-safe indices
const account = AccountIndex.ACCOUNT_0; // 0
const receive = ChangeIndex.RECEIVE; // 0
const change = ChangeIndex.CHANGE; // 1
const address = AddressIndex.ADDRESS_0; // 0

// Build a custom derivation path
const customPath = buildDerivationPath(
  84, // BIP84 (Native SegWit)
  COIN_TYPE_MAINNET,
  AccountIndex.ACCOUNT_0,
  ChangeIndex.RECEIVE,
  AddressIndex.ADDRESS_5
);
console.log(customPath.path); // "m/84'/0'/0'/0/5"
console.log(customPath.components.purpose); // 84
console.log(customPath.components.addressIndex); // 5

// Parse an existing derivation path
const parsed = parseDerivationPath("m/84'/0'/0'/0/0");
console.log(parsed.purpose); // 84
console.log(parsed.coinType); // 0
console.log(parsed.account); // 0
console.log(parsed.change); // 0
console.log(parsed.addressIndex); // 0

// Get standard path with defaults
const standardPath = getStandardPath(84, 'MAINNET');
console.log(standardPath.path); // "m/84'/0'/0'/0/0"

// Get standard path with custom values
const customStandard = getStandardPath(
  86, // BIP86 (Taproot)
  'TESTNET',
  AccountIndex.ACCOUNT_1,
  ChangeIndex.CHANGE,
  AddressIndex.ADDRESS_10
);
console.log(customStandard.path); // "m/86'/1'/1'/1/10"

// Use pre-defined standard paths for BIP84 (Native SegWit)
const firstReceive = STANDARD_PATHS_BIP84.FIRST_RECEIVE_MAINNET;
console.log(firstReceive.path); // "m/84'/0'/0'/0/0"

const firstChange = STANDARD_PATHS_BIP84.FIRST_CHANGE_MAINNET;
console.log(firstChange.path); // "m/84'/0'/0'/1/0"

const secondAccount = STANDARD_PATHS_BIP84.SECOND_ACCOUNT_MAINNET;
console.log(secondAccount.path); // "m/84'/0'/1'/0/0"

// Use pre-defined standard paths for BIP86 (Taproot)
const taprootPath = STANDARD_PATHS_BIP86.FIRST_RECEIVE_MAINNET;
console.log(taprootPath.path); // "m/86'/0'/0'/0/0"
console.log(taprootPath.components.purpose); // 86

// Get coin type for a network
const mainnetCoin = getCoinTypeForNetwork('MAINNET'); // 0
const testnetCoin = getCoinTypeForNetwork('testnet'); // 1
const regtestCoin = getCoinTypeForNetwork('REGTEST'); // 1

// Iterate through address indices
for (let i = AddressIndex.ADDRESS_0; i <= AddressIndex.ADDRESS_9; i++) {
  const path = buildDerivationPath(
    84,
    COIN_TYPE_MAINNET,
    AccountIndex.ACCOUNT_0,
    ChangeIndex.RECEIVE,
    i
  );
  console.log(path.path); // m/84'/0'/0'/0/0, m/84'/0'/0'/0/1, ...
}

import { LEGACY_PATHS, MULTISIG_PATHS, HISTORICAL_PATHS } from '@asylia/atlas';

// Electrum Legacy paths (m/0'/change/index format)
const electrumReceive = LEGACY_PATHS.ELECTRUM_LEGACY_FIRST_RECEIVE;
console.log(electrumReceive.path); // "m/0'/0/0"

const electrumChange = LEGACY_PATHS.ELECTRUM_LEGACY_FIRST_CHANGE;
console.log(electrumChange.path); // "m/0'/1/0"

// BIP32 basic paths
const bip32Receive = LEGACY_PATHS.BIP32_BASIC_FIRST_RECEIVE;
console.log(bip32Receive.path); // "m/0'/0/0"

const bip32NonHardened = LEGACY_PATHS.BIP32_NON_HARDENED;
console.log(bip32NonHardened.path); // "m/0/0/0"

// Multi-signature paths
// BIP45 (m/45'/cosigner/change/index)
const bip45 = MULTISIG_PATHS.BIP45_COSIGNER_0_RECEIVE_MAINNET;
console.log(bip45.path); // "m/45'/0/0/0"

// BIP48 with P2WSH-P2SH (script_type=1)
const bip48WshP2sh = MULTISIG_PATHS.BIP48_P2WSH_P2SH_RECEIVE_MAINNET;
console.log(bip48WshP2sh.path); // "m/48'/0'/0'/1'/0/0"

// BIP48 with P2WSH (script_type=2)
const bip48Wsh = MULTISIG_PATHS.BIP48_P2WSH_RECEIVE_MAINNET;
console.log(bip48Wsh.path); // "m/48'/0'/0'/2'/0/0"

// Access all historical paths at once
const allHistorical = HISTORICAL_PATHS;
console.log(Object.keys(allHistorical)); // All legacy and multisig paths

import {
  PATHS_BY_NETWORK_MAINNET,
  PATHS_BY_NETWORK_TESTNET,
  PATHS_BY_NETWORK_REGTEST,
  getPathsForNetwork,
  getCommonPathsForNetwork,
  getLegacyPathsForNetwork,
  getMultisigPathsForNetwork,
  getAllPathsByNetwork,
} from '@asylia/atlas';

// Get all mainnet paths using the map
const mainnetPaths = PATHS_BY_NETWORK_MAINNET;
console.log(mainnetPaths.BIP84_FIRST_RECEIVE_MAINNET.path); // "m/84'/0'/0'/0/0"

// Or use the function to get paths as an array
const allMainnetPaths = getPathsForNetwork('MAINNET');
console.log(allMainnetPaths.length); // All mainnet paths

const testnetPaths = getPathsForNetwork('testnet');
console.log(testnetPaths.length); // All testnet paths

// Get only common/standard paths (BIP44, 49, 84, 86)
const commonMainnet = getCommonPathsForNetwork('MAINNET');
console.log(commonMainnet.length); // 15 paths (3 for each BIP + second account)

// Get only legacy paths
const legacyPaths = getLegacyPathsForNetwork('MAINNET');
console.log(legacyPaths.length); // Electrum and BIP32 paths

// Get only multisig paths
const multisigMainnet = getMultisigPathsForNetwork('MAINNET');
// Returns BIP45 and BIP48 mainnet paths

const multisigTestnet = getMultisigPathsForNetwork('TESTNET');
// Returns BIP45 and BIP48 testnet paths

// Get all paths grouped by network
const groupedPaths = getAllPathsByNetwork();
console.log(groupedPaths.mainnet.length); // All mainnet paths
console.log(groupedPaths.testnet.length); // All testnet paths
console.log(groupedPaths.regtest.length); // All regtest paths

// Filter and display specific paths
const mainnetCommon = getCommonPathsForNetwork('MAINNET');
mainnetCommon.forEach((path) => {
  console.log(`${path.components.purpose}: ${path.path}`);
  // 44: m/44'/0'/0'/0/0
  // 44: m/44'/0'/0'/1/0
  // 49: m/49'/0'/0'/0/0
  // ...
});

import {
  // Constants
  DERIVATION_VARIANTS,

  // Types
  type DerivationVariant,
  type DerivationPathIDMainnetValue,
  type DerivationPathIDTestnetValue,
  type DerivationPathIDRegtestValue,

  // Network-specific maps
  DerivationPathIDMainnet,
  DerivationPathIDTestnet,
  DerivationPathIDRegtest,
} from '@asylia/atlas';

// Get all variants (without network)
const variants = DERIVATION_VARIANTS;
// [
//   'ELECTRUM_LEGACY_P2PKH',
//   'BIP_44_P2PKH',
//   'BIP_49_P2SH-P2WPKH',
//   'BIP_84_P2WPKH',
//   'BIP_86_P2TR',
//   'BIP_45_P2SH-MULTISIG',
//   'BIP_48_P2WSH-P2SH',
//   'BIP_48_P2WSH'
// ]

// Access mainnet derivation path IDs
const mainnetLegacy = DerivationPathIDMainnet.BIP_44_P2PKH_MAINNET;
const mainnetNestedSegwit = DerivationPathIDMainnet.BIP_49_P2SH_P2WPKH_MAINNET;
const mainnetSegwit = DerivationPathIDMainnet.BIP_84_P2WPKH_MAINNET;
const mainnetTaproot = DerivationPathIDMainnet.BIP_86_P2TR_MAINNET;

// Access testnet derivation path IDs
const testnetLegacy = DerivationPathIDTestnet.BIP_44_P2PKH_TESTNET;
const testnetSegwit = DerivationPathIDTestnet.BIP_84_P2WPKH_TESTNET;
const testnetTaproot = DerivationPathIDTestnet.BIP_86_P2TR_TESTNET;

// Access regtest derivation path IDs
const regtestLegacy = DerivationPathIDRegtest.BIP_44_P2PKH_REGTEST;
const regtestSegwit = DerivationPathIDRegtest.BIP_84_P2WPKH_REGTEST;