import { ClobSigner } from "./signing/signer.cjs";
import { Side } from "./order-utils/model/side.cjs";
import { ApiKeyCreds, ApiKeysResponse, BalanceAllowanceParams, BalanceAllowanceResponse, BanStatus, BookParams, BuilderApiKey, BuilderApiKeyResponse, BuilderConfig, BuilderFeeRates, BuilderTradeParams, BuilderTradesResponse, Chain, CreateOrderOptions, DropNotificationParams, FeeInfos, FeeRates, MarketDetails, MarketPrice, MarketReward, MarketTradeEvent, NegRisk, Notification, OpenOrder, OpenOrderParams, OpenOrdersResponse, OrderBookSummary, OrderMarketCancelParams, OrderPayload, OrderScoring, OrderScoringParams, OrderType, OrdersScoring, OrdersScoringParams, PaginationPayload, PreMigrationOrdersResponse, PriceHistoryFilterParams, ReadonlyApiKeyResponse, RewardsPercentages, TickSize, TickSizes, TotalUserEarning, Trade, TradeParams, TradesPaginatedResponse, UserEarning, UserRewardsEarning } from "./types/clob.cjs";
import { UserMarketOrderV1, UserOrderV1 } from "./types/ordersV1.cjs";
import { UserMarketOrderV2, UserOrderV2 } from "./types/ordersV2.cjs";
import { PostOrdersArgs, SignedOrder } from "./types/unifiedOrder.cjs";
import { SignatureTypeV2 } from "./order-utils/model/signatureTypeV2.cjs";
import { OrderBuilder } from "./order-builder/orderBuilder.cjs";
import { adjustBuyAmountForFees } from "./fees/index.cjs";

//#region src/client.d.ts
interface ClobClientOptions {
  host: string;
  chain: Chain;
  signer?: ClobSigner;
  creds?: ApiKeyCreds;
  signatureType?: SignatureTypeV2;
  funderAddress?: string;
  useServerTime?: boolean;
  builderConfig?: BuilderConfig;
  getSigner?: () => Promise<ClobSigner> | ClobSigner;
  retryOnError?: boolean;
  throwOnError?: boolean;
  feeSlippage?: number;
}
declare class ClobClient {
  readonly host: string;
  readonly chainId: Chain;
  readonly signer?: ClobSigner;
  readonly creds?: ApiKeyCreds;
  readonly orderBuilder: OrderBuilder;
  readonly tickSizes: TickSizes;
  readonly negRisk: NegRisk;
  readonly feeInfos: FeeInfos;
  readonly feeRates: FeeRates;
  readonly builderFeeRates: BuilderFeeRates;
  private readonly tokenConditionMap;
  readonly useServerTime?: boolean;
  readonly builderConfig?: BuilderConfig;
  readonly signatureType: SignatureTypeV2;
  readonly funderAddress?: string;
  private cachedVersion?;
  readonly retryOnError?: boolean;
  readonly throwOnError?: boolean;
  readonly feeSlippage: number;
  constructor({
    host,
    chain,
    signer,
    creds,
    signatureType,
    funderAddress,
    useServerTime,
    builderConfig,
    getSigner,
    retryOnError,
    throwOnError,
    feeSlippage
  }: ClobClientOptions);
  getOk(): Promise<any>;
  postHeartbeat(heartbeatId?: string): Promise<{
    heartbeat_id: string;
    error_msg?: string;
  }>;
  getVersion(): Promise<number>;
  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>;
  getClobMarketInfo(conditionID: string): Promise<MarketDetails>;
  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>;
  getFeeExponent(tokenID: string): Promise<number>;
  /**
   * Calculates the hash for the given orderbook
   * @param orderbook
   * @returns
   */
  getOrderBookHash(orderbook: OrderBookSummary): Promise<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>;
  createReadonlyApiKey(): Promise<ReadonlyApiKeyResponse>;
  getReadonlyApiKeys(): Promise<string[]>;
  deleteReadonlyApiKey(key: string): Promise<boolean>;
  getOrder(orderID: string): Promise<OpenOrder>;
  getTrades(params?: TradeParams, only_first_page?: boolean, next_cursor?: string): Promise<Trade[]>;
  getTradesPaginated(params?: TradeParams, next_cursor?: string): Promise<TradesPaginatedResponse>;
  getBuilderTrades(params: BuilderTradeParams, next_cursor?: string): Promise<BuilderTradesResponse>;
  getNotifications(): Promise<Notification[]>;
  dropNotifications(params?: DropNotificationParams): Promise<void>;
  getBalanceAllowance(params?: BalanceAllowanceParams): Promise<BalanceAllowanceResponse>;
  updateBalanceAllowance(params?: BalanceAllowanceParams): Promise<void>;
  createOrder(userOrder: UserOrderV1 | UserOrderV2, options?: Partial<CreateOrderOptions>): Promise<SignedOrder>;
  createMarketOrder(userMarketOrder: UserMarketOrderV1 | UserMarketOrderV2, options?: Partial<CreateOrderOptions>): Promise<SignedOrder>;
  createAndPostOrder<T extends OrderType.GTC | OrderType.GTD = OrderType.GTC>(userOrder: UserOrderV1 | UserOrderV2, options?: Partial<CreateOrderOptions>, orderType?: T, postOnly?: boolean, deferExec?: boolean): Promise<any>;
  createAndPostMarketOrder<T extends OrderType.FOK | OrderType.FAK = OrderType.FOK>(userMarketOrder: UserMarketOrderV1 | UserMarketOrderV2, options?: Partial<CreateOrderOptions>, orderType?: T, deferExec?: boolean): Promise<any>;
  getOpenOrders(params?: OpenOrderParams, only_first_page?: boolean, next_cursor?: string): Promise<OpenOrdersResponse>;
  getPreMigrationOrders(only_first_page?: boolean, next_cursor?: string): Promise<PreMigrationOrdersResponse>;
  postOrder<T extends OrderType = OrderType.GTC>(order: SignedOrder, orderType?: T, postOnly?: boolean, deferExec?: boolean): Promise<any>;
  postOrders(args: PostOrdersArgs[], postOnly?: boolean, 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[]>;
  calculateMarketPrice(tokenID: string, side: Side, amount: number, orderType?: OrderType): Promise<number>;
  createBuilderApiKey(): Promise<BuilderApiKey>;
  getBuilderApiKeys(): Promise<BuilderApiKeyResponse[]>;
  revokeBuilderApiKey(): Promise<any>;
  getMarketTradesEvents(conditionID: string): Promise<MarketTradeEvent[]>;
  private canL1Auth;
  private canL2Auth;
  private isBuilderOrder;
  private getBuilderTakerFeeRate;
  private adjustBuyAmountForBalance;
  private _ensureMarketInfoCached;
  private ensureBuilderFeeRateCached;
  private _resolveTickSize;
  private _resolveFeeRateBps;
  private resolveVersion;
  private _retryOnVersionUpdate;
  private _isOrderVersionMismatch;
  private throwIfError;
  private get;
  private post;
  private del;
}
//#endregion
export { ClobClient, ClobClientOptions };
//# sourceMappingURL=client.d.cts.map