/**
 * @pinax/token-api - Pinax Token API
 *
 * Power your apps & AI agents with real-time token data.
 *
 * @see https://thegraph.com/docs/en/token-api/quick-start/
 * @license Apache-2.0
 */

import createClient, { type Middleware } from 'openapi-fetch';
import type { paths } from './openapi.d.ts';

// Re-export types
export type * from './openapi.d.ts';

// Constants
export const DEFAULT_BASE_URL = 'https://token-api.thegraph.com';

/**
 * Typed error class for API-level errors returned by the Token API.
 *
 * Network errors (DNS, socket, timeout) propagate as native `TypeError`/`Error`
 * and do not go through `handleResponse`, so they are not wrapped in `APIError`.
 *
 * @example
 * ```typescript
 * try {
 *   await client.evm.tokens.getHolders({ ... });
 * } catch (e) {
 *   if (e instanceof APIError) {
 *     if (e.status === 429) { // retry }
 *     if (e.status === 404) { // not found }
 *   }
 * }
 * ```
 */
export class APIError extends Error {
  status: number;
  code: string;

  constructor(error: { status: number; code: string; message: string }) {
    super(error.message);
    this.name = 'APIError';
    this.status = error.status;
    this.code = error.code;
  }
}

// Response types inferred from operations
export type EvmTransfersResponse = NonNullable<Awaited<ReturnType<InstanceType<typeof TokenAPI>['evm']['tokens']['getTransfers']>>>;
export type EvmSwapsResponse = NonNullable<Awaited<ReturnType<InstanceType<typeof TokenAPI>['evm']['dexs']['getSwaps']>>>;
export type EvmTokensResponse = NonNullable<Awaited<ReturnType<InstanceType<typeof TokenAPI>['evm']['tokens']['getTokenMetadata']>>>;
export type EvmBalancesResponse = NonNullable<Awaited<ReturnType<InstanceType<typeof TokenAPI>['evm']['tokens']['getBalances']>>>;
export type EvmHoldersResponse = NonNullable<Awaited<ReturnType<InstanceType<typeof TokenAPI>['evm']['tokens']['getHolders']>>>;
export type EvmPoolsResponse = NonNullable<Awaited<ReturnType<InstanceType<typeof TokenAPI>['evm']['dexs']['getPools']>>>;
export type SvmTransfersResponse = NonNullable<Awaited<ReturnType<InstanceType<typeof TokenAPI>['svm']['tokens']['getTransfers']>>>;
export type SvmSwapsResponse = NonNullable<Awaited<ReturnType<InstanceType<typeof TokenAPI>['svm']['dexs']['getSwaps']>>>;
export type SvmTokensResponse = NonNullable<Awaited<ReturnType<InstanceType<typeof TokenAPI>['svm']['tokens']['getTokenMetadata']>>>;
export type SvmNativeTokensResponse = NonNullable<Awaited<ReturnType<InstanceType<typeof TokenAPI>['svm']['tokens']['getNativeTokenMetadata']>>>;
export type SvmBalancesResponse = NonNullable<Awaited<ReturnType<InstanceType<typeof TokenAPI>['svm']['tokens']['getBalances']>>>;
export type SvmHoldersResponse = NonNullable<Awaited<ReturnType<InstanceType<typeof TokenAPI>['svm']['tokens']['getHolders']>>>;
export type SvmPoolsResponse = NonNullable<Awaited<ReturnType<InstanceType<typeof TokenAPI>['svm']['dexs']['getPools']>>>;
export type TvmTransfersResponse = NonNullable<Awaited<ReturnType<InstanceType<typeof TokenAPI>['tvm']['tokens']['getTransfers']>>>;
export type TvmSwapsResponse = NonNullable<Awaited<ReturnType<InstanceType<typeof TokenAPI>['tvm']['dexs']['getSwaps']>>>;
export type TvmTokensResponse = NonNullable<Awaited<ReturnType<InstanceType<typeof TokenAPI>['tvm']['tokens']['getTokenMetadata']>>>;
export type TvmPoolsResponse = NonNullable<Awaited<ReturnType<InstanceType<typeof TokenAPI>['tvm']['dexs']['getPools']>>>;
export type PolymarketMarketsResponse = NonNullable<Awaited<ReturnType<InstanceType<typeof TokenAPI>['polymarket']['getMarkets']>>>;
export type PolymarketUsersResponse = NonNullable<Awaited<ReturnType<InstanceType<typeof TokenAPI>['polymarket']['getUsers']>>>;
export type HyperliquidMarketsResponse = NonNullable<Awaited<ReturnType<InstanceType<typeof TokenAPI>['hyperliquid']['getMarkets']>>>;
export type HyperliquidUsersResponse = NonNullable<Awaited<ReturnType<InstanceType<typeof TokenAPI>['hyperliquid']['getUsers']>>>;

type GetQuery<P extends keyof paths> = paths[P] extends {
  get: {
    parameters: {
      query?: infer Q;
    };
  };
}
  ? Q
  : never;

// Network types
export type EvmNetwork =
  | 'mainnet'
  | 'base'
  | 'arbitrum-one'
  | 'bsc'
  | 'polygon'
  | 'optimism'
  | 'avalanche'
  | 'unichain';

export type SvmNetwork = 'solana';

export type TvmNetwork = 'tron';

export type EvmDexProtocol = 'uniswap_v1' | 'uniswap_v2' | 'uniswap_v3' | 'uniswap_v4' | 'curvefi' | 'balancer' | 'bancor' | 'cow' | 'aerodrome' | 'dodo' | 'woofi' | 'traderjoe' | 'kyber_elastic';
export type TvmDexProtocol = 'uniswap_v1' | 'uniswap_v2' | 'uniswap_v3' | 'uniswap_v4' | 'sunpump';
export type SvmDexProtocol =
  | 'jupiter_v4'
  | 'jupiter_v6'
  | 'pumpfun'
  | 'pumpfun_amm'
  | 'raydium_amm_v4'
  | 'raydium_clmm'
  | 'raydium_cpmm'
  | 'raydium_launchpad'
  | 'meteora_daam'
  | 'meteora_dlmm'
  | 'meteora_amm'
  | 'orca_whirlpool'
  | 'boop'
  | 'byreal'
  | 'darklake'
  | 'dumpfun'
  | 'moonshot'
  | 'pancakeswap';
export type SvmTokenProgramId = '11111111111111111111111111111111' | 'TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb' | 'TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA';
export type SvmDexProgramId =
  | 'LanMV9sAd7wArD4vJFi2qDdfnVhFxYSUg6eADduJ3uj'
  | 'CPMMoo8L3F4NbTegBCKVNunggL7H1ZpdTHKxQB5qKP1C'
  | '675kPX9MHTjS2zt1qfr1NYHuzeLXfQM9H24wFSUt1Mp8'
  | 'CAMMCzo5YL8w4VFF8KVHrK22GGUsp5VTaW7grrKgrWqK'
  | 'Eo7WjKq67rjJQSZxS6z3YkapzY3eMj6Xy8X5EQVn5UaB'
  | 'JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4'
  | 'LBUZKhRxPF3XUpBCjp4YzTKgLccjZhTSDM9YuVaPwxo'
  | 'cpamdpZCGKUy5JxQXB4dcpGPiikHawvSWAd6mEn1sGG'
  | 'pAMMBay6oceH9fJKBRHGP5D4bD4sWpmSwMn52FMfXEA'
  | 'JUP4Fb2cqiRUcaTHdrPC8h2gNsA2ETXiPDD33WcGuJB'
  | '6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P';

/**
 * @deprecated Use `EvmDexProtocol` or `TvmDexProtocol` instead.
 */
export type DexProtocol = EvmDexProtocol;

/**
 * EVM chain identifiers for network parameter.
 * Use these constants instead of raw strings for type safety.
 *
 * @example
 * ```typescript
 * import { TokenAPI, EVMChains } from "@pinax/token-api";
 *
 * const client = new TokenAPI();
 * const transfers = await client.evm.tokens.getTransfers({
 *   network: EVMChains.Ethereum,
 *   limit: 10,
 * });
 * ```
 */
export const EVMChains = {
  /** Ethereum Mainnet (alias for 'mainnet') */
  Ethereum: 'mainnet',
  /** Base */
  Base: 'base',
  /** Arbitrum One */
  ArbitrumOne: 'arbitrum-one',
  /** BNB Smart Chain */
  BSC: 'bsc',
  /** Polygon */
  Polygon: 'polygon',
  /** Optimism */
  Optimism: 'optimism',
  /** Avalanche */
  Avalanche: 'avalanche',
  /** Unichain */
  Unichain: 'unichain',
} as const satisfies Record<string, EvmNetwork>;

/**
 * SVM (Solana Virtual Machine) chain identifiers for network parameter.
 * Use these constants instead of raw strings for type safety.
 *
 * @example
 * ```typescript
 * import { TokenAPI, SVMChains } from "@pinax/token-api";
 *
 * const client = new TokenAPI();
 * const transfers = await client.svm.tokens.getTransfers({
 *   network: SVMChains.Solana,
 *   limit: 10,
 * });
 * ```
 */
export const SVMChains = {
  /** Solana */
  Solana: 'solana',
} as const satisfies Record<string, SvmNetwork>;

/**
 * TVM (Tron Virtual Machine) chain identifiers for network parameter.
 * Use these constants instead of raw strings for type safety.
 *
 * @example
 * ```typescript
 * import { TokenAPI, TVMChains } from "@pinax/token-api";
 *
 * const client = new TokenAPI();
 * const transfers = await client.tvm.tokens.getTransfers({
 *   network: TVMChains.Tron,
 *   limit: 10,
 * });
 * ```
 */
export const TVMChains = {
  /** Tron */
  Tron: 'tron',
} as const satisfies Record<string, TvmNetwork>;

/**
 * Configuration options for the Pinax SDK client
 */
export interface PinaxClientOptions {
  /**
   * Bearer token for authentication.
   * Get your API token at https://thegraph.market
   *
   * Required for most API endpoints. Some monitoring endpoints
   * like health, version, and networks may work without authentication.
   */
  apiToken?: string;

  /**
   * Base URL for the API (defaults to production)
   */
  baseUrl?: string;

  /**
   * Custom fetch implementation
   */
  fetch?: typeof fetch;
}

/**
 * Create a middleware that adds authentication headers and referrer
 */
function createAuthMiddleware(options: PinaxClientOptions): Middleware {
  const apiToken = options.apiToken;

  return {
    async onRequest({ request }) {
      if (apiToken) {
        request.headers.set('Authorization', `Bearer ${apiToken}`);
      }
      request.headers.set('User-Agent', '@pinax/token-api');
      return request;
    },
  };
}

/**
 * Create a Pinax Token API client for accessing the Token API
 *
 * @example
 * ```typescript
 * import { createAPIClient } from "@pinax/token-api";
 *
 * const client = createAPIClient({
 *   apiToken: "your-api-token-jwt"
 * });
 *
 * // Get token transfers
 * const { data, error } = await client.GET("/v1/evm/transfers", {
 *   params: {
 *     query: {
 *       network: "mainnet",
 *       to_address: "0xd8da6bf26964af9d7eed9e03e53415d37aa96045",
 *       limit: 10
 *     }
 *   }
 * });
 *
 * if (data) {
 *   console.log("Transfers:", data.data);
 * }
 * ```
 */
export function createAPIClient(options: PinaxClientOptions = {}) {
  const baseUrl = options.baseUrl ?? DEFAULT_BASE_URL;

  const client = createClient<paths>({
    baseUrl,
    fetch: options.fetch,
  });

  // Add authentication middleware
  client.use(createAuthMiddleware(options));

  return client;
}

/**
 * Helper function to handle API responses and errors
 */
function handleResponse<T>(data: T | undefined | null, error: unknown): T {
  if (error) {
    if (
      typeof error === 'object' &&
      error !== null &&
      'status' in error &&
      'code' in error &&
      'message' in error &&
      typeof (error as Record<string, unknown>).status === 'number' &&
      typeof (error as Record<string, unknown>).code === 'string' &&
      typeof (error as Record<string, unknown>).message === 'string'
    ) {
      throw new APIError(error as { status: number; code: string; message: string });
    }
    throw new Error(`API Error: ${JSON.stringify(error)}`);
  }
  if (data === undefined || data === null) {
    throw new Error('API Error: No data returned');
  }
  return data;
}

/**
 * EVM Tokens API - Token operations on EVM networks
 */
class EvmTokens {
  constructor(private client: ReturnType<typeof createAPIClient>) { }

  /**
   * Get ERC-20 token transfers
   */
  async getTransfers(params: {
    network: EvmNetwork;
    transaction_id?: string | string[];
    contract?: string | string[];
    from_address?: string | string[];
    to_address?: string | string[];
    start_time?: string;
    end_time?: string;
    start_block?: number;
    end_block?: number;
    page?: number;
    limit?: number;
  }) {
    const { data, error } = await this.client.GET('/v1/evm/transfers', {
      params: { query: params },
    });

    return handleResponse(data, error);
  }

  /**
   * Get native token transfers (ETH, etc.)
   */
  async getNativeTransfers(params: {
    network: EvmNetwork;
    transaction_id?: string | string[];
    from_address?: string | string[];
    to_address?: string | string[];
    start_time?: string;
    end_time?: string;
    start_block?: number;
    end_block?: number;
    page?: number;
    limit?: number;
  }) {
    const { data, error } = await this.client.GET('/v1/evm/transfers/native', {
      params: { query: params },
    });

    return handleResponse(data, error);
  }

  /**
   * Get token metadata
   */
  async getTokenMetadata(params: {
    network: EvmNetwork;
    contract: string | string[];
  }) {
    const { data, error } = await this.client.GET('/v1/evm/tokens', {
      params: { query: params },
    });

    return handleResponse(data, error);
  }

  /**
   * Get token balances for a wallet address
   */
  async getBalances(params: {
    network: EvmNetwork;
    address: string | string[];
    contract?: string | string[];
    include_null_balances?: boolean;
    page?: number;
    limit?: number;
  }) {
    const { data, error } = await this.client.GET('/v1/evm/balances', {
      params: { query: params },
    });

    return handleResponse(data, error);
  }

  /**
   * Get token holders
   */
  async getHolders(params: {
    network: EvmNetwork;
    contract: string;
    page?: number;
    limit?: number;
  }) {
    const { data, error } = await this.client.GET('/v1/evm/holders', {
      params: { query: params },
    });

    return handleResponse(data, error);
  }

  /**
   * Get native token holders (ranked by ETH balance, etc.)
   */
  async getNativeHolders(params: {
    network: EvmNetwork;
    page?: number;
    limit?: number;
  }) {
    const { data, error } = await this.client.GET('/v1/evm/holders/native', {
      params: { query: params },
    });

    return handleResponse(data, error);
  }

  /**
   * Get native token balances for wallet addresses
   */
  async getNativeBalances(params: {
    network: EvmNetwork;
    address: string | string[];
  }) {
    const { data, error } = await this.client.GET('/v1/evm/balances/native', {
      params: { query: params },
    });

    return handleResponse(data, error);
  }

  /**
   * Get historical token balance changes over time in OHLCV format
   */
  async getHistoricalBalances(params: {
    network: EvmNetwork;
    address: string;
    contract?: string | string[];
    interval?: '1h' | '4h' | '1d' | '1w';
    start_time?: string;
    end_time?: string;
    page?: number;
    limit?: number;
  }) {
    const { data, error } = await this.client.GET(
      '/v1/evm/balances/historical',
      {
        params: { query: params },
      },
    );

    return handleResponse(data, error);
  }

  /**
   * Get historical native balance changes over time in OHLCV format
   */
  async getHistoricalNativeBalances(params: {
    network: EvmNetwork;
    address: string;
    interval?: '1h' | '4h' | '1d' | '1w';
    start_time?: string;
    end_time?: string;
    page?: number;
    limit?: number;
  }) {
    const { data, error } = await this.client.GET(
      '/v1/evm/balances/historical/native',
      {
        params: { query: params },
      },
    );

    return handleResponse(data, error);
  }

  /**
   * Get native token metadata (ETH, etc.) including supply and holder count
   */
  async getNativeTokenMetadata(params: {
    network: EvmNetwork;
  }) {
    const { data, error } = await this.client.GET('/v1/evm/tokens/native', {
      params: { query: params },
    });

    return handleResponse(data, error);
  }
}

/**
 * EVM DEXs API - Decentralized exchange operations on EVM networks
 */
class EvmDexs {
  constructor(private client: ReturnType<typeof createAPIClient>) { }

  /**
   * Get DEX swap transactions
   */
  async getSwaps(params: {
    network: EvmNetwork;
    transaction_id?: string | string[];
    factory?: string | string[];
    pool?: string | string[];
    caller?: string | string[];
    sender?: string | string[];
    recipient?: string | string[];
    input_contract?: string | string[];
    output_contract?: string | string[];
    protocol?: EvmDexProtocol;
    start_time?: string;
    end_time?: string;
    start_block?: number;
    end_block?: number;
    page?: number;
    limit?: number;
  }) {
    const { data, error } = await this.client.GET('/v1/evm/swaps', {
      params: { query: params },
    });

    return handleResponse(data, error);
  }

  /**
   * Get DEX liquidity pools
   */
  async getPools(params: {
    network: EvmNetwork;
    factory?: string | string[];
    pool?: string | string[];
    input_token?: string | string[];
    output_token?: string | string[];
    protocol?: EvmDexProtocol;
    page?: number;
    limit?: number;
  }) {
    const { data, error } = await this.client.GET('/v1/evm/pools', {
      params: { query: params },
    });

    return handleResponse(data, error);
  }

  /**
   * Get supported DEXs
   */
  async getDexes(params: {
    network: EvmNetwork;
    page?: number;
    limit?: number;
  }) {
    const { data, error } = await this.client.GET('/v1/evm/dexes', {
      params: { query: params },
    });

    return handleResponse(data, error);
  }

  /**
   * Get OHLCV price data for liquidity pools
   */
  async getPoolOHLC(params: {
    network: EvmNetwork;
    pool: string;
    interval?: '1h' | '4h' | '1d' | '1w';
    start_time?: string;
    end_time?: string;
    page?: number;
    limit?: number;
  }) {
    const { data, error } = await this.client.GET('/v1/evm/pools/ohlc', {
      params: { query: params },
    });

    return handleResponse(data, error);
  }
}

/**
 * EVM NFTs API - NFT operations on EVM networks
 */
class EvmNfts {
  constructor(private client: ReturnType<typeof createAPIClient>) { }

  /**
   * Get NFT collection metadata and stats
   */
  async getCollections(params: {
    network: EvmNetwork;
    contract: string;
    page?: number;
    limit?: number;
  }) {
    const { data, error } = await this.client.GET('/v1/evm/nft/collections', {
      params: { query: params },
    });

    return handleResponse(data, error);
  }

  /**
   * Get NFT holders for a collection
   */
  async getHolders(params: {
    network: EvmNetwork;
    contract: string;
    page?: number;
    limit?: number;
  }) {
    const { data, error } = await this.client.GET('/v1/evm/nft/holders', {
      params: { query: params },
    });

    return handleResponse(data, error);
  }

  /**
   * Get NFT items with metadata
   */
  async getItems(params: {
    network: EvmNetwork;
    contract: string;
    token_id?: string | string[];
    page?: number;
    limit?: number;
  }) {
    const { data, error } = await this.client.GET('/v1/evm/nft/items', {
      params: { query: params },
    });

    return handleResponse(data, error);
  }

  /**
   * Get NFT ownerships by wallet address
   */
  async getOwnerships(params: {
    network: EvmNetwork;
    address: string | string[];
    contract?: string | string[];
    token_id?: string | string[];
    token_standard?: 'ERC721' | 'ERC1155';
    include_null_balances?: boolean;
    page?: number;
    limit?: number;
  }) {
    const { data, error } = await this.client.GET('/v1/evm/nft/ownerships', {
      params: { query: params },
    });

    return handleResponse(data, error);
  }

  /**
   * Get NFT sales data
   */
  async getSales(params: {
    network: EvmNetwork;
    transaction_id?: string | string[];
    contract?: string | string[];
    token_id?: string | string[];
    address?: string | string[];
    from_address?: string | string[];
    to_address?: string | string[];
    start_time?: string;
    end_time?: string;
    start_block?: number;
    end_block?: number;
    page?: number;
    limit?: number;
  }) {
    const { data, error } = await this.client.GET('/v1/evm/nft/sales', {
      params: { query: params },
    });

    return handleResponse(data, error);
  }

  /**
   * Get NFT transfers
   */
  async getTransfers(params: {
    network: EvmNetwork;
    type?: 'BURN' | 'MINT' | 'TRANSFER';
    transaction_id?: string | string[];
    contract?: string | string[];
    token_id?: string | string[];
    address?: string | string[];
    from_address?: string | string[];
    to_address?: string | string[];
    start_time?: string;
    end_time?: string;
    start_block?: number;
    end_block?: number;
    page?: number;
    limit?: number;
  }) {
    const { data, error } = await this.client.GET('/v1/evm/nft/transfers', {
      params: { query: params },
    });

    return handleResponse(data, error);
  }
}

/**
 * EVM API - Operations on EVM (Ethereum Virtual Machine) networks
 */
class EvmApi {
  public readonly tokens: EvmTokens;
  public readonly dexs: EvmDexs;
  public readonly nfts: EvmNfts;

  constructor(client: ReturnType<typeof createAPIClient>) {
    this.tokens = new EvmTokens(client);
    this.dexs = new EvmDexs(client);
    this.nfts = new EvmNfts(client);
  }
}

/**
 * SVM Tokens API - Token operations on Solana Virtual Machine networks
 */
class SvmTokens {
  constructor(private client: ReturnType<typeof createAPIClient>) { }

  /**
   * Get SPL token transfers
   */
  async getTransfers(params: {
    network: SvmNetwork;
    signature?: string | string[];
    source?: string | string[];
    destination?: string | string[];
    authority?: string | string[];
    mint?: string | string[];
    program_id?: SvmTokenProgramId;
    start_time?: string;
    end_time?: string;
    start_block?: number;
    end_block?: number;
    page?: number;
    limit?: number;
  }) {
    const { data, error } = await this.client.GET('/v1/svm/transfers', {
      params: { query: params },
    });

    return handleResponse(data, error);
  }

  /**
   * Get native SOL transfers
   */
  async getNativeTransfers(params: GetQuery<'/v1/svm/transfers/native'>) {
    const { data, error } = await this.client.GET('/v1/svm/transfers/native', {
      params: { query: params },
    });

    return handleResponse(data, error);
  }

  /**
   * Get token metadata
   */
  async getTokenMetadata(params: {
    network: SvmNetwork;
    mint: string | string[];
  }) {
    const { data, error } = await this.client.GET('/v1/svm/tokens', {
      params: { query: params },
    });

    return handleResponse(data, error);
  }

  /**
   * Get native SOL token metadata
   */
  async getNativeTokenMetadata(params: GetQuery<'/v1/svm/tokens/native'>) {
    const { data, error } = await this.client.GET('/v1/svm/tokens/native', {
      params: { query: params },
    });

    return handleResponse(data, error);
  }

  /**
   * Get token balances for a wallet address
   */
  async getBalances(params: {
    network: SvmNetwork;
    owner: string | string[];
    token_account?: string | string[];
    mint?: string | string[];
    program_id?: SvmTokenProgramId;
    include_null_balances?: boolean;
    page?: number;
    limit?: number;
  }) {
    const { data, error } = await this.client.GET('/v1/svm/balances', {
      params: { query: params },
    });

    return handleResponse(data, error);
  }

  /**
   * Get native SOL balances for wallet addresses
   */
  async getNativeBalances(params: {
    network: SvmNetwork;
    address: string | string[];
    include_null_balances?: boolean;
    page?: number;
    limit?: number;
  }) {
    const { data, error } = await this.client.GET('/v1/svm/balances/native', {
      params: { query: params },
    });

    return handleResponse(data, error);
  }

  /**
   * Get token holders
   */
  async getHolders(params: {
    network: SvmNetwork;
    mint: string;
    page?: number;
    limit?: number;
  }) {
    const { data, error } = await this.client.GET('/v1/svm/holders', {
      params: { query: params },
    });

    return handleResponse(data, error);
  }

  /**
   * Get native SOL holders
   */
  async getNativeHolders(params: GetQuery<'/v1/svm/holders/native'>) {
    const { data, error } = await this.client.GET('/v1/svm/holders/native', {
      params: { query: params },
    });

    return handleResponse(data, error);
  }

  /**
   * Get account owner lookup
   */
  async getAccountOwner(params: {
    network: SvmNetwork;
    account: string | string[];
    page?: number;
    limit?: number;
  }) {
    const { data, error } = await this.client.GET('/v1/svm/owner', {
      params: { query: params },
    });

    return handleResponse(data, error);
  }
}

/**
 * SVM DEXs API - Decentralized exchange operations on Solana Virtual Machine networks
 */
class SvmDexs {
  constructor(private client: ReturnType<typeof createAPIClient>) { }

  /**
   * Get DEX swap transactions
   */
  async getSwaps(params: {
    network: SvmNetwork;
    signature?: string | string[];
    amm?: string | string[];
    amm_pool?: string | string[];
    user?: string | string[];
    fee_payer?: string | string[];
    signer?: string | string[];
    input_mint?: string | string[];
    protocol?: SvmDexProtocol;
    output_mint?: string | string[];
    program_id?: string | string[];
    start_time?: string;
    end_time?: string;
    start_block?: number;
    end_block?: number;
    page?: number;
    limit?: number;
  }) {
    const { data, error } = await this.client.GET('/v1/svm/swaps', {
      params: { query: params },
    });

    return handleResponse(data, error);
  }

  /**
   * Get DEX liquidity pools
   */
  async getPools(params: {
    network: SvmNetwork;
    amm?: string | string[];
    amm_pool?: string | string[];
    mint?: string | string[];
    program_id?: string | string[];
    protocol?: Exclude<SvmDexProtocol, 'jupiter_v4' | 'jupiter_v6'>;
    page?: number;
    limit?: number;
  }) {
    const { data, error } = await this.client.GET('/v1/svm/pools', {
      params: { query: params },
    });

    return handleResponse(data, error);
  }

  /**
   * Get supported DEXs
   */
  async getDexes(params: {
    network: SvmNetwork;
    page?: number;
    limit?: number;
  }) {
    const { data, error } = await this.client.GET('/v1/svm/dexes', {
      params: { query: params },
    });

    return handleResponse(data, error);
  }

  /**
   * Get OHLCV price data for liquidity pools
   */
  async getPoolOHLC(params: {
    network: SvmNetwork;
    amm_pool: string;
    interval?: '1h' | '4h' | '1d' | '1w';
    start_time?: string;
    end_time?: string;
    page?: number;
    limit?: number;
  }) {
    const { data, error } = await this.client.GET('/v1/svm/pools/ohlc', {
      params: { query: params },
    });

    return handleResponse(data, error);
  }
}

/**
 * SVM NFTs API - NFT operations on Solana Virtual Machine networks
 *
 * @remarks
 * This class is a placeholder for future NFT functionality on SVM networks (Solana).
 * Methods will be added when the Token API adds support for Solana NFT operations.
 */
class SvmNfts {
  constructor(private client: ReturnType<typeof createAPIClient>) { }
}

/**
 * SVM API - Operations on SVM (Solana Virtual Machine) networks
 */
class SvmApi {
  public readonly tokens: SvmTokens;
  public readonly dexs: SvmDexs;
  public readonly nfts: SvmNfts;

  constructor(client: ReturnType<typeof createAPIClient>) {
    this.tokens = new SvmTokens(client);
    this.dexs = new SvmDexs(client);
    this.nfts = new SvmNfts(client);
  }
}

/**
 * Polymarket API - Market, activity, platform, and user analytics
 */
class PolymarketApi {
  constructor(private client: ReturnType<typeof createAPIClient>) { }

  /**
   * Get Polymarket market metadata
   */
  async getMarkets(params?: GetQuery<'/v1/polymarket/markets'>) {
    const { data, error } = await this.client.GET('/v1/polymarket/markets', {
      params: { query: params ?? {} },
    });

    return handleResponse(data, error);
  }

  /**
   * Get OHLCV data for a Polymarket outcome token
   */
  async getMarketOHLC(params: GetQuery<'/v1/polymarket/markets/ohlc'>) {
    const { data, error } = await this.client.GET('/v1/polymarket/markets/ohlc', {
      params: { query: params },
    });

    return handleResponse(data, error);
  }

  /**
   * Get market open interest time-series
   */
  async getMarketOpenInterest(params?: GetQuery<'/v1/polymarket/markets/oi'>) {
    const { data, error } = await this.client.GET('/v1/polymarket/markets/oi', {
      params: { query: params ?? {} },
    });

    return handleResponse(data, error);
  }

  /**
   * Get on-chain Polymarket activity
   */
  async getMarketActivity(params?: GetQuery<'/v1/polymarket/markets/activity'>) {
    const { data, error } = await this.client.GET('/v1/polymarket/markets/activity', {
      params: { query: params ?? {} },
    });

    return handleResponse(data, error);
  }

  /**
   * Get leaderboard positions for a market outcome token
   */
  async getMarketPositions(params: GetQuery<'/v1/polymarket/markets/positions'>) {
    const { data, error } = await this.client.GET('/v1/polymarket/markets/positions', {
      params: { query: params },
    });

    return handleResponse(data, error);
  }

  /**
   * Get platform-wide Polymarket aggregates
   */
  async getPlatform(params?: GetQuery<'/v1/polymarket/platform'>) {
    const { data, error } = await this.client.GET('/v1/polymarket/platform', {
      params: { query: params ?? {} },
    });

    return handleResponse(data, error);
  }

  /**
   * Get Polymarket user stats
   */
  async getUsers(params?: GetQuery<'/v1/polymarket/users'>) {
    const { data, error } = await this.client.GET('/v1/polymarket/users', {
      params: { query: params ?? {} },
    });

    return handleResponse(data, error);
  }

  /**
   * Get positions for a Polymarket user
   */
  async getUserPositions(params: GetQuery<'/v1/polymarket/users/positions'>) {
    const { data, error } = await this.client.GET('/v1/polymarket/users/positions', {
      params: { query: params },
    });

    return handleResponse(data, error);
  }
}

/**
 * Hyperliquid API - Markets, users, vaults, liquidations, and platform analytics
 */
class HyperliquidApi {
  constructor(private client: ReturnType<typeof createAPIClient>) { }

  /**
   * Get Hyperliquid DEX aggregates
   */
  async getDexes() {
    const { data, error } = await this.client.GET('/v1/hyperliquid/dexes', {});

    return handleResponse(data, error);
  }

  /**
   * Get Hyperliquid market metadata
   */
  async getMarkets(params?: GetQuery<'/v1/hyperliquid/markets'>) {
    const { data, error } = await this.client.GET('/v1/hyperliquid/markets', {
      params: { query: params ?? {} },
    });

    return handleResponse(data, error);
  }

  /**
   * Get Hyperliquid market OHLC
   */
  async getMarketOHLC(params: GetQuery<'/v1/hyperliquid/markets/ohlc'>) {
    const { data, error } = await this.client.GET('/v1/hyperliquid/markets/ohlc', {
      params: { query: params },
    });

    return handleResponse(data, error);
  }

  /**
   * Get Hyperliquid market open interest
   */
  async getMarketOpenInterest(params: GetQuery<'/v1/hyperliquid/markets/oi'>) {
    const { data, error } = await this.client.GET('/v1/hyperliquid/markets/oi', {
      params: { query: params },
    });

    return handleResponse(data, error);
  }

  /**
   * Get Hyperliquid market activity
   */
  async getMarketActivity(params?: GetQuery<'/v1/hyperliquid/markets/activity'>) {
    const { data, error } = await this.client.GET('/v1/hyperliquid/markets/activity', {
      params: { query: params ?? {} },
    });

    return handleResponse(data, error);
  }

  /**
   * Get Hyperliquid liquidation events
   */
  async getLiquidations(params?: GetQuery<'/v1/hyperliquid/markets/liquidations'>) {
    const { data, error } = await this.client.GET('/v1/hyperliquid/markets/liquidations', {
      params: { query: params ?? {} },
    });

    return handleResponse(data, error);
  }

  /**
   * Get Hyperliquid liquidation OHLC
   */
  async getLiquidationOHLC(params: GetQuery<'/v1/hyperliquid/markets/liquidations/ohlc'>) {
    const { data, error } = await this.client.GET('/v1/hyperliquid/markets/liquidations/ohlc', {
      params: { query: params },
    });

    return handleResponse(data, error);
  }

  /**
   * Get Hyperliquid user stats
   */
  async getUsers(params?: GetQuery<'/v1/hyperliquid/users'>) {
    const { data, error } = await this.client.GET('/v1/hyperliquid/users', {
      params: { query: params ?? {} },
    });

    return handleResponse(data, error);
  }

  /**
   * Get Hyperliquid user positions
   */
  async getUserPositions(params: GetQuery<'/v1/hyperliquid/users/positions'>) {
    const { data, error } = await this.client.GET('/v1/hyperliquid/users/positions', {
      params: { query: params },
    });

    return handleResponse(data, error);
  }

  /**
   * Get Hyperliquid user balance-changing activity
   */
  async getUserActivity(params: GetQuery<'/v1/hyperliquid/users/activity'>) {
    const { data, error } = await this.client.GET('/v1/hyperliquid/users/activity', {
      params: { query: params },
    });

    return handleResponse(data, error);
  }

  /**
   * Get Hyperliquid vault stats
   */
  async getVaults(params?: GetQuery<'/v1/hyperliquid/vaults'>) {
    const { data, error } = await this.client.GET('/v1/hyperliquid/vaults', {
      params: { query: params ?? {} },
    });

    return handleResponse(data, error);
  }

  /**
   * Get Hyperliquid vault depositors
   */
  async getVaultDepositors(params: GetQuery<'/v1/hyperliquid/vaults/depositors'>) {
    const { data, error } = await this.client.GET('/v1/hyperliquid/vaults/depositors', {
      params: { query: params },
    });

    return handleResponse(data, error);
  }

  /**
   * Get Hyperliquid platform-wide aggregates
   */
  async getPlatform(params?: GetQuery<'/v1/hyperliquid/platform'>) {
    const { data, error } = await this.client.GET('/v1/hyperliquid/platform', {
      params: { query: params ?? {} },
    });

    return handleResponse(data, error);
  }
}

/**
 * TVM Tokens API - Token operations on Tron Virtual Machine networks
 */
class TvmTokens {
  constructor(private client: ReturnType<typeof createAPIClient>) { }

  /**
   * Get TRC-20 token transfers
   */
  async getTransfers(params: {
    network: TvmNetwork;
    transaction_id?: string | string[];
    contract?: string | string[];
    from_address?: string | string[];
    to_address?: string | string[];
    start_time?: string;
    end_time?: string;
    start_block?: number;
    end_block?: number;
    page?: number;
    limit?: number;
  }) {
    const { data, error } = await this.client.GET('/v1/tvm/transfers', {
      params: { query: params },
    });

    return handleResponse(data, error);
  }

  /**
   * Get native TRX transfers
   */
  async getNativeTransfers(params: {
    network: TvmNetwork;
    transaction_id?: string | string[];
    from_address?: string | string[];
    to_address?: string | string[];
    start_time?: string;
    end_time?: string;
    start_block?: number;
    end_block?: number;
    page?: number;
    limit?: number;
  }) {
    const { data, error } = await this.client.GET('/v1/tvm/transfers/native', {
      params: { query: params },
    });

    return handleResponse(data, error);
  }

  /**
   * Get token metadata
   */
  async getTokenMetadata(params: {
    network: TvmNetwork;
    contract: string | string[];
  }) {
    const { data, error } = await this.client.GET('/v1/tvm/tokens', {
      params: { query: params },
    });

    return handleResponse(data, error);
  }

  /**
   * Get native TRX token metadata
   */
  async getNativeTokenMetadata(params: {
    network: TvmNetwork;
  }) {
    const { data, error } = await this.client.GET('/v1/tvm/tokens/native', {
      params: { query: params },
    });

    return handleResponse(data, error);
  }
}

/**
 * TVM DEXs API - Decentralized exchange operations on Tron Virtual Machine networks
 */
class TvmDexs {
  constructor(private client: ReturnType<typeof createAPIClient>) { }

  /**
   * Get DEX swap transactions
   */
  async getSwaps(params: {
    network: TvmNetwork;
    transaction_id?: string | string[];
    factory?: string | string[];
    pool?: string | string[];
    transaction_from?: string | string[];
    sender?: string | string[];
    recipient?: string | string[];
    input_contract?: string | string[];
    output_contract?: string | string[];
    protocol?: TvmDexProtocol;
    start_time?: string;
    end_time?: string;
    start_block?: number;
    end_block?: number;
    page?: number;
    limit?: number;
  }) {
    const { data, error } = await this.client.GET('/v1/tvm/swaps', {
      params: { query: params },
    });

    return handleResponse(data, error);
  }

  /**
   * Get supported DEXs
   */
  async getDexes(params: {
    network: TvmNetwork;
    page?: number;
    limit?: number;
  }) {
    const { data, error } = await this.client.GET('/v1/tvm/dexes', {
      params: { query: params },
    });

    return handleResponse(data, error);
  }

  /**
   * Get DEX liquidity pools
   */
  async getPools(params: {
    network: TvmNetwork;
    factory?: string | string[];
    pool?: string | string[];
    input_token?: string | string[];
    output_token?: string | string[];
    protocol?: TvmDexProtocol;
    page?: number;
    limit?: number;
  }) {
    const { data, error } = await this.client.GET('/v1/tvm/pools', {
      params: { query: params },
    });

    return handleResponse(data, error);
  }

  /**
   * Get OHLCV price data for liquidity pools
   */
  async getPoolOHLC(params: {
    network: TvmNetwork;
    pool: string;
    interval?: '1h' | '4h' | '1d' | '1w';
    start_time?: string;
    end_time?: string;
    page?: number;
    limit?: number;
  }) {
    const { data, error } = await this.client.GET('/v1/tvm/pools/ohlc', {
      params: { query: params },
    });

    return handleResponse(data, error);
  }
}

/**
 * TVM NFTs API - NFT operations on Tron Virtual Machine networks
 *
 * @remarks
 * This class is a placeholder for future NFT functionality on TVM networks (Tron).
 * Methods will be added when the Token API adds support for Tron NFT operations.
 */
class TvmNfts {
  constructor(private client: ReturnType<typeof createAPIClient>) { }
}

/**
 * TVM API - Operations on TVM (Tron Virtual Machine) networks
 */
class TvmApi {
  public readonly tokens: TvmTokens;
  public readonly dexs: TvmDexs;
  public readonly nfts: TvmNfts;

  constructor(client: ReturnType<typeof createAPIClient>) {
    this.tokens = new TvmTokens(client);
    this.dexs = new TvmDexs(client);
    this.nfts = new TvmNfts(client);
  }
}

/**
 * High-level wrapper for common Token API operations
 *
 * @example
 * ```typescript
 * import { TokenAPI } from "@pinax/token-api";
 *
 * const client = new TokenAPI({ apiToken: "YOUR_API_KEY_HERE" });
 *
 * // Get EVM transfers
 * const transfers = await client.evm.tokens.getTransfers({
 *   network: "mainnet",
 *   to_address: "0xd8da6bf26964af9d7eed9e03e53415d37aa96045"
 * });
 *
 * // Get EVM swaps
 * const swaps = await client.evm.dexs.getSwaps({
 *   network: "mainnet",
 *   pool: "0x88e6a0c2ddd26feeb64f039a2c41296fcb3f5640"
 * });
 * ```
 */
export class TokenAPI {
  private client: ReturnType<typeof createAPIClient>;

  /**
   * EVM (Ethereum Virtual Machine) API - Ethereum, Base, Arbitrum, etc.
   */
  public readonly evm: EvmApi;

  /**
   * SVM (Solana Virtual Machine) API - Solana
   */
  public readonly svm: SvmApi;

  /**
   * TVM (Tron Virtual Machine) API - Tron
   */
  public readonly tvm: TvmApi;

  /**
   * Polymarket analytics API
   */
  public readonly polymarket: PolymarketApi;

  /**
   * Hyperliquid analytics API
   */
  public readonly hyperliquid: HyperliquidApi;

  constructor(options: PinaxClientOptions = {}) {
    this.client = createAPIClient(options);
    this.evm = new EvmApi(this.client);
    this.svm = new SvmApi(this.client);
    this.tvm = new TvmApi(this.client);
    this.polymarket = new PolymarketApi(this.client);
    this.hyperliquid = new HyperliquidApi(this.client);
  }

  /**
   * Get the underlying openapi-fetch client for advanced usage
   */
  getClient() {
    return this.client;
  }

  // === Monitoring / System Methods (at root level) ===

  /**
   * Check API health status
   */
  async getHealth() {
    const { data, error } = await this.client.GET('/v1/health', {});

    return handleResponse(data, error);
  }

  /**
   * Get API version information
   */
  async getVersion() {
    const { data, error } = await this.client.GET('/v1/version', {});

    return handleResponse(data, error);
  }

  /**
   * Get list of supported networks
   */
  async getNetworks(params?: {
    network?: string | string[];
  }) {
    const { data, error } = await this.client.GET('/v1/networks', {
      params: { query: params ?? {} },
    });

    return handleResponse(data, error);
  }
}

// Default export
export default TokenAPI;

/**
 * @deprecated Use `TokenAPI` instead. `TokenClient` is an alias kept for backward compatibility.
 */
export const TokenClient = TokenAPI;