import { Connection, PublicKey, TransactionInstruction } from '@solana/web3.js';
import { AnchorProvider, Program, Wallet } from '@coral-xyz/anchor';
import BN from 'bn.js';
import { TriadProtocol } from './types/triad_protocol';
import { CreateMarketArgs, OpenOrderArgs, UserTrade, CreateCustomerArgs, MarketBidOrderArgs, CancelBidOrderArgs, CancelAskOrderArgs, PlaceBidOrderArgs, PlaceAskOrderArgs, CollectMarketFeeArgs, CreatePoolArgs, BookOrder, MarketAskOrderArgs, RpcOptions, OrderDirection } from './types';
import Stake from './stake';
import Poseidon from './poseidon';
export * from './types';
export * from './utils/helpers';
export default class TriadProtocolClient {
    private connection;
    private wallet;
    private rpcOptions;
    program: Program<TriadProtocol>;
    provider: AnchorProvider;
    stake: Stake;
    poseidon: Poseidon;
    constructor(connection: Connection, wallet: Wallet, rpcOptions: RpcOptions);
    /**
     * Get All Pools
     */
    getAllPools(): Promise<import("./types").Pool[]>;
    /**
     * Get All Markets
     */
    getAllMarkets(): Promise<import("./types").Market[]>;
    /**
     * Get My User Trades from a user authority
     * @param wallet - User wallet PublicKey
     */
    getMyUserTrades(wallet: PublicKey): Promise<UserTrade[]>;
    /**
     * Get User Orders
     * @param wallet - User wallet PublicKey
     */
    getUserOrders(wallet: PublicKey): Promise<import("./types").Order[]>;
    /**
     * Get User Orders By Market ID
     * @param wallet - User wallet PublicKey
     * @param marketId - The ID of the market
     */
    getUserOrdersByMarketId(wallet: PublicKey, marketId: number): Promise<import("./types").Order[]>;
    /**
     * Get User Book Orders
     */
    getUserBookOrders(wallet: PublicKey, marketId: number): Promise<BookOrder[]>;
    /**
     * Get Pool By ID
     * @param poolId - The ID of the pool
     */
    getPoolById(poolId: number): Promise<import("./types").Pool>;
    /**
     * Get Market By ID
     * @param marketId - The ID of the market
     */
    getMarketById(marketId: number): Promise<import("./types").Market>;
    /**
     * Get Market By Address
     * @param marketAddress - The address of the market
     */
    getMarketByAddress(marketAddress: PublicKey): Promise<import("./types").Market>;
    /**
     * Get Costumer By Wallet Address
     * @param wallet - The wallet address of the customer
     */
    getCustomerByWallet(wallet: PublicKey): Promise<import("./types").Customer>;
    /**
     * Get Customer By ID
     * @param customerId - The ID of the customer
     */
    getCustomerById(customerId: number): Promise<import("./types").Customer>;
    /**
     * Get Current Market ID
     */
    nextMarketId(): Promise<number>;
    /**
     * Get Next Customer ID
     */
    nextCustomerId(): Promise<number>;
    /**
     * Get Next Pool ID
     */
    nextPoolId(): Promise<number>;
    /**
     * Get User Trade PDA
     * @param wallet - User wallet PublicKey
     * @param userNonce - The nonce of the user
     */
    getUserPDA(wallet: PublicKey, userNonce?: number): PublicKey;
    /**
     * Get User Trade
     * @param wallet - User wallet PublicKey
     * @param userNonce - The nonce of the user
     */
    getUserTrade(wallet: PublicKey, userNonce?: number): Promise<{
        bump: number;
        authority: PublicKey;
        totalDeposits: BN;
        totalWithdraws: BN;
        padding1: number[];
        orders: {
            ts: BN;
            orderId: BN;
            filledShares: BN;
            marketId: BN;
            orderStatus: ({
                open?: never;
                closed?: never;
                claimed?: never;
                liquidated?: never;
                waiting?: never;
            } & {
                init: Record<string, never>;
            }) | ({
                init?: never;
                closed?: never;
                claimed?: never;
                liquidated?: never;
                waiting?: never;
            } & {
                open: Record<string, never>;
            }) | ({
                init?: never;
                open?: never;
                claimed?: never;
                liquidated?: never;
                waiting?: never;
            } & {
                closed: Record<string, never>;
            }) | ({
                init?: never;
                open?: never;
                closed?: never;
                liquidated?: never;
                waiting?: never;
            } & {
                claimed: Record<string, never>;
            }) | ({
                init?: never;
                open?: never;
                closed?: never;
                claimed?: never;
                waiting?: never;
            } & {
                liquidated: Record<string, never>;
            }) | ({
                init?: never;
                open?: never;
                closed?: never;
                claimed?: never;
                liquidated?: never;
            } & {
                waiting: Record<string, never>;
            });
            price: BN;
            padding1: number[];
            totalShares: BN;
            orderType: ({
                limit?: never;
            } & {
                market: Record<string, never>;
            }) | ({
                market?: never;
            } & {
                limit: Record<string, never>;
            });
            orderDirection: ({
                flop?: never;
            } & {
                hype: Record<string, never>;
            }) | ({
                hype?: never;
            } & {
                flop: Record<string, never>;
            });
            userNonce: number;
            orderSide: ({
                ask?: never;
            } & {
                bid: Record<string, never>;
            }) | ({
                bid?: never;
            } & {
                ask: Record<string, never>;
            });
            padding2: number[];
            createdAt: BN;
            padding3: number[];
            isTrdPayout: boolean;
            padding: number[];
        }[];
        nonce: number;
        isSubUser: boolean;
        poseidon: number;
        padding: number[];
    }>;
    /**
     * Create Market
     * @param args.markets - Array of markets to create
     * @param args.markets.marketId - Market ID
     * @param args.markets.startTime - start time
     * @param args.markets.endTime - end time
     * @param args.markets.question - question (max 80 characters)
     * @param args.markets.liquidityAtStart - liquidity at start
     * @param args.markets.payoutFee - payout fee (to add affiliate system)
     * @param args.customer - The customer of the market
     * @param args.poolId - The ID of the pool
     */
    createMarket({ markets, customer, poolId }: CreateMarketArgs): Promise<string>;
    /**
     * Create Pool
     * @param poolId - The ID of the pool
     * @param question - The question of the pool
     * @param markets - The markets of the pool
     */
    createPool({ poolId, question, markets, customer, startTime, endTime, feeBps, payoutFee, isFast }: CreatePoolArgs): Promise<string>;
    /**
     * Open Order
     * @param args.marketId - The ID of the Market
     * @param args.amount - The amount of the Order
     * @param args.direction - The direction of the Order
     * @param args.mint - The mint of the Order
     * @param args.token - The token to use for the Order
     */
    openOrder({ marketId, amount, direction, mint, token }: OpenOrderArgs): Promise<string>;
    /**
     * Close Order
     * @param args.marketId - The ID of the Market
     * @param args.orderId - The ID of the Order
     * @param args.userNonce - The nonce of the user
     */
    closeOrder({ marketId, orderId, userNonce }: {
        marketId: number;
        orderId: number;
        userNonce: number;
    }): Promise<string>;
    /**
     * Resolve Market
     * @param args.marketId - The ID of the Market
     * @param args.poolId - The ID of the Pool
     * @param args.winningDirection - The Winning Direction of the Market
     */
    updateMarketWinningDirection({ marketId, poolId, winningDirection }: {
        marketId: number;
        poolId?: number;
        winningDirection: {
            hype: {};
        } | {
            flop: {};
        } | {
            none: {};
        } | {
            draw: {};
        };
    }): Promise<string>;
    /**
     * Collect Remaining Liquidity
     * @param marketId - The ID of the market
     */
    collectRemainingLiquidity(marketId: number): Promise<string>;
    /**
     * Payout Order
     * @param args.marketId - The ID of the Market
     * @param args.orderId - The ID of the Order to Payout
     * @param args.userNonce - The nonce of the user
     * @param args.mint - The mint of the market
     */
    payoutOrder(orders: {
        marketId: number;
        orderId: number;
        userNonce: number;
        mint: PublicKey;
    }[]): Promise<string>;
    /**
     * Update Market Payout
     * @param marketId - The ID of the market
     * @param poolId - The ID of the pool
     * @param allowPayout - Whether to allow the market to payout
     */
    updateMarketPayout({ marketId, poolId, allowPayout }: {
        marketId: number;
        poolId?: number;
        allowPayout: boolean;
    }): Promise<string>;
    /**
     * Create Sub User Trade
     * @param user - User PublicKey the main user
     */
    createSubUserTrade(user: PublicKey): Promise<string>;
    /**
     * Update Market End
     * @param marketId - The ID of the market
     * @param marketEnd - The end time of the market
     */
    updateMarketEnd({ marketId, marketEnd }: {
        marketId: number;
        marketEnd: number;
    }): Promise<string>;
    /**
     * Update Market Question
     * @param marketId - The ID of the market
     * @param question - The question of the market
     */
    updateMarketQuestion({ marketId, question }: {
        marketId: number;
        question: string;
    }): Promise<string>;
    /**
     * Create Customer
     * @param args.id - The ID of the customer
     * @param args.name - The name of the customer
     * @param args.authority - The authority of the customer
     * @param args.feeRecipient - The fee recipient of the customer
     */
    createCustomer({ id, name, authority, feeRecipient }: CreateCustomerArgs): Promise<string>;
    /**
     * Get User Trade Nonce With Slots
     * @param userTrades - User Trades
     */
    getUserTradeNonceWithSlots(userTrades: UserTrade[]): PublicKey;
    /**
     * Get User Trade Ixs
     */
    getUserTradeIxs(): Promise<{
        userTradePDA: PublicKey;
        ixs: TransactionInstruction[];
        nonce: number;
    } | {
        userTradePDA: PublicKey;
        ixs: TransactionInstruction[];
        nonce?: undefined;
    }>;
    /**
     * Get User Trade Nonce
     * @param marketId - The ID of the Market
     * @param orderDirection - The direction of the Order
     */
    getUserTradeNonce(marketId: number, orderDirection: OrderDirection): Promise<{
        userTradePDA: PublicKey;
        userTradeIxs: TransactionInstruction[];
    }>;
    /**
     * Place Bid Order
     * @param args.marketId - The ID of the Market
     * @param args.orders - Array of orders to execute
     * @param args.orders.amount - The amount of the Order
     * @param args.orders.price - The price of the Order
     * @param args.orders.orderDirection - The direction of the Order
     * @param args.mint - The mint of the Order
     * @param args.isTrdPayout - Whether to payout in TRD or not
     */
    placeBidOrder({ marketId, orders, isTrdPayout }: PlaceBidOrderArgs): Promise<string>;
    /**
     * Place Ask Order
     * @param args.marketId - The ID of the Market
     * @param args.orders - Array of orders to execute
     * @param args.orders.amount - The amount of the Order
     * @param args.orders.price - The price of the Order
     * @param args.orders.bidOrderId - The ID of the Bid Order
     * @param args.orders.bidNonce - The nonce of the Bid Order
     */
    placeAskOrder({ marketId, orders }: PlaceAskOrderArgs): Promise<string>;
    /**
     * Cancel Bid Order
     * @param args.marketId - The ID of the Market
     * @param args.orders.orderId - The ID of the Order
     * @param args.orders.userNonce - The nonce of the user
     * @param args.orders.orderDirection - The direction of the Order
     */
    cancelBidOrder({ marketId, orders }: CancelBidOrderArgs): Promise<string>;
    /**
     * Cancel Ask Order
     * @param args.marketId - The ID of the Market
     * @param args.orders.orderId - The ID of the Order
     * @param args.orders.userNonce - The nonce of the user
     * @param args.orders.orderDirection - The direction of the Order
     */
    cancelAskOrder({ marketId, orders }: CancelAskOrderArgs): Promise<string>;
    /**
     * Market Bid Order
     * @param args.marketId - The ID of the Market
     * @param args.amount - The amount of the Order
     * @param args.orderDirection - The direction of the Order
     * @param args.feeBps - The fee in basis points
     * @param args.isTrdPayout - Whether to payout in TRD or not
     */
    marketBidOrder({ marketId, amount, orderDirection, feeBps, isTrdPayout }: MarketBidOrderArgs): Promise<string>;
    /**
     * Market Ask Order
     * @param args.marketId - The ID of the Market
     * @param args.orders - Array of orders to execute
     * @param args.orders.shares - The amount of shares to sell
     * @param args.orders.bidOrderId - The ID of the Bid Order
     * @param args.orders.userNonce - The nonce of the user
     * @param args.orderDirection - The direction of the Order
     * @param args.isTrdPayout - Whether to payout in TRD or not
     * @param args.feeBps - The fee in basis points
     */
    marketAskOrder({ marketId, orders, orderDirection, isTrdPayout, feeBps }: MarketAskOrderArgs): Promise<string>;
    /**
     * Get Orders By Market ID
     * @param marketId - Market ID
     */
    getOrderBook(marketId: number): Promise<{
        marketId: number;
        rewardsAvailable: string;
        rewardsClaimed: string;
        spreadToReward: string;
        hype: {
            bid: BookOrder[];
            ask: BookOrder[];
        };
        flop: {
            bid: BookOrder[];
            ask: BookOrder[];
        };
    }>;
    /**
     * Collect Market Fee
     * @param args.markets - The markets to collect the fee from
     * @param args.markets.marketAddress - The address of the market
     * @param args.markets.customerId - The ID of the customer
     * @param args.markets.customerFeeRecipient - The address of the customer fee recipient
     */
    collectMarketFee({ markets }: CollectMarketFeeArgs): Promise<string>;
    /**
     * Close Order Book
     * @param marketIds - Market IDs
     */
    closeOrderBook(marketIds: number[]): Promise<string>;
}