new ContextClient(options?: ContextClientOptions)

ctx.address: Address | null
ctx.chain: "mainnet" | "testnet"
ctx.chainConfig: ChainConfig
ctx.markets: Markets
ctx.orders: Orders
ctx.portfolio: PortfolioModule
ctx.account: AccountModule
ctx.questions: Questions

ctx.markets.list(params?: SearchMarketsParams): Promise<MarketList>
ctx.markets.search(params: MarketSearchParams): Promise<MarketSearchResult>
ctx.markets.get(id: string): Promise<Market>
ctx.markets.quotes(marketId: string): Promise<Quotes>
ctx.markets.orderbook(
  marketId: string,
  params?: GetOrderbookParams,
): Promise<Orderbook>
ctx.markets.fullOrderbook(
  marketId: string,
  params?: Omit<GetOrderbookParams, "outcomeIndex">,
): Promise<FullOrderbook>
ctx.markets.simulate(
  marketId: string,
  params: SimulateTradeParams,
): Promise<SimulateResult>
ctx.markets.priceHistory(
  marketId: string,
  params?: GetPriceHistoryParams,
): Promise<PriceHistory>
ctx.markets.oracle(marketId: string): Promise<OracleResponse>
ctx.markets.oracleQuotes(marketId: string): Promise<OracleQuotesResponse>
ctx.markets.latestOracleQuote(marketId: string): Promise<OracleQuoteLatest>
ctx.markets.requestOracleQuote(
  marketId: string,
): Promise<OracleQuoteRequestResult>
ctx.markets.activity(
  marketId: string,
  params?: GetActivityParams,
): Promise<ActivityResponse>
ctx.markets.create(questionId: string): Promise<CreateMarketResult>
ctx.markets.globalActivity(params?: GetActivityParams): Promise<ActivityResponse>

ctx.orders.list(params?: GetOrdersParams): Promise<OrderList>
ctx.orders.listAll(params?: Omit<GetOrdersParams, "cursor">): Promise<Order[]>
ctx.orders.mine(marketId?: string): Promise<OrderList>
ctx.orders.allMine(marketId?: string): Promise<Order[]>
ctx.orders.get(id: string): Promise<Order>
ctx.orders.recent(params?: GetRecentOrdersParams): Promise<OrderList>
ctx.orders.simulate(params: OrderSimulateParams): Promise<OrderSimulateResult>

ctx.orders.create(req: PlaceOrderRequest): Promise<CreateOrderResult>
ctx.orders.createMarket(req: PlaceMarketOrderRequest): Promise<CreateOrderResult>
ctx.orders.cancel(
  target: Hex | { nonce: Hex; settlementVersion?: 1 | 2 } | Pick<Order, "nonce" | "settlementVersion">,
): Promise<CancelResult>
ctx.orders.cancelReplace(
  cancelNonce: Hex,
  newOrder: PlaceOrderRequest,
  settlementVersion?: 1 | 2,
): Promise<CancelReplaceResult>
ctx.orders.bulkCreate(orders: PlaceOrderRequest[]): Promise<BulkCreateResult>
ctx.orders.bulkCancel(nonces: Hex[]): Promise<BulkCancelResult>
ctx.orders.bulkCancelOrders(
  orders: Array<Pick<Order, "nonce" | "settlementVersion">>,
): Promise<BulkCancelResult>
ctx.orders.bulk(
  creates: PlaceOrderRequest[],
  cancelNonces: Hex[],
): Promise<BulkResult>

ctx.portfolio.get(
  address?: Address,
  params?: GetPortfolioParams,
): Promise<Portfolio>
ctx.portfolio.positions(
  address?: Address,
  params?: GetPositionsParams,
): Promise<PositionList>
ctx.portfolio.claimable(address?: Address): Promise<ClaimableResponse>
ctx.portfolio.stats(address?: Address): Promise<PortfolioStats>
ctx.portfolio.balance(address?: Address): Promise<Balance>
ctx.portfolio.tokenBalance(
  address: Address,
  tokenAddress: Address,
): Promise<TokenBalance>
ctx.portfolio.settlementBalance(
  address: Address,
  tokenAddress: Address,
): Promise<SettlementBalance>

ctx.account.status(): Promise<AccountStatus>
ctx.account.approveUsdc(): Promise<Hex | null>
ctx.account.approveOperator(): Promise<Hex | null>
ctx.account.setup(): Promise<SetupResult>
ctx.account.deposit(amount: number): Promise<DepositResult>
ctx.account.onchainSetup(): Promise<SetupResult>
ctx.account.onchainDeposit(amount: number): Promise<Hex>
ctx.account.withdraw(amount: number): Promise<Hex>
ctx.account.mintTestUsdc(amount?: number): Promise<MintResult>
ctx.account.mintCompleteSets(marketId: string, amount: number): Promise<Hex>
ctx.account.burnCompleteSets(
  marketId: string,
  amount: number,
  creditInternal?: boolean,
): Promise<Hex>
ctx.account.gaslessSetup(): Promise<GaslessOperatorResult>
ctx.account.gaslessDeposit(amount: number): Promise<GaslessDepositResult>
ctx.account.relayOperatorApproval(
  req: GaslessOperatorRequest,
): Promise<GaslessOperatorResult>
ctx.account.relayDeposit(
  req: GaslessDepositRequest,
): Promise<GaslessDepositResult>

ctx.questions.submit(question: string): Promise<SubmitQuestionResult>
ctx.questions.agentSubmit(
  draft: AgentSubmitMarketDraft,
): Promise<SubmitQuestionResult>
ctx.questions.agentSubmitAndWait(
  draft: AgentSubmitMarketDraft,
  options?: SubmitAndWaitOptions,
): Promise<QuestionSubmission>
ctx.questions.getSubmission(
  submissionId: string,
): Promise<QuestionSubmission>
ctx.questions.submitAndWait(
  question: string,
  options?: SubmitAndWaitOptions,
): Promise<QuestionSubmission>

ctx.migration.getStatus(request?: MigrationAddressRequest): Promise<MigrationStatus>
ctx.migration.start(request?: StartMigrationRequest): Promise<StartMigrationResult>
ctx.migration.migrateFunds(request: SponsoredMigrateFundsRequest): Promise<SponsoredMigrateFundsResult>
ctx.migration.signSponsoredMigrateFunds(status?: MigrationStatus): Promise<SponsoredMigrateFundsRequest>
ctx.migration.restoreOrders(request: RestoreMigrationOrdersRequest): Promise<RestoreMigrationOrdersResult>
ctx.migration.restorePendingOrders(restorations?: PendingMigrationRestoration[]): Promise<RestoreMigrationOrdersResult>
ctx.migration.dismissOrders(request?: DismissMigrationOrdersRequest): Promise<DismissMigrationOrdersResult>
ctx.migration.signAddressAuthorization(
  request: SignMigrationAddressAuthorizationRequest,
): Promise<PublicAddressAuthorization>

encodePriceCents(priceCents: number): bigint
encodeSize(size: number): bigint
calculateMaxFee(price: bigint, size: bigint): bigint
decodePriceCents(raw: bigint): number
decodeSize(raw: bigint): number

resolveChainConfig(chain?: ChainOption): ChainConfig
MAINNET_CONFIG: ChainConfig
TESTNET_CONFIG: ChainConfig

interface PlaceOrderRequest {
  marketId: string
  outcome: "yes" | "no"
  side: "buy" | "sell"
  priceCents: number
  size: number
  buyValue?: number
  expirySeconds?: number
  inventoryModeConstraint?: 0 | 1 | 2  // V1 compatibility
  makerRoleConstraint?: 0 | 1 | 2
  settlementVersion?: 1 | 2             // defaults to 2
  timeInForce?: 0 | 1 | 2               // defaults to GTC
}

interface PlaceMarketOrderRequest {
  marketId: string
  outcome: "yes" | "no"
  side: "buy" | "sell"
  maxPriceCents: number
  maxSize: number
  buyValue?: number
  expirySeconds?: number
  settlementVersion?: 1 | 2
  timeInForce?: 0 | 1 | 2
}

interface Order {
  marketId: string
  trader: string
  nonce: string
  side: 0 | 1
  price: string
  size: string
  filledSize: string
  remainingSize: string
  percentFilled: number
  insertedAt: string
  type: "limit" | "market"
  status: "open" | "filled" | "cancelled" | "expired" | "voided"
  voidedAt: string | null
  voidReason:
    | "UNFILLED_MARKET_ORDER"
    | "UNDER_COLLATERALIZED"
    | "MISSING_OPERATOR_APPROVAL"
    | "BELOW_MIN_FILL_SIZE"
    | "INVALID_SIGNATURE"
    | "MARKET_RESOLVED"
    | "ADMIN_VOID"
    | null
  outcomeIndex: number
  settlementVersion: 1 | 2
}

interface AccountStatus {
  address: `0x${string}`
  ethBalance: bigint
  usdcBalance: bigint
  usdcAllowance: bigint
  isOperatorApproved: boolean
  needsUsdcApproval: boolean
  needsOperatorApproval: boolean
  isReady: boolean
}

interface AgentSubmitMarketDraft {
  market: {
    formattedQuestion: string
    shortQuestion: string
    marketType: "SUBJECTIVE" | "OBJECTIVE"
    evidenceMode: "social_only" | "web_enabled"
    resolutionCriteria: string
    endTime: string
    timezone?: string
    sources?: string[]
    buckets?: Bucket[]
    comparisons?: AgentSubmitComparison[]
    explanation?: string
  }
}

interface Bucket {
  key: string
  label: string
  countBy: "authors" | "events"
  includedAuthors?: string[]
  excludedAuthors?: string[]
  query: string
  instructions: string
  target?: number
  authorOnly?: boolean
  order?: number
}

type AgentSubmitComparison =
  | {
      type: "binary"
      key: string
      label: string
      aKey: string
      bKey: string
      operator?: ">" | ">=" | "==" | "<=" | "<"
      aWeight?: number
      bWeight?: number
      margin?: number
    }
  | {
      type: "max" | "min"
      key: string
      label: string
      bucketKeys: string[]
    }
  | {
      type: "before"
      key: string
      label: string
      aKey: string
      bKey: string
      event?: "firstEvent" | "targetReached"
      requireBoth?: boolean
    }
  | {
      type: "first"
      key: string
      label: string
      bucketKeys: string[]
      event?: "firstEvent" | "targetReached"
    }

interface ContextClientOptions {
  chain?: "mainnet" | "testnet"
  apiKey?: string
  baseUrl?: string
  rpcUrl?: string
  signer?:
    | { privateKey: `0x${string}` }
    | { account: import("viem").Account }
    | { walletClient: import("viem").WalletClient }
}