import { Wallet } from "@ethersproject/wallet";
import { JsonRpcSigner } from "@ethersproject/providers";
import { SignatureType, SignedOrder } from "@polymarket/order-utils";
import { BuilderConfig } from "@polymarket/builder-signing-sdk";
import { ApiKeyCreds, ApiKeysResponse, Chain, CreateOrderOptions, MarketPrice, OpenOrderParams, OpenOrdersResponse, OrderMarketCancelParams, OrderBookSummary, OrderPayload, OrderType, Side, Trade, Notification, TradeParams, UserMarketOrder, UserOrder, BalanceAllowanceParams, BalanceAllowanceResponse, OrderScoringParams, OrderScoring, OpenOrder, TickSizes, TickSize, OrdersScoringParams, OrdersScoring, PriceHistoryFilterParams, PaginationPayload, MarketTradeEvent, DropNotificationParams, BookParams, UserEarning, RewardsPercentages, MarketReward, UserRewardsEarning, TotalUserEarning, NegRisk, BanStatus, PostOrdersArgs, FeeRates, BuilderTrade, BuilderApiKey, BuilderApiKeyResponse } from "./types";
import { OrderBuilder } from "./order-builder/builder";
export declare class ClobClient {
    readonly host: string;
    readonly chainId: Chain;
    readonly signer?: Wallet | JsonRpcSigner;
    readonly creds?: ApiKeyCreds;
    readonly orderBuilder: OrderBuilder;
    readonly tickSizes: TickSizes;
    readonly negRisk: NegRisk;
    readonly feeRates: FeeRates;
    readonly geoBlockToken?: string;
    readonly useServerTime?: boolean;
    readonly builderConfig?: BuilderConfig;
    constructor(host: string, chainId: Chain, signer?: Wallet | JsonRpcSigner, creds?: ApiKeyCreds, signatureType?: SignatureType, funderAddress?: string, geoBlockToken?: string, useServerTime?: boolean, builderConfig?: BuilderConfig, getSigner?: () => Promise<Wallet | JsonRpcSigner> | (Wallet | JsonRpcSigner));
    getOk(): Promise<any>;
    getServerTime(): Promise<number>;
    getSamplingSimplifiedMarkets(next_cursor?: string): Promise<PaginationPayload>;
    getSamplingMarkets(next_cursor?: string): Promise<PaginationPayload>;
    getSimplifiedMarkets(next_cursor?: string): Promise<PaginationPayload>;
    getMarkets(next_cursor?: string): Promise<PaginationPayload>;
    getMarket(conditionID: string): Promise<any>;
    getOrderBook(tokenID: string): Promise<OrderBookSummary>;
    getOrderBooks(params: BookParams[]): Promise<OrderBookSummary[]>;
    getTickSize(tokenID: string): Promise<TickSize>;
    getNegRisk(tokenID: string): Promise<boolean>;
    getFeeRateBps(tokenID: string): Promise<number>;
    /**
     * Calculates the hash for the given orderbook
     * @param orderbook
     * @returns
     */
    getOrderBookHash(orderbook: OrderBookSummary): string;
    getMidpoint(tokenID: string): Promise<any>;
    getMidpoints(params: BookParams[]): Promise<any>;
    getPrice(tokenID: string, side: string): Promise<any>;
    getPrices(params: BookParams[]): Promise<any>;
    getSpread(tokenID: string): Promise<any>;
    getSpreads(params: BookParams[]): Promise<any>;
    getLastTradePrice(tokenID: string): Promise<any>;
    getLastTradesPrices(params: BookParams[]): Promise<any>;
    getPricesHistory(params: PriceHistoryFilterParams): Promise<MarketPrice[]>;
    /**
     * Creates a new API key for a user
     * @param nonce
     * @returns ApiKeyCreds
     */
    createApiKey(nonce?: number): Promise<ApiKeyCreds>;
    /**
     * Derives an existing API key for a user
     * @param nonce
     * @returns ApiKeyCreds
     */
    deriveApiKey(nonce?: number): Promise<ApiKeyCreds>;
    createOrDeriveApiKey(nonce?: number): Promise<ApiKeyCreds>;
    getApiKeys(): Promise<ApiKeysResponse>;
    getClosedOnlyMode(): Promise<BanStatus>;
    deleteApiKey(): Promise<any>;
    getOrder(orderID: string): Promise<OpenOrder>;
    getTrades(params?: TradeParams, only_first_page?: boolean, next_cursor?: string): Promise<Trade[]>;
    getTradesPaginated(params?: TradeParams, next_cursor?: string): Promise<{
        trades: Trade[];
        next_cursor: string;
        limit: number;
        count: number;
    }>;
    getBuilderTrades(params?: TradeParams, next_cursor?: string): Promise<{
        trades: BuilderTrade[];
        next_cursor: string;
        limit: number;
        count: number;
    }>;
    getNotifications(): Promise<Notification[]>;
    dropNotifications(params?: DropNotificationParams): Promise<void>;
    getBalanceAllowance(params?: BalanceAllowanceParams): Promise<BalanceAllowanceResponse>;
    updateBalanceAllowance(params?: BalanceAllowanceParams): Promise<void>;
    createOrder(userOrder: UserOrder, options?: Partial<CreateOrderOptions>): Promise<SignedOrder>;
    createMarketOrder(userMarketOrder: UserMarketOrder, options?: Partial<CreateOrderOptions>): Promise<SignedOrder>;
    createAndPostOrder<T extends OrderType.GTC | OrderType.GTD = OrderType.GTC>(userOrder: UserOrder, options?: Partial<CreateOrderOptions>, orderType?: T, deferExec?: boolean): Promise<any>;
    createAndPostMarketOrder<T extends OrderType.FOK | OrderType.FAK = OrderType.FOK>(userMarketOrder: UserMarketOrder, options?: Partial<CreateOrderOptions>, orderType?: T, deferExec?: boolean): Promise<any>;
    getOpenOrders(params?: OpenOrderParams, only_first_page?: boolean, next_cursor?: string): Promise<OpenOrdersResponse>;
    postOrder<T extends OrderType = OrderType.GTC>(order: SignedOrder, orderType?: T, deferExec?: boolean): Promise<any>;
    postOrders(args: PostOrdersArgs[], deferExec?: boolean): Promise<any>;
    cancelOrder(payload: OrderPayload): Promise<any>;
    cancelOrders(ordersHashes: string[]): Promise<any>;
    cancelAll(): Promise<any>;
    cancelMarketOrders(payload: OrderMarketCancelParams): Promise<any>;
    isOrderScoring(params?: OrderScoringParams): Promise<OrderScoring>;
    areOrdersScoring(params?: OrdersScoringParams): Promise<OrdersScoring>;
    getEarningsForUserForDay(date: string): Promise<UserEarning[]>;
    getTotalEarningsForUserForDay(date: string): Promise<TotalUserEarning[]>;
    getUserEarningsAndMarketsConfig(date: string, order_by?: string, position?: string, no_competition?: boolean): Promise<UserRewardsEarning[]>;
    getRewardPercentages(): Promise<RewardsPercentages>;
    getCurrentRewards(): Promise<MarketReward[]>;
    getRawRewardsForMarket(conditionId: string): Promise<MarketReward[]>;
    getMarketTradesEvents(conditionID: string): Promise<MarketTradeEvent[]>;
    calculateMarketPrice(tokenID: string, side: Side, amount: number, orderType?: OrderType): Promise<number>;
    createBuilderApiKey(): Promise<BuilderApiKey>;
    getBuilderApiKeys(): Promise<BuilderApiKeyResponse[]>;
    revokeBuilderApiKey(): Promise<any>;
    private canL1Auth;
    private canL2Auth;
    private mustBuilderAuth;
    private canBuilderAuth;
    private _resolveTickSize;
    private _resolveFeeRateBps;
    private _generateBuilderHeaders;
    private _getBuilderHeaders;
    private get;
    private post;
    private del;
}