Financial Data

/**
 * Generate a bank account number
 * @param options - Configuration options
 * @returns Account number string
 */
accountNumber(options?: {
  length?: number;
}): string;

/**
 * Generate a descriptive account name
 * @returns Account name string
 */
accountName(): string;

/**
 * Generate a bank routing number
 * @returns Routing number string
 */
routingNumber(): string;

/**
 * Generate a money amount
 * @param options - Configuration options
 * @returns Formatted amount string
 */
amount(options?: {
  min?: number;
  max?: number;
  dec?: number;
  symbol?: string;
  autoFormat?: boolean;
}): string;

/**
 * Generate complete currency information
 * @returns Currency object with code, name, and symbol
 */
currency(): Currency;

/**
 * Generate a three-letter currency code
 * @returns Currency code (ISO 4217)
 */
currencyCode(): string;

/**
 * Generate a currency name
 * @returns Currency name string
 */
currencyName(): string;

/**
 * Generate a currency symbol
 * @returns Currency symbol string
 */
currencySymbol(): string;

/**
 * Generate a currency numeric code (ISO 4217)
 * @returns Currency numeric code string
 */
currencyNumericCode(): string;

/**
 * Generate a credit card number
 * @param options - Configuration options
 * @returns Credit card number string
 */
creditCardNumber(options?: {
  issuer?: string;
}): string;

/**
 * Generate a credit card CVV/CVC code
 * @returns CVV code string
 */
creditCardCVV(): string;

/**
 * Generate a credit card issuer name
 * @returns Issuer name string
 */
creditCardIssuer(): string;

/**
 * Generate a Bitcoin address
 * @param options - Configuration options
 * @returns Bitcoin address string
 */
bitcoinAddress(options?: {
  type?: BitcoinAddressFamilyType;
  network?: BitcoinNetworkType;
}): string;

/**
 * Generate a Litecoin address
 * @returns Litecoin address string
 */
litecoinAddress(): string;

/**
 * Generate an Ethereum address
 * @returns Ethereum address string
 */
ethereumAddress(): string;

/**
 * Generate an IBAN (International Bank Account Number)
 * @param options - Configuration options
 * @returns IBAN string
 */
iban(options?: {
  formatted?: boolean;
  countryCode?: string;
}): string;

/**
 * Generate a BIC (Bank Identifier Code)
 * @param options - Configuration options
 * @returns BIC string
 */
bic(options?: {
  includeBranchCode?: boolean;
}): string;

/**
 * Generate a transaction type
 * @returns Transaction type string
 */
transactionType(): string;

/**
 * Generate a transaction description
 * @returns Transaction description string
 */
transactionDescription(): string;

/**
 * Generate a PIN number
 * @param options - Configuration options
 * @returns PIN string
 */
pin(options?: {
  length?: number;
}): string;

import { faker } from "@faker-js/faker";

// Generate complete bank account information
const bankAccount = {
  accountName: faker.finance.accountName(),
  accountNumber: faker.finance.accountNumber(),
  routingNumber: faker.finance.routingNumber(),
  balance: faker.finance.amount({ min: 100, max: 10000, dec: 2 }),
  currency: faker.finance.currency()
};

// Generate credit card for testing
const creditCard = {
  number: faker.finance.creditCardNumber(),
  cvv: faker.finance.creditCardCVV(),
  issuer: faker.finance.creditCardIssuer()
};

// Generate cryptocurrency portfolio
const cryptoPortfolio = {
  bitcoin: {
    address: faker.finance.bitcoinAddress({ type: 'bech32', network: 'mainnet' }),
    amount: faker.finance.amount({ min: 0.001, max: 10, dec: 8, symbol: '₿' })
  },
  ethereum: {
    address: faker.finance.ethereumAddress(),
    amount: faker.finance.amount({ min: 0.1, max: 100, dec: 6, symbol: 'Ξ' })
  },
  litecoin: {
    address: faker.finance.litecoinAddress(),
    amount: faker.finance.amount({ min: 1, max: 1000, dec: 4, symbol: 'Ł' })
  }
};

// Generate international banking data
const internationalAccount = {
  iban: faker.finance.iban({ formatted: true }),
  bic: faker.finance.bic({ includeBranchCode: true }),
  currency: faker.finance.currencyCode(),
  amount: faker.finance.amount({ min: 1000, max: 50000, dec: 2 })
};

// Generate transaction history
const transactions = Array.from({ length: 10 }, () => ({
  type: faker.finance.transactionType(),
  description: faker.finance.transactionDescription(),
  amount: faker.finance.amount({ min: -1000, max: 1000, dec: 2 }),
  currency: faker.finance.currencyCode(),
  date: faker.date.recent({ days: 30 }),
  accountNumber: faker.finance.accountNumber({ length: 12 })
}));

interface Currency {
  code: string;        // ISO 4217 currency code
  name: string;        // Full currency name
  symbol: string;      // Currency symbol
  numericCode: string; // ISO 4217 numeric code
}

enum BitcoinAddressFamily {
  Legacy = 'legacy',
  Segwit = 'segwit', 
  Bech32 = 'bech32',
  Taproot = 'taproot'
}

type BitcoinAddressFamilyType = keyof typeof BitcoinAddressFamily;

enum BitcoinNetwork {
  Mainnet = 'mainnet',
  Testnet = 'testnet'
}

type BitcoinNetworkType = keyof typeof BitcoinNetwork;

import { fakerDE, fakerJP, fakerEN_US } from "@faker-js/faker";

// German financial data (EUR formatting)
const germanFinance = {
  amount: fakerDE.finance.amount({ min: 100, max: 1000, dec: 2 }),
  iban: fakerDE.finance.iban({ countryCode: 'DE' }),
  currency: fakerDE.finance.currency() // Likely EUR
};

// Japanese financial data (JPY formatting)  
const japaneseFinance = {
  amount: fakerJP.finance.amount({ min: 1000, max: 100000, dec: 0 }),
  currency: fakerJP.finance.currency() // Likely JPY
};

// US financial data (USD formatting)
const usFinance = {
  amount: fakerEN_US.finance.amount({ min: 100, max: 1000, dec: 2, symbol: '$' }),
  routingNumber: fakerEN_US.finance.routingNumber(), // US format
  currency: fakerEN_US.finance.currency() // Likely USD
};