klingex 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,895 @@
+interface KlingExConfig {
+    /** API key for authentication */
+    apiKey?: string;
+    /** JWT token for authentication (alternative to apiKey) */
+    jwt?: string;
+    /** Base URL for the API (default: https://api.klingex.io) */
+    baseUrl?: string;
+    /** WebSocket URL (default: wss://api.klingex.io) */
+    wsUrl?: string;
+    /** Request timeout in milliseconds (default: 30000) */
+    timeout?: number;
+    /** Use human-readable values for orders by default (default: true) */
+    humanReadable?: boolean;
+}
+interface ApiResponse<T> {
+    success?: boolean;
+    data?: T;
+    error?: string;
+    message?: string;
+}
+interface PaginatedResponse<T> {
+    data: T[];
+    total: number;
+    limit: number;
+    offset: number;
+}
+interface Asset {
+    id: number;
+    symbol: string;
+    name: string;
+    decimals: number;
+    min_deposit: string;
+    min_withdrawal: string;
+    withdrawal_fee: string;
+    is_active?: boolean;
+}
+interface AssetsResponse {
+    assets: Asset[];
+}
+interface Market {
+    id: number;
+    base_asset_id: number;
+    quote_asset_id: number;
+    min_trade_amount: string;
+    max_trade_amount: string;
+    tick_size: string;
+    step_size: string;
+    maker_fee_rate: string;
+    taker_fee_rate: string;
+    price_decimals: number;
+    is_active: boolean;
+    created_at: string;
+    updated_at: string;
+    base_asset_symbol: string;
+    base_asset_name: string;
+    quote_asset_symbol: string;
+    quote_asset_name: string;
+    volume_24h: string;
+    priceChange24h: string;
+    last_price: string;
+    base_decimals: number;
+    quote_decimals: number;
+    volume_24h_human: string;
+}
+interface Ticker {
+    ticker_id: string;
+    base_currency: string;
+    target_currency: string;
+    last_price: string;
+    base_volume: string;
+    target_volume: string;
+    bid: string;
+    ask: string;
+    high: string;
+    low: string;
+}
+interface OrderbookEntry {
+    price: string;
+    quantity: string;
+}
+interface Orderbook {
+    trading_pair_id: number;
+    base_symbol: string;
+    quote_symbol: string;
+    bids: OrderbookEntry[];
+    asks: OrderbookEntry[];
+}
+interface OrderbookRaw {
+    trading_pair_id: number;
+    base_symbol: string;
+    quote_symbol: string;
+    bids: string[][];
+    asks: string[][];
+}
+interface OHLCV {
+    time_bucket: string;
+    open_price: string;
+    high_price: string;
+    low_price: string;
+    close_price: string;
+    volume: string;
+    number_of_trades: number;
+}
+type Timeframe = '1m' | '5m' | '15m' | '30m' | '1h' | '4h' | '1d' | '1w';
+type OrderSide = 'buy' | 'sell' | 'BUY' | 'SELL';
+type OrderStatus = 'pending' | 'partial' | 'filled' | 'cancelled' | 'rejected';
+type OrderType = 'limit' | 'market';
+interface SubmitOrderParams {
+    /** Trading pair symbol (e.g., "BTC-USDT") */
+    symbol: string;
+    /** Trading pair ID */
+    tradingPairId: number;
+    /** Order side */
+    side: OrderSide;
+    /** Order quantity (human-readable by default, e.g., "1.5") */
+    quantity: string;
+    /** Order price (human-readable by default, e.g., "50000.00"). Use "0" for market orders */
+    price: string;
+    /** If true, quantity/price are in base units. If false (default), human-readable */
+    rawValues?: boolean;
+    /** Slippage tolerance for market orders (0-1) */
+    slippage?: number;
+}
+interface Order {
+    id: string;
+    trading_pair_id: number;
+    side: 'buy' | 'sell';
+    type: OrderType;
+    price: string;
+    amount: string;
+    filled_amount: string;
+    status: OrderStatus;
+    created_at: string;
+    updated_at: string;
+    human_price?: string;
+    human_amount?: string;
+    human_filled_amount?: string;
+    human_remaining?: string;
+    human_total?: string;
+}
+interface UserOrdersResponse {
+    orders: Order[];
+}
+interface SubmitOrderResponse {
+    message: string;
+    order_id: string;
+}
+interface CancelOrderParams {
+    orderId: string;
+    tradingPairId: number;
+}
+interface CancelOrderResponse {
+    message: string;
+    released_balance: string;
+}
+interface GetOrdersParams {
+    tradingPairId?: number;
+    status?: OrderStatus;
+    limit?: number;
+}
+interface Balance {
+    balance: string;
+    locked_balance: string;
+    wallet_id: string;
+    deposit_address: string;
+    id: number;
+    symbol: string;
+    name: string;
+    decimals: number;
+    min_deposit: string;
+    min_withdrawal: string;
+    withdrawal_fee: string;
+    available_balance?: string;
+    human_balance?: string;
+    human_locked?: string;
+    human_available?: string;
+}
+interface DepositAddress {
+    address: string;
+    memo?: string;
+    network?: string;
+}
+interface WithdrawParams {
+    assetId: number;
+    symbol: string;
+    address: string;
+    amount: string;
+    memo?: string;
+}
+interface WithdrawResponse {
+    message: string;
+    withdrawal_id?: string;
+    requires_2fa?: boolean;
+    session_token?: string;
+}
+type InvoiceStatus = 'pending' | 'paid' | 'expired' | 'cancelled' | 'overpaid' | 'underpaid';
+interface CreateInvoiceParams {
+    /** Amount in the specified asset */
+    amount: string;
+    /** Asset symbol (e.g., "USDT") */
+    asset: string;
+    /** Optional description */
+    description?: string;
+    /** External reference ID */
+    external_id?: string;
+    /** Webhook URL for payment notifications */
+    webhook_url?: string;
+    /** Redirect URL after payment */
+    redirect_url?: string;
+    /** Expiration time in minutes (default: 60) */
+    expires_in?: number;
+}
+interface Invoice {
+    id: string;
+    amount: string;
+    asset: string;
+    status: InvoiceStatus;
+    description?: string;
+    external_id?: string;
+    payment_address: string;
+    payment_amount?: string;
+    paid_at?: string;
+    expires_at: string;
+    created_at: string;
+    webhook_url?: string;
+    redirect_url?: string;
+}
+interface InvoiceFees {
+    network_fee: string;
+    service_fee: string;
+    total_fee: string;
+}
+type WebSocketChannel = 'orderbook' | 'trades' | 'ticker' | 'user.orders' | 'user.balances';
+interface WebSocketMessage<T = unknown> {
+    channel: WebSocketChannel;
+    event: string;
+    data: T;
+    timestamp: string;
+}
+interface WebSocketOptions {
+    /** Reconnect automatically on disconnect (default: true) */
+    reconnect?: boolean;
+    /** Reconnect interval in milliseconds (default: 5000) */
+    reconnectInterval?: number;
+    /** Maximum reconnection attempts (default: 10) */
+    maxReconnectAttempts?: number;
+}
+declare class KlingExError extends Error {
+    code?: string | undefined;
+    statusCode?: number | undefined;
+    details?: unknown | undefined;
+    constructor(message: string, code?: string | undefined, statusCode?: number | undefined, details?: unknown | undefined);
+}
+declare class AuthenticationError extends KlingExError {
+    constructor(message?: string);
+}
+declare class RateLimitError extends KlingExError {
+    retryAfter?: number | undefined;
+    constructor(message?: string, retryAfter?: number | undefined);
+}
+declare class ValidationError extends KlingExError {
+    constructor(message: string, details?: unknown);
+}
+declare class InsufficientFundsError extends KlingExError {
+    constructor(message?: string);
+}
+
+type MessageHandler<T = unknown> = (data: T) => void;
+type ErrorHandler = (error: Error) => void;
+declare class KlingExWebSocket {
+    private ws;
+    private url;
+    private apiKey?;
+    private jwt?;
+    private options;
+    private subscriptions;
+    private reconnectAttempts;
+    private reconnectTimeout;
+    private pingInterval;
+    private isConnecting;
+    private errorHandler?;
+    constructor(url: string, auth: {
+        apiKey?: string;
+        jwt?: string;
+    }, options?: WebSocketOptions);
+    /**
+     * Connect to WebSocket server
+     */
+    connect(): Promise<void>;
+    /**
+     * Disconnect from WebSocket server
+     */
+    disconnect(): void;
+    /**
+     * Set error handler
+     */
+    onError(handler: ErrorHandler): void;
+    /**
+     * Subscribe to orderbook updates
+     * @param symbol - Trading pair symbol
+     * @param handler - Callback for orderbook updates
+     */
+    orderbook(symbol: string, handler: MessageHandler<Orderbook>): () => void;
+    /**
+     * Subscribe to trade updates
+     * @param symbol - Trading pair symbol
+     * @param handler - Callback for trade updates
+     */
+    trades(symbol: string, handler: MessageHandler<{
+        id: string;
+        price: string;
+        quantity: string;
+        side: 'buy' | 'sell';
+        timestamp: string;
+    }>): () => void;
+    /**
+     * Subscribe to ticker updates
+     * @param symbol - Trading pair symbol
+     * @param handler - Callback for ticker updates
+     */
+    ticker(symbol: string, handler: MessageHandler<Ticker>): () => void;
+    /**
+     * Subscribe to user order updates (requires auth)
+     * @param handler - Callback for order updates
+     */
+    userOrders(handler: MessageHandler<Order>): () => void;
+    /**
+     * Subscribe to user balance updates (requires auth)
+     * @param handler - Callback for balance updates
+     */
+    userBalances(handler: MessageHandler<Balance>): () => void;
+    private subscribe;
+    private sendSubscribe;
+    private sendUnsubscribe;
+    private send;
+    private handleMessage;
+    private resubscribeAll;
+    private scheduleReconnect;
+    private startPingInterval;
+    private stopPingInterval;
+}
+
+interface HttpClientConfig {
+    baseUrl: string;
+    apiKey?: string;
+    jwt?: string;
+    timeout: number;
+}
+interface RequestOptions {
+    method?: 'GET' | 'POST' | 'PUT' | 'DELETE';
+    body?: unknown;
+    params?: Record<string, string | number | boolean | undefined>;
+    headers?: Record<string, string>;
+}
+declare class HttpClient {
+    private config;
+    constructor(config: HttpClientConfig);
+    /**
+     * Update authentication credentials
+     */
+    setAuth(auth: {
+        apiKey?: string;
+        jwt?: string;
+    }): void;
+    /**
+     * Make an HTTP request to the API
+     */
+    request<T>(endpoint: string, options?: RequestOptions): Promise<T>;
+    /**
+     * Handle HTTP error responses
+     */
+    private handleError;
+    /**
+     * Extract error message from response
+     */
+    private extractErrorMessage;
+    /**
+     * Extract retry-after value from rate limit response
+     */
+    private extractRetryAfter;
+    get<T>(endpoint: string, params?: Record<string, string | number | boolean | undefined>): Promise<T>;
+    post<T>(endpoint: string, body?: unknown): Promise<T>;
+    put<T>(endpoint: string, body?: unknown): Promise<T>;
+    delete<T>(endpoint: string, body?: unknown): Promise<T>;
+}
+
+declare class MarketsEndpoint {
+    private http;
+    constructor(http: HttpClient);
+    /**
+     * Get all available markets/trading pairs
+     * @example
+     * const markets = await client.markets.list();
+     * // Returns full market info including:
+     * // - base_asset_symbol, quote_asset_symbol
+     * // - maker_fee_rate, taker_fee_rate
+     * // - last_price, volume_24h, priceChange24h
+     */
+    list(): Promise<Market[]>;
+    /**
+     * Get a specific market by ID
+     * @param marketId - The market/trading pair ID
+     */
+    get(marketId: number): Promise<Market | undefined>;
+    /**
+     * Find a market by symbol pair
+     * @param baseSymbol - Base asset symbol (e.g., "BTC")
+     * @param quoteSymbol - Quote asset symbol (e.g., "USDT")
+     */
+    findBySymbols(baseSymbol: string, quoteSymbol: string): Promise<Market | undefined>;
+    /**
+     * Get all tickers with 24h price data (CMC format)
+     * @example
+     * const tickers = await client.markets.tickers();
+     * // Returns ticker_id as "BTC_USDT" format
+     */
+    tickers(): Promise<Ticker[]>;
+    /**
+     * Get ticker for a specific symbol pair
+     * @param tickerId - Ticker ID in CMC format (e.g., "BTC_USDT")
+     */
+    ticker(tickerId: string): Promise<Ticker | undefined>;
+    /**
+     * Get ticker by base and quote currency
+     * @param baseCurrency - Base currency symbol (e.g., "BTC")
+     * @param targetCurrency - Target/quote currency symbol (e.g., "USDT")
+     */
+    tickerByPair(baseCurrency: string, targetCurrency: string): Promise<Ticker | undefined>;
+    /**
+     * Get orderbook for a trading pair
+     * @param marketId - The market/trading pair ID
+     * @param options - Options for the orderbook request
+     * @example
+     * const orderbook = await client.markets.orderbook(1);
+     * console.log('Best bid:', orderbook.bids[0]);
+     * console.log('Best ask:', orderbook.asks[0]);
+     */
+    orderbook(marketId: number, options?: {
+        isCmc?: boolean;
+    }): Promise<Orderbook>;
+    /**
+     * Get raw orderbook (original API format with arrays)
+     * @param marketId - The market/trading pair ID
+     */
+    orderbookRaw(marketId: number, options?: {
+        isCmc?: boolean;
+    }): Promise<OrderbookRaw>;
+    /**
+     * Get OHLCV (candlestick) data
+     * @param marketId - Trading pair ID
+     * @param timeframe - Candle timeframe (e.g., "1h", "1d")
+     * @param options - Additional options
+     * @example
+     * const candles = await client.markets.ohlcv(1, '1h');
+     */
+    ohlcv(marketId: number, timeframe: Timeframe, options?: {
+        limit?: number;
+        startDate?: string;
+        endDate?: string;
+    }): Promise<OHLCV[]>;
+    /**
+     * Get all available assets
+     * @example
+     * const assets = await client.markets.assets();
+     */
+    assets(): Promise<Asset[]>;
+    /**
+     * Get a specific asset by symbol
+     * @param symbol - Asset symbol (e.g., "BTC")
+     */
+    asset(symbol: string): Promise<Asset | undefined>;
+    /**
+     * Get recent trades for a trading pair
+     * @param marketId - Trading pair ID
+     * @param limit - Number of trades to return
+     */
+    trades(marketId: number, limit?: number): Promise<Array<{
+        id: string;
+        price: string;
+        quantity: string;
+        side: 'buy' | 'sell';
+        timestamp: string;
+    }>>;
+}
+
+declare class OrdersEndpoint {
+    private http;
+    private humanReadableDefault;
+    constructor(http: HttpClient, humanReadableDefault?: boolean);
+    /**
+     * Submit a new order
+     * @param params - Order parameters
+     * @example
+     * // Buy 1.5 BTC at $50,000 (human-readable values)
+     * const order = await client.orders.submit({
+     *   symbol: 'BTC-USDT',
+     *   tradingPairId: 1,
+     *   side: 'BUY',
+     *   quantity: '1.5',
+     *   price: '50000.00'
+     * });
+     *
+     * @example
+     * // Market order (price = 0)
+     * const order = await client.orders.submit({
+     *   symbol: 'BTC-USDT',
+     *   tradingPairId: 1,
+     *   side: 'BUY',
+     *   quantity: '1.0',
+     *   price: '0',
+     *   slippage: 0.01  // 1% slippage tolerance
+     * });
+     */
+    submit(params: SubmitOrderParams): Promise<SubmitOrderResponse>;
+    /**
+     * Cancel an existing order
+     * @param params - Order ID and trading pair ID
+     * @example
+     * const result = await client.orders.cancel({
+     *   orderId: '7c9e6679-7425-40de-944b-e07fc1f90ae7',
+     *   tradingPairId: 1
+     * });
+     * console.log(`Released balance: ${result.released_balance}`);
+     */
+    cancel(params: CancelOrderParams): Promise<CancelOrderResponse>;
+    /**
+     * Cancel all open orders for a trading pair
+     * @param tradingPairId - Trading pair ID
+     * @example
+     * const result = await client.orders.cancelAll(1);
+     * console.log(`Cancelled ${result.cancelledCount} orders`);
+     */
+    cancelAll(tradingPairId: number): Promise<{
+        message: string;
+        cancelledCount: number;
+        totalOrders: number;
+        cancelledOrderIds: string[];
+        totalReleasedBalance: string;
+    }>;
+    /**
+     * Get your open orders
+     * @param params - Filter parameters
+     * @example
+     * // Get all open orders
+     * const orders = await client.orders.list();
+     *
+     * // Get orders for specific trading pair
+     * const orders = await client.orders.list({ tradingPairId: 1 });
+     */
+    list(params?: GetOrdersParams): Promise<Order[]>;
+    /**
+     * Get order history (including filled/cancelled orders)
+     * @param params - Filter and pagination parameters
+     */
+    history(params?: {
+        tradingPairId?: number;
+        status?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<{
+        orders: Order[];
+        total: number;
+        limit: number;
+        offset: number;
+    }>;
+    /**
+     * Get a specific order by ID
+     * @param orderId - Order UUID
+     */
+    get(orderId: string): Promise<Order | undefined>;
+    /**
+     * Place a limit buy order (human-readable values)
+     * @param symbol - Trading pair symbol (e.g., "BTC-USDT")
+     * @param tradingPairId - Trading pair ID
+     * @param quantity - Amount to buy
+     * @param price - Price per unit
+     */
+    limitBuy(symbol: string, tradingPairId: number, quantity: string, price: string): Promise<SubmitOrderResponse>;
+    /**
+     * Place a limit sell order (human-readable values)
+     * @param symbol - Trading pair symbol (e.g., "BTC-USDT")
+     * @param tradingPairId - Trading pair ID
+     * @param quantity - Amount to sell
+     * @param price - Price per unit
+     */
+    limitSell(symbol: string, tradingPairId: number, quantity: string, price: string): Promise<SubmitOrderResponse>;
+    /**
+     * Place a market buy order
+     * @param symbol - Trading pair symbol (e.g., "BTC-USDT")
+     * @param tradingPairId - Trading pair ID
+     * @param quantity - Amount to buy
+     * @param slippage - Slippage tolerance (0-1, e.g., 0.01 for 1%)
+     */
+    marketBuy(symbol: string, tradingPairId: number, quantity: string, slippage?: number): Promise<SubmitOrderResponse>;
+    /**
+     * Place a market sell order
+     * @param symbol - Trading pair symbol (e.g., "BTC-USDT")
+     * @param tradingPairId - Trading pair ID
+     * @param quantity - Amount to sell
+     * @param slippage - Slippage tolerance (0-1, e.g., 0.01 for 1%)
+     */
+    marketSell(symbol: string, tradingPairId: number, quantity: string, slippage?: number): Promise<SubmitOrderResponse>;
+}
+
+declare class WalletEndpoint {
+    private http;
+    constructor(http: HttpClient);
+    /**
+     * Get all wallet balances
+     * Each balance includes:
+     * - balance: Total balance (raw value)
+     * - locked_balance: Locked in orders (raw value)
+     * - wallet_id: UUID of the wallet
+     * - deposit_address: Deposit address for this asset
+     * - id, symbol, name, decimals: Asset info
+     * - min_deposit, min_withdrawal, withdrawal_fee: Limits
+     *
+     * @example
+     * const balances = await client.wallet.balances();
+     * const ethBalance = balances.find(b => b.symbol === 'ETH');
+     * console.log(`ETH Balance: ${ethBalance?.balance}`);
+     * console.log(`Deposit Address: ${ethBalance?.deposit_address}`);
+     */
+    balances(): Promise<Balance[]>;
+    /**
+     * Get balance for a specific asset
+     * @param symbol - Asset symbol (e.g., "BTC", "ETH", "USDT")
+     */
+    balance(symbol: string): Promise<Balance | undefined>;
+    /**
+     * Get deposit address for an asset (from balance data)
+     * The deposit_address is included in the balance response
+     * @param symbol - Asset symbol (e.g., "BTC")
+     * @example
+     * const address = await client.wallet.depositAddress('ETH');
+     * console.log(`Send ETH to: ${address.address}`);
+     */
+    depositAddress(symbol: string): Promise<DepositAddress | undefined>;
+    /**
+     * Generate a new deposit address (if supported)
+     * @param assetId - Asset ID
+     */
+    generateDepositAddress(assetId: number): Promise<DepositAddress>;
+    /**
+     * Submit a withdrawal request
+     * @param params - Withdrawal parameters
+     * @example
+     * const result = await client.wallet.withdraw({
+     *   assetId: 2,
+     *   symbol: 'ETH',
+     *   address: '0x...',
+     *   amount: '0.1'
+     * });
+     *
+     * if (result.requires_2fa) {
+     *   // Need to complete 2FA verification
+     *   await client.wallet.confirm2FA(result.session_token, '123456');
+     * }
+     */
+    withdraw(params: WithdrawParams): Promise<WithdrawResponse>;
+    /**
+     * Complete withdrawal 2FA verification
+     * @param sessionToken - Session token from withdraw response
+     * @param code - 2FA code from authenticator app
+     */
+    confirm2FA(sessionToken: string, code: string): Promise<{
+        message: string;
+    }>;
+    /**
+     * Get deposit history
+     * @param options - Pagination options
+     */
+    deposits(options?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<{
+        deposits: Array<{
+            id: string;
+            asset_id: number;
+            symbol: string;
+            amount: string;
+            address: string;
+            tx_hash?: string;
+            status: string;
+            confirmations: number;
+            created_at: string;
+        }>;
+        total: number;
+    }>;
+    /**
+     * Get withdrawal history
+     * @param options - Pagination options
+     */
+    withdrawals(options?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<{
+        withdrawals: Array<{
+            id: string;
+            asset_id: number;
+            symbol: string;
+            amount: string;
+            fee: string;
+            address: string;
+            tx_hash?: string;
+            status: string;
+            created_at: string;
+        }>;
+        total: number;
+    }>;
+    /**
+     * Get transaction history (deposits + withdrawals + trades)
+     */
+    history(): Promise<Array<{
+        id: string;
+        type: 'deposit' | 'withdrawal' | 'trade';
+        asset: string;
+        amount: string;
+        status: string;
+        created_at: string;
+    }>>;
+    /**
+     * Format raw units to human-readable decimal string
+     * @param value - Raw value as string
+     * @param decimals - Number of decimals
+     */
+    private formatUnits;
+}
+
+declare class InvoicesEndpoint {
+    private http;
+    constructor(http: HttpClient);
+    /**
+     * Create a new payment invoice
+     * @param params - Invoice parameters
+     * @example
+     * const invoice = await client.invoices.create({
+     *   amount: '100.00',
+     *   asset: 'USDT',
+     *   description: 'Order #12345',
+     *   external_id: 'order-12345',
+     *   webhook_url: 'https://yoursite.com/webhook'
+     * });
+     *
+     * console.log(`Payment address: ${invoice.payment_address}`);
+     * console.log(`Expires: ${invoice.expires_at}`);
+     */
+    create(params: CreateInvoiceParams): Promise<Invoice>;
+    /**
+     * Get all invoices
+     * @param options - Pagination and filter options
+     */
+    list(options?: {
+        limit?: number;
+        offset?: number;
+        status?: string;
+    }): Promise<PaginatedResponse<Invoice>>;
+    /**
+     * Get a specific invoice by ID
+     * @param invoiceId - Invoice UUID
+     */
+    get(invoiceId: string): Promise<Invoice>;
+    /**
+     * Get invoice status (for polling)
+     * @param invoiceId - Invoice UUID
+     */
+    status(invoiceId: string): Promise<{
+        status: string;
+        paid_amount?: string;
+        confirmations?: number;
+    }>;
+    /**
+     * Cancel a pending invoice
+     * @param invoiceId - Invoice UUID
+     */
+    cancel(invoiceId: string): Promise<{
+        message: string;
+    }>;
+    /**
+     * Get invoice PDF
+     * @param invoiceId - Invoice UUID
+     * @returns PDF blob
+     */
+    pdf(invoiceId: string): Promise<Blob>;
+    /**
+     * Get estimated fees for an invoice
+     * @param asset - Asset symbol
+     * @param amount - Invoice amount
+     */
+    fees(asset: string, amount: string): Promise<InvoiceFees>;
+    /**
+     * Get public invoice payment page data (no auth required)
+     * @param invoiceId - Invoice UUID
+     */
+    paymentPage(invoiceId: string): Promise<{
+        invoice: Invoice;
+        qr_code?: string;
+        payment_uri?: string;
+    }>;
+}
+
+/**
+ * KlingEx API Client
+ *
+ * @example
+ * // Initialize with API key
+ * const client = new KlingEx({
+ *   apiKey: 'your-api-key-here'
+ * });
+ *
+ * // Get markets
+ * const markets = await client.markets.list();
+ *
+ * // Place an order (human-readable values)
+ * const order = await client.orders.submit({
+ *   symbol: 'BTC-USDT',
+ *   tradingPairId: 1,
+ *   side: 'buy',
+ *   quantity: '1.5',
+ *   price: '50000.00'
+ * });
+ *
+ * // Subscribe to real-time orderbook
+ * await client.ws.connect();
+ * client.ws.orderbook('BTC-USDT', (data) => {
+ *   console.log('Orderbook update:', data);
+ * });
+ */
+declare class KlingEx {
+    private http;
+    private _ws;
+    private config;
+    /** Market data endpoints */
+    readonly markets: MarketsEndpoint;
+    /** Order management endpoints */
+    readonly orders: OrdersEndpoint;
+    /** Wallet/balance endpoints */
+    readonly wallet: WalletEndpoint;
+    /** Invoice/payment endpoints */
+    readonly invoices: InvoicesEndpoint;
+    constructor(config?: KlingExConfig);
+    /**
+     * WebSocket client for real-time data
+     * Note: Call ws.connect() before subscribing to channels
+     */
+    get ws(): KlingExWebSocket;
+    /**
+     * Create WebSocket connection with custom options
+     */
+    createWebSocket(options?: WebSocketOptions): KlingExWebSocket;
+    /**
+     * Update authentication credentials
+     */
+    setAuth(auth: {
+        apiKey?: string;
+        jwt?: string;
+    }): void;
+    /**
+     * Check if client has authentication configured
+     */
+    get isAuthenticated(): boolean;
+    /**
+     * Get the configured base URL
+     */
+    get baseUrl(): string;
+    /**
+     * Get current user profile
+     */
+    getProfile(): Promise<{
+        id: string;
+        email: string;
+        created_at: string;
+        two_fa_enabled: boolean;
+    }>;
+    /**
+     * Get current user info
+     */
+    getUser(): Promise<{
+        id: string;
+        email: string;
+        is_active: boolean;
+        is_email_verified: boolean;
+        created_at: string;
+    }>;
+    /**
+     * Get API key statistics
+     */
+    getApiKeyStats(): Promise<{
+        total_keys: number;
+        active_keys: number;
+        last_used_at?: string;
+    }>;
+}
+
+export { type ApiResponse, type Asset, type AssetsResponse, AuthenticationError, type Balance, type CancelOrderParams, type CancelOrderResponse, type CreateInvoiceParams, type DepositAddress, type GetOrdersParams, InsufficientFundsError, type Invoice, type InvoiceFees, type InvoiceStatus, InvoicesEndpoint, KlingEx, type KlingExConfig, KlingExError, KlingExWebSocket, type Market, MarketsEndpoint, type OHLCV, type Order, type OrderSide, type OrderStatus, type OrderType, type Orderbook, type OrderbookEntry, type OrderbookRaw, OrdersEndpoint, type PaginatedResponse, RateLimitError, type SubmitOrderParams, type SubmitOrderResponse, type Ticker, type Timeframe, type UserOrdersResponse, ValidationError, WalletEndpoint, type WebSocketChannel, type WebSocketMessage, type WebSocketOptions, type WithdrawParams, type WithdrawResponse, KlingEx as default };