@polymarket/client 0.0.0-canary-20260421120448

package/dist/types-BcwWqAsH.d.ts

@@ -0,0 +1,4754 @@
+import * as _polymarket_bindings from '@polymarket/bindings';
+import { PaginationCursor, EvmAddress as EvmAddress$1, TokenId, TickSizeValue, ConditionId, TransactionId } from '@polymarket/bindings';
+import { EvmAddress, Prettify, PolymarketError, EvmSignature, HexString, NonEmptyArray, TxHash } from '@polymarket/types';
+import { RelayerTransactionType, RelayerExecuteParams, GaslessTransaction } from '@polymarket/bindings/relayer';
+import { z, ZodError } from 'zod';
+import * as _polymarket_bindings_clob from '@polymarket/bindings/clob';
+import { ClobTrade, NotificationsResponse, BuilderTrade, Prices, OrderBook, LastTradePrice, LastTradePriceForToken, PriceHistoryPoint, CurrentReward, MarketReward, OrdersScoringResponse, UserEarning, TotalUserEarning, UserRewardsEarning, RewardsPercentages, CancelOrdersResponse, OrderSide, OrderType, SignatureType, OrderResponse, OrderResponses, OpenOrder, ApiKeyCreds, BalanceAllowanceResponse } from '@polymarket/bindings/clob';
+import { WalletType, Event, TagReference, Market, Series, Tag, RelatedTag, PublicSearchResponse, SportsMetadata, SportsMarketTypesResponse, Team, PublicProfile, Comment } from '@polymarket/bindings/gamma';
+import { Position, ClosedPosition, Value, Traded, MetaMarketPositionV1, Activity, LeaderboardEntry, BuilderVolumeEntry, TraderLeaderboardEntry, LiveVolume, OpenInterest, MetaHolder, Trade } from '@polymarket/bindings/data';
+import { Hex } from 'ox';
+
+type AccountIdentity = {
+    signer: EvmAddress;
+    wallet: EvmAddress;
+    walletType: WalletType;
+};
+
+declare const PageSizeSchema: z.ZodNumber;
+type Page<T> = {
+    items: T[];
+    hasMore: boolean;
+    nextCursor?: PaginationCursor;
+    totalCount?: number;
+};
+type Paginated<T> = AsyncIterable<Page<T>> & {
+    firstPage(): Promise<Page<T>>;
+    from(cursor?: PaginationCursor): Paginated<T>;
+};
+
+type AccountPublicActions = {
+    /**
+     * Lists current positions for a wallet.
+     *
+     * @throws {@link ListPositionsError}
+     * Thrown on failure.
+     *
+     * @example
+     * Fetch the first page of results:
+     * ```ts
+     * const paginator = client.listPositions({
+     *   user: '0x7c3db723f1d4d8cb9c550095203b686cb11e5c6b',
+     *   pageSize: 10,
+     * });
+     *
+     * const firstPage = await paginator.firstPage();
+     *
+     * // Optionally, fetch additional pages:
+     * for await (const page of paginator.from(firstPage.nextCursor)) {
+     *   // page.items: Position[]
+     * }
+     * ```
+     *
+     * @example
+     * Loop through all pages with `for await`:
+     * ```ts
+     * const paginator = client.listPositions({
+     *   user: '0x7c3db723f1d4d8cb9c550095203b686cb11e5c6b',
+     *   pageSize: 10,
+     * });
+     *
+     * for await (const page of paginator) {
+     *   // page.items: Position[]
+     * }
+     * ```
+     */
+    listPositions(request: ListPositionsRequest): Paginated<Position>;
+    /**
+     * Lists closed positions for a wallet.
+     *
+     * @throws {@link ListClosedPositionsError}
+     * Thrown on failure.
+     *
+     * @example
+     * Fetch the first page of results:
+     * ```ts
+     * const paginator = client.listClosedPositions({
+     *   user: '0x7c3db723f1d4d8cb9c550095203b686cb11e5c6b',
+     *   pageSize: 10,
+     * });
+     *
+     * const firstPage = await paginator.firstPage();
+     *
+     * // Optionally, fetch additional pages:
+     * for await (const page of paginator.from(firstPage.nextCursor)) {
+     *   // page.items: ClosedPosition[]
+     * }
+     * ```
+     *
+     * @example
+     * Loop through all pages with `for await`:
+     * ```ts
+     * const paginator = client.listClosedPositions({
+     *   user: '0x7c3db723f1d4d8cb9c550095203b686cb11e5c6b',
+     *   pageSize: 10,
+     * });
+     *
+     * for await (const page of paginator) {
+     *   // page.items: ClosedPosition[]
+     * }
+     * ```
+     */
+    listClosedPositions(request: ListClosedPositionsRequest): Paginated<ClosedPosition>;
+    /**
+     * Fetches the total value for a wallet's positions.
+     *
+     * @throws {@link FetchPortfolioValueError}
+     * Thrown on failure.
+     *
+     * @example
+     * ```ts
+     * const value = await client.fetchPortfolioValue({
+     *   user: '0x7c3db723f1d4d8cb9c550095203b686cb11e5c6b',
+     * });
+     * ```
+     */
+    fetchPortfolioValue(request: FetchPortfolioValueRequest): Promise<Value[]>;
+    /**
+     * Fetches the total number of markets a wallet has traded.
+     *
+     * @throws {@link FetchTradedMarketCountError}
+     * Thrown on failure.
+     *
+     * @example
+     * ```ts
+     * const traded = await client.fetchTradedMarketCount({
+     *   user: '0x7c3db723f1d4d8cb9c550095203b686cb11e5c6b',
+     * });
+     * ```
+     */
+    fetchTradedMarketCount(request: FetchTradedMarketCountRequest): Promise<Traded>;
+    /**
+     * Downloads an accounting snapshot archive for a wallet.
+     *
+     * @throws {@link DownloadAccountingSnapshotError}
+     * Thrown on failure.
+     *
+     * @example
+     * ```ts
+     * const snapshot = await client.downloadAccountingSnapshot({
+     *   user: '0x7c3db723f1d4d8cb9c550095203b686cb11e5c6b',
+     * });
+     * ```
+     */
+    downloadAccountingSnapshot(request: DownloadAccountingSnapshotRequest): Promise<Blob>;
+    /**
+     * Lists positions for a market.
+     *
+     * @throws {@link ListMarketPositionsError}
+     * Thrown on failure.
+     *
+     * @example
+     * Fetch the first page of results:
+     * ```ts
+     * const paginator = client.listMarketPositions({
+     *   market: '0xe546672750517f62c45a5a00067481981e62b9c20fa8220203232c9dc8fd2093',
+     *   pageSize: 10,
+     * });
+     *
+     * const firstPage = await paginator.firstPage();
+     *
+     * // Optionally, fetch additional pages:
+     * for await (const page of paginator.from(firstPage.nextCursor)) {
+     *   // page.items: MetaMarketPositionV1[]
+     * }
+     * ```
+     *
+     * @example
+     * Loop through all pages with `for await`:
+     * ```ts
+     * const paginator = client.listMarketPositions({
+     *   market: '0xe546672750517f62c45a5a00067481981e62b9c20fa8220203232c9dc8fd2093',
+     *   pageSize: 10,
+     * });
+     *
+     * for await (const page of paginator) {
+     *   // page.items: MetaMarketPositionV1[]
+     * }
+     * ```
+     */
+    listMarketPositions(request: ListMarketPositionsRequest): Paginated<MetaMarketPositionV1>;
+    /**
+     * Lists wallet activity.
+     *
+     * @throws {@link ListActivityError}
+     * Thrown on failure.
+     *
+     * @example
+     * Fetch the first page of results:
+     * ```ts
+     * const paginator = client.listActivity({
+     *   user: '0x7c3db723f1d4d8cb9c550095203b686cb11e5c6b',
+     *   pageSize: 10,
+     * });
+     *
+     * const firstPage = await paginator.firstPage();
+     *
+     * // Optionally, fetch additional pages:
+     * for await (const page of paginator.from(firstPage.nextCursor)) {
+     *   // page.items: Activity[]
+     * }
+     * ```
+     *
+     * @example
+     * Loop through all pages with `for await`:
+     * ```ts
+     * const paginator = client.listActivity({
+     *   user: '0x7c3db723f1d4d8cb9c550095203b686cb11e5c6b',
+     *   pageSize: 10,
+     * });
+     *
+     * for await (const page of paginator) {
+     *   // page.items: Activity[]
+     * }
+     * ```
+     */
+    listActivity(request: ListActivityRequest): Paginated<Activity>;
+};
+type AccountActions = Prettify<AccountPublicActions & {
+    /**
+     * Lists trades for the authenticated account across all pages.
+     *
+     * @throws {@link ListAccountTradesError}
+     * Thrown on failure.
+     *
+     * @example
+     * Fetch the first page of results:
+     * ```ts
+     * const paginator = client.listAccountTrades({
+     *   market: '0x0000000000000000000000000000000000000000000000000000000000000001',
+     * });
+     *
+     * const firstPage = await paginator.firstPage();
+     *
+     * // Optionally, fetch additional pages:
+     * for await (const page of paginator.from(firstPage.nextCursor)) {
+     *   // page.items: ClobTrade[]
+     * }
+     * ```
+     *
+     * @example
+     * Loop through all pages with `for await`:
+     * ```ts
+     * const paginator = client.listAccountTrades({
+     *   market: '0x0000000000000000000000000000000000000000000000000000000000000001',
+     * });
+     *
+     * for await (const page of paginator) {
+     *   // page.items: ClobTrade[]
+     * }
+     * ```
+     */
+    listAccountTrades(request?: ListAccountTradesRequest): Paginated<ClobTrade>;
+    /**
+     * Fetches notifications for the authenticated account.
+     *
+     * @throws {@link FetchNotificationsError}
+     * Thrown on failure.
+     *
+     * @example
+     * ```ts
+     * const notifications = await client.fetchNotifications();
+     * ```
+     */
+    fetchNotifications(): Promise<NotificationsResponse>;
+    /**
+     * Drops notifications for the authenticated account.
+     *
+     * @throws {@link DropNotificationsError}
+     * Thrown on failure.
+     *
+     * @example
+     * ```ts
+     * await client.dropNotifications({
+     *   ids: ['1', '2'],
+     * });
+     * ```
+     */
+    dropNotifications(request: DropNotificationsRequest): Promise<void>;
+    /**
+     * Fetches whether the account is restricted to closed-only trading.
+     *
+     * @throws {@link FetchClosedOnlyModeError}
+     * Thrown on failure.
+     *
+     * @example
+     * ```ts
+     * const closedOnly = await client.fetchClosedOnlyMode();
+     * ```
+     */
+    fetchClosedOnlyMode(): Promise<boolean>;
+}>;
+declare function accountActions(client: BasePublicClient): AccountPublicActions;
+declare function accountActions(client: BaseSecureClient): AccountActions;
+
+type AnalyticsActions = {
+    /**
+     * Lists builder-attributed trades.
+     *
+     * @throws {@link ListBuilderTradesError}
+     * Thrown on failure.
+     *
+     * @example
+     * Fetch the first page of results:
+     * ```ts
+     * const paginator = client.listBuilderTrades({
+     *   pageSize: 10,
+     * });
+     *
+     * const firstPage = await paginator.firstPage();
+     *
+     * // Optionally, fetch additional pages:
+     * for await (const page of paginator.from(firstPage.nextCursor)) {
+     *   // page.items: BuilderTrade[]
+     * }
+     * ```
+     *
+     * @example
+     * Loop through all pages with `for await`:
+     * ```ts
+     * const paginator = client.listBuilderTrades({
+     *   pageSize: 10,
+     * });
+     *
+     * for await (const page of paginator) {
+     *   // page.items: BuilderTrade[]
+     * }
+     * ```
+     */
+    listBuilderTrades(request?: ListBuilderTradesRequest): Paginated<BuilderTrade>;
+    /**
+     * Lists builder leaderboard rankings.
+     *
+     * @throws {@link ListBuilderLeaderboardError}
+     * Thrown on failure.
+     *
+     * @example
+     * Fetch the first page of results:
+     * ```ts
+     * const paginator = client.listBuilderLeaderboard({
+     *   pageSize: 10,
+     *   timePeriod: 'DAY',
+     * });
+     *
+     * const firstPage = await paginator.firstPage();
+     *
+     * // Optionally, fetch additional pages:
+     * for await (const page of paginator.from(firstPage.nextCursor)) {
+     *   // page.items: LeaderboardEntry[]
+     * }
+     * ```
+     *
+     * @example
+     * Loop through all pages with `for await`:
+     * ```ts
+     * const paginator = client.listBuilderLeaderboard({
+     *   pageSize: 10,
+     *   timePeriod: 'DAY',
+     * });
+     *
+     * for await (const page of paginator) {
+     *   // page.items: LeaderboardEntry[]
+     * }
+     * ```
+     */
+    listBuilderLeaderboard(request?: ListBuilderLeaderboardRequest): Paginated<LeaderboardEntry>;
+    /**
+     * Lists daily builder volume entries.
+     *
+     * @throws {@link ListBuilderVolumeError}
+     * Thrown on failure.
+     *
+     * @example
+     * ```ts
+     * const volume = await client.fetchBuilderVolume({
+     *   timePeriod: 'DAY',
+     * });
+     * ```
+     */
+    fetchBuilderVolume(request?: ListBuilderVolumeRequest): Promise<BuilderVolumeEntry[]>;
+    /**
+     * Lists trader leaderboard rankings.
+     *
+     * @throws {@link ListTraderLeaderboardError}
+     * Thrown on failure.
+     *
+     * @example
+     * Fetch the first page of results:
+     * ```ts
+     * const paginator = client.listTraderLeaderboard({
+     *   orderBy: 'PNL',
+     *   pageSize: 10,
+     *   timePeriod: 'DAY',
+     * });
+     *
+     * const firstPage = await paginator.firstPage();
+     *
+     * // Optionally, fetch additional pages:
+     * for await (const page of paginator.from(firstPage.nextCursor)) {
+     *   // page.items: TraderLeaderboardEntry[]
+     * }
+     * ```
+     *
+     * @example
+     * Loop through all pages with `for await`:
+     * ```ts
+     * const paginator = client.listTraderLeaderboard({
+     *   orderBy: 'PNL',
+     *   pageSize: 10,
+     *   timePeriod: 'DAY',
+     * });
+     *
+     * for await (const page of paginator) {
+     *   // page.items: TraderLeaderboardEntry[]
+     * }
+     * ```
+     */
+    listTraderLeaderboard(request?: ListTraderLeaderboardRequest): Paginated<TraderLeaderboardEntry>;
+};
+declare function analyticsActions(client: BasePublicClient): AnalyticsActions;
+declare function analyticsActions(client: BaseSecureClient): AnalyticsActions;
+
+type DataActions = {
+    /**
+     * Fetches live volume for an event.
+     *
+     * @throws {@link FetchEventLiveVolumeError}
+     * Thrown on failure.
+     *
+     * @example
+     * ```ts
+     * const volume = await client.fetchEventLiveVolume({ id: '123' });
+     * ```
+     */
+    fetchEventLiveVolume(request: FetchEventLiveVolumeRequest): Promise<LiveVolume[]>;
+    /**
+     * Fetches the midpoint price for a token.
+     *
+     * @throws {@link FetchMidpointError}
+     * Thrown on failure.
+     *
+     * @example
+     * ```ts
+     * const midpoint = await client.fetchMidpoint({ tokenId: '123' });
+     * ```
+     */
+    fetchMidpoint(request: FetchMidpointRequest): Promise<string>;
+    /**
+     * Fetches midpoint prices for multiple tokens.
+     *
+     * @throws {@link FetchMidpointsError}
+     * Thrown on failure.
+     *
+     * @example
+     * ```ts
+     * const midpoints = await client.fetchMidpoints([{ tokenId: '123' }]);
+     * ```
+     */
+    fetchMidpoints(request: FetchMidpointsRequest): Promise<Record<string, string>>;
+    /**
+     * Fetches the current quoted price for a token and side.
+     *
+     * @throws {@link FetchPriceError}
+     * Thrown on failure.
+     *
+     * @example
+     * ```ts
+     * const price = await client.fetchPrice({ tokenId: '123', side: OrderSide.BUY });
+     * ```
+     */
+    fetchPrice(request: FetchPriceRequest): Promise<string>;
+    /**
+     * Fetches quoted prices for multiple tokens.
+     *
+     * @throws {@link FetchPricesError}
+     * Thrown on failure.
+     *
+     * @example
+     * ```ts
+     * const prices = await client.fetchPrices([{ tokenId: '123', side: OrderSide.BUY }]);
+     * ```
+     */
+    fetchPrices(request: FetchPricesRequest): Promise<Prices>;
+    /**
+     * Fetches the current order book for a token.
+     *
+     * @throws {@link FetchOrderBookError}
+     * Thrown on failure.
+     *
+     * @example
+     * ```ts
+     * const book = await client.fetchOrderBook({ tokenId: '123' });
+     * ```
+     */
+    fetchOrderBook(request: FetchOrderBookRequest): Promise<OrderBook>;
+    /**
+     * Fetches order books for multiple tokens.
+     *
+     * @throws {@link FetchOrderBooksError}
+     * Thrown on failure.
+     *
+     * @example
+     * ```ts
+     * const books = await client.fetchOrderBooks([{ tokenId: '123' }]);
+     * ```
+     */
+    fetchOrderBooks(request: FetchOrderBooksRequest): Promise<OrderBook[]>;
+    /**
+     * Fetches the spread for a token.
+     *
+     * @throws {@link FetchSpreadError}
+     * Thrown on failure.
+     *
+     * @example
+     * ```ts
+     * const spread = await client.fetchSpread({ tokenId: '123' });
+     * ```
+     */
+    fetchSpread(request: FetchSpreadRequest): Promise<string>;
+    /**
+     * Fetches spreads for multiple tokens.
+     *
+     * @throws {@link FetchSpreadsError}
+     * Thrown on failure.
+     *
+     * @example
+     * ```ts
+     * const spreads = await client.fetchSpreads([{ tokenId: '123' }]);
+     * ```
+     */
+    fetchSpreads(request: FetchSpreadsRequest): Promise<Record<string, string>>;
+    /**
+     * Fetches the last traded price for a token.
+     *
+     * @throws {@link FetchLastTradePriceError}
+     * Thrown on failure.
+     *
+     * @example
+     * ```ts
+     * const price = await client.fetchLastTradePrice({ tokenId: '123' });
+     * ```
+     */
+    fetchLastTradePrice(request: FetchLastTradePriceRequest): Promise<LastTradePrice>;
+    /**
+     * Fetches last traded prices for multiple tokens.
+     *
+     * @throws {@link FetchLastTradePricesError}
+     * Thrown on failure.
+     *
+     * @example
+     * ```ts
+     * const prices = await client.fetchLastTradePrices([{ tokenId: '123' }]);
+     * ```
+     */
+    fetchLastTradePrices(request: FetchLastTradePricesRequest): Promise<LastTradePriceForToken[]>;
+    /**
+     * Fetches historical price points for a token.
+     *
+     * @throws {@link FetchPriceHistoryError}
+     * Thrown on failure.
+     *
+     * @example
+     * ```ts
+     * const history = await client.fetchPriceHistory({ tokenId: '123', interval: '1d' });
+     * ```
+     */
+    fetchPriceHistory(request: FetchPriceHistoryRequest): Promise<PriceHistoryPoint[]>;
+    /**
+     * Estimates the price level a market order would cross at current book depth.
+     *
+     * For BUY orders, `amount` is the amount of collateral to spend. For SELL orders,
+     * `amount` is the number of shares to sell.
+     *
+     * @throws {@link EstimateMarketPriceError}
+     * Thrown on failure.
+     *
+     * @example
+     * ```ts
+     * const price = await client.estimateMarketPrice({
+     *   tokenId: '123',
+     *   side: OrderSide.BUY,
+     *   amount: 10,
+     * });
+     * ```
+     */
+    estimateMarketPrice(request: EstimateMarketPriceRequest): Promise<number>;
+    /**
+     * Lists open interest for one or more markets.
+     *
+     * @throws {@link ListOpenInterestError}
+     * Thrown on failure.
+     *
+     * @example
+     * ```ts
+     * const openInterest = await client.listOpenInterest({
+     *   market: ['0xe546672750517f62c45a5a00067481981e62b9c20fa8220203232c9dc8fd2093'],
+     * });
+     * ```
+     */
+    listOpenInterest(request?: ListOpenInterestRequest): Promise<OpenInterest[]>;
+    /**
+     * Lists the top holders for one or more markets.
+     *
+     * @throws {@link ListMarketHoldersError}
+     * Thrown on failure.
+     *
+     * @example
+     * ```ts
+     * const holders = await client.listMarketHolders({
+     *   market: ['0xe546672750517f62c45a5a00067481981e62b9c20fa8220203232c9dc8fd2093'],
+     *   limit: 5,
+     * });
+     * ```
+     */
+    listMarketHolders(request: ListMarketHoldersRequest): Promise<MetaHolder[]>;
+    /**
+     * Lists trades for a wallet, market, or event.
+     *
+     * @throws {@link ListTradesError}
+     * Thrown on failure.
+     *
+     * @example
+     * Fetch the first page of results:
+     * ```ts
+     * const paginator = client.listTrades({
+     *   user: '0x7c3db723f1d4d8cb9c550095203b686cb11e5c6b',
+     *   pageSize: 10,
+     * });
+     *
+     * const firstPage = await paginator.firstPage();
+     *
+     * // Optionally, fetch additional pages:
+     * for await (const page of paginator.from(firstPage.nextCursor)) {
+     *   // page.items: Trade[]
+     * }
+     * ```
+     *
+     * @example
+     * Loop through all pages with `for await`:
+     * ```ts
+     * const paginator = client.listTrades({
+     *   user: '0x7c3db723f1d4d8cb9c550095203b686cb11e5c6b',
+     *   pageSize: 10,
+     * });
+     *
+     * for await (const page of paginator) {
+     *   // page.items: Trade[]
+     * }
+     * ```
+     */
+    listTrades(request?: ListTradesRequest): Paginated<Trade>;
+};
+declare function dataActions(client: BasePublicClient): DataActions;
+declare function dataActions(client: BaseSecureClient): DataActions;
+
+type DiscoveryActions = {
+    /**
+     * Lists events.
+     *
+     * @throws {@link ListEventsError}
+     * Thrown on failure.
+     *
+     * @example
+     * Fetch the first page of results:
+     * ```ts
+     * const paginator = client.listEvents({
+     *   pageSize: 10,
+     * });
+     *
+     * const firstPage = await paginator.firstPage();
+     *
+     * // Optionally, fetch additional pages:
+     * for await (const page of paginator.from(firstPage.nextCursor)) {
+     *   // page.items: Event[]
+     * }
+     * ```
+     *
+     * @example
+     * Loop through all pages with `for await`:
+     * ```ts
+     * const paginator = client.listEvents({
+     *   pageSize: 10,
+     * });
+     *
+     * for await (const page of paginator) {
+     *   // page.items: Event[]
+     * }
+     * ```
+     */
+    listEvents(request?: ListEventsRequest): Paginated<Event>;
+    /**
+     * Fetches an event.
+     *
+     * @throws {@link FetchEventError}
+     * Thrown on failure.
+     *
+     * @example
+     * ```ts
+     * const event = await client.fetchEvent({
+     *   id: '123',
+     * });
+     * ```
+     */
+    fetchEvent(request: FetchEventRequest): Promise<Event>;
+    /**
+     * Fetches an event's tags.
+     *
+     * @throws {@link FetchEventTagsError}
+     * Thrown on failure.
+     *
+     * @example
+     * ```ts
+     * const tags = await client.fetchEventTags({
+     *   id: '123',
+     * });
+     * ```
+     */
+    fetchEventTags(request: FetchEventTagsRequest): Promise<TagReference[]>;
+    /**
+     * Lists markets.
+     *
+     * @throws {@link ListMarketsError}
+     * Thrown on failure.
+     *
+     * @example
+     * Fetch the first page of results:
+     * ```ts
+     * const paginator = client.listMarkets({
+     *   closed: false,
+     *   pageSize: 10,
+     * });
+     *
+     * const firstPage = await paginator.firstPage();
+     *
+     * // Optionally, fetch additional pages:
+     * for await (const page of paginator.from(firstPage.nextCursor)) {
+     *   // page.items: Market[]
+     * }
+     * ```
+     *
+     * @example
+     * Loop through all pages with `for await`:
+     * ```ts
+     * const paginator = client.listMarkets({
+     *   closed: false,
+     *   pageSize: 10,
+     * });
+     *
+     * for await (const page of paginator) {
+     *   // page.items: Market[]
+     * }
+     * ```
+     */
+    listMarkets(request?: ListMarketsRequest): Paginated<Market>;
+    /**
+     * Fetches a market.
+     *
+     * @throws {@link FetchMarketError}
+     * Thrown on failure.
+     *
+     * @example
+     * ```ts
+     * const market = await client.fetchMarket({
+     *   id: '12345',
+     * });
+     * ```
+     */
+    fetchMarket(request: FetchMarketRequest): Promise<Market>;
+    /**
+     * Fetches a market's tags.
+     *
+     * @throws {@link FetchMarketTagsError}
+     * Thrown on failure.
+     *
+     * @example
+     * ```ts
+     * const tags = await client.fetchMarketTags({
+     *   id: '12345',
+     * });
+     * ```
+     */
+    fetchMarketTags(request: FetchMarketTagsRequest): Promise<TagReference[]>;
+    /**
+     * Lists series.
+     *
+     * @throws {@link ListSeriesError}
+     * Thrown on failure.
+     *
+     * @example
+     * Fetch the first page of results:
+     * ```ts
+     * const paginator = client.listSeries({
+     *   pageSize: 10,
+     * });
+     *
+     * const firstPage = await paginator.firstPage();
+     *
+     * // Optionally, fetch additional pages:
+     * for await (const page of paginator.from(firstPage.nextCursor)) {
+     *   // page.items: Series[]
+     * }
+     * ```
+     *
+     * @example
+     * Loop through all pages with `for await`:
+     * ```ts
+     * const paginator = client.listSeries({
+     *   pageSize: 10,
+     * });
+     *
+     * for await (const page of paginator) {
+     *   // page.items: Series[]
+     * }
+     * ```
+     */
+    listSeries(request?: ListSeriesRequest): Paginated<Series>;
+    /**
+     * Fetches a series.
+     *
+     * @throws {@link FetchSeriesError}
+     * Thrown on failure.
+     *
+     * @example
+     * ```ts
+     * const series = await client.fetchSeries({
+     *   id: '123',
+     * });
+     * ```
+     */
+    fetchSeries(request: FetchSeriesRequest): Promise<Series>;
+    /**
+     * Lists tags.
+     *
+     * @throws {@link ListTagsError}
+     * Thrown on failure.
+     *
+     * @example
+     * Fetch the first page of results:
+     * ```ts
+     * const paginator = client.listTags({
+     *   pageSize: 10,
+     * });
+     *
+     * const firstPage = await paginator.firstPage();
+     *
+     * // Optionally, fetch additional pages:
+     * for await (const page of paginator.from(firstPage.nextCursor)) {
+     *   // page.items: Tag[]
+     * }
+     * ```
+     *
+     * @example
+     * Loop through all pages with `for await`:
+     * ```ts
+     * const paginator = client.listTags({
+     *   pageSize: 10,
+     * });
+     *
+     * for await (const page of paginator) {
+     *   // page.items: Tag[]
+     * }
+     * ```
+     */
+    listTags(request?: ListTagsRequest): Paginated<Tag>;
+    /**
+     * Fetches a tag by id or slug.
+     *
+     * @throws {@link FetchTagError}
+     * Thrown on failure.
+     *
+     * @example
+     * ```ts
+     * const tag = await client.fetchTag({
+     *   slug: 'politics',
+     * });
+     * ```
+     */
+    fetchTag(request: FetchTagRequest): Promise<Tag>;
+    /**
+     * Fetches related tag relationships by id or slug.
+     *
+     * @throws {@link FetchRelatedTagsError}
+     * Thrown on failure.
+     *
+     * @example
+     * ```ts
+     * const related = await client.fetchRelatedTags({
+     *   slug: 'politics',
+     * });
+     * ```
+     */
+    fetchRelatedTags(request: FetchRelatedTagsRequest): Promise<RelatedTag[]>;
+    /**
+     * Fetches resources linked from related tag relationships by id or slug.
+     *
+     * @throws {@link FetchRelatedTagResourcesError}
+     * Thrown on failure.
+     *
+     * @example
+     * ```ts
+     * const resources = await client.fetchRelatedTagResources({
+     *   slug: 'politics',
+     * });
+     * ```
+     */
+    fetchRelatedTagResources(request: FetchRelatedTagResourcesRequest): Promise<Tag[]>;
+    /**
+     * Runs a public full-text search.
+     *
+     * @throws {@link SearchError}
+     * Thrown on failure.
+     *
+     * @example
+     * ```ts
+     * const results = await client.search({
+     *   query: 'election',
+     * });
+     * ```
+     */
+    search(request: SearchRequest): Promise<PublicSearchResponse>;
+    /**
+     * Lists available sports metadata.
+     *
+     * @throws {@link ListSportsError}
+     * Thrown on failure.
+     *
+     * @example
+     * ```ts
+     * const sports = await client.listSports();
+     * ```
+     */
+    listSports(): Promise<SportsMetadata[]>;
+    /**
+     * Fetches the available market types grouped by sport.
+     *
+     * @throws {@link FetchSportsMarketTypesError}
+     * Thrown on failure.
+     *
+     * @example
+     * ```ts
+     * const marketTypes = await client.fetchSportsMarketTypes();
+     * ```
+     */
+    fetchSportsMarketTypes(): Promise<SportsMarketTypesResponse>;
+    /**
+     * Lists teams.
+     *
+     * @throws {@link ListTeamsError}
+     * Thrown on failure.
+     *
+     * @example
+     * Fetch the first page of results:
+     * ```ts
+     * const paginator = client.listTeams({
+     *   pageSize: 10,
+     * });
+     *
+     * const firstPage = await paginator.firstPage();
+     *
+     * // Optionally, fetch additional pages:
+     * for await (const page of paginator.from(firstPage.nextCursor)) {
+     *   // page.items: Team[]
+     * }
+     * ```
+     *
+     * @example
+     * Loop through all pages with `for await`:
+     * ```ts
+     * const paginator = client.listTeams({
+     *   pageSize: 10,
+     * });
+     *
+     * for await (const page of paginator) {
+     *   // page.items: Team[]
+     * }
+     * ```
+     */
+    listTeams(request?: ListTeamsRequest): Paginated<Team>;
+    /**
+     * Fetches a public profile by wallet address.
+     *
+     * @throws {@link FetchPublicProfileError}
+     * Thrown on failure.
+     *
+     * @example
+     * ```ts
+     * const profile = await client.fetchPublicProfile({
+     *   address: '0x1234...',
+     * });
+     * ```
+     */
+    fetchPublicProfile(request: FetchPublicProfileRequest): Promise<PublicProfile | null>;
+    /**
+     * Lists comments for an event or series.
+     *
+     * @throws {@link ListCommentsError}
+     * Thrown on failure.
+     *
+     * @example
+     * Fetch the first page of results:
+     * ```ts
+     * const paginator = client.listComments({
+     *   parentEntityId: '123',
+     *   parentEntityType: 'Event',
+     *   pageSize: 20,
+     * });
+     *
+     * const firstPage = await paginator.firstPage();
+     *
+     * // Optionally, fetch additional pages:
+     * for await (const page of paginator.from(firstPage.nextCursor)) {
+     *   // page.items: Comment[]
+     * }
+     * ```
+     *
+     * @example
+     * Loop through all pages with `for await`:
+     * ```ts
+     * const paginator = client.listComments({
+     *   parentEntityId: '123',
+     *   parentEntityType: 'Event',
+     *   pageSize: 20,
+     * });
+     *
+     * for await (const page of paginator) {
+     *   // page.items: Comment[]
+     * }
+     * ```
+     */
+    listComments(request: ListCommentsRequest): Paginated<Comment>;
+    /**
+     * Fetches a comment thread by comment id.
+     *
+     * @throws {@link FetchCommentsByIdError}
+     * Thrown on failure.
+     *
+     * @example
+     * ```ts
+     * const thread = await client.fetchCommentsById({
+     *   id: '456',
+     *   getPositions: true,
+     * });
+     * ```
+     */
+    fetchCommentsById(request: FetchCommentsByIdRequest): Promise<Comment[]>;
+    /**
+     * Lists comments written by a wallet address.
+     *
+     * @throws {@link ListCommentsByUserAddressError}
+     * Thrown on failure.
+     *
+     * @example
+     * Fetch the first page of results:
+     * ```ts
+     * const paginator = client.listCommentsByUserAddress({
+     *   address: '0x1234...',
+     *   pageSize: 10,
+     *   order: 'DESC',
+     * });
+     *
+     * const firstPage = await paginator.firstPage();
+     *
+     * // Optionally, fetch additional pages:
+     * for await (const page of paginator.from(firstPage.nextCursor)) {
+     *   // page.items: Comment[]
+     * }
+     * ```
+     *
+     * @example
+     * Loop through all pages with `for await`:
+     * ```ts
+     * const paginator = client.listCommentsByUserAddress({
+     *   address: '0x1234...',
+     *   pageSize: 10,
+     *   order: 'DESC',
+     * });
+     *
+     * for await (const page of paginator) {
+     *   // page.items: Comment[]
+     * }
+     * ```
+     */
+    listCommentsByUserAddress(request: ListCommentsByUserAddressRequest): Paginated<Comment>;
+};
+declare function discoveryActions(client: BasePublicClient): DiscoveryActions;
+declare function discoveryActions(client: BaseSecureClient): DiscoveryActions;
+
+type RewardsPublicActions = {
+    /**
+     * Lists current active market rewards.
+     *
+     * @throws {@link ListCurrentRewardsError}
+     * Thrown on failure.
+     *
+     * @example
+     * Fetch the first page of results:
+     * ```ts
+     * const paginator = client.listCurrentRewards();
+     *
+     * const firstPage = await paginator.firstPage();
+     *
+     * // Optionally, fetch additional pages:
+     * for await (const page of paginator.from(firstPage.nextCursor)) {
+     *   // page.items: CurrentReward[]
+     * }
+     * ```
+     *
+     * @example
+     * Loop through all pages with `for await`:
+     * ```ts
+     * const paginator = client.listCurrentRewards();
+     *
+     * for await (const page of paginator) {
+     *   // page.items: CurrentReward[]
+     * }
+     * ```
+     */
+    listCurrentRewards(request?: ListCurrentRewardsRequest): Paginated<CurrentReward>;
+    /**
+     * Lists reward configurations for a market.
+     *
+     * @throws {@link ListMarketRewardsError}
+     * Thrown on failure.
+     *
+     * @example
+     * Fetch the first page of results:
+     * ```ts
+     * const paginator = client.listMarketRewards({
+     *   conditionId:
+     *     '0xbd31dc8a20211944f6b70f31557f1001557b59905b7738480ca09bd4532f84af',
+     * });
+     *
+     * const firstPage = await paginator.firstPage();
+     *
+     * // Optionally, fetch additional pages:
+     * for await (const page of paginator.from(firstPage.nextCursor)) {
+     *   // page.items: MarketReward[]
+     * }
+     * ```
+     *
+     * @example
+     * Loop through all pages with `for await`:
+     * ```ts
+     * const paginator = client.listMarketRewards({
+     *   conditionId:
+     *     '0xbd31dc8a20211944f6b70f31557f1001557b59905b7738480ca09bd4532f84af',
+     * });
+     *
+     * for await (const page of paginator) {
+     *   // page.items: MarketReward[]
+     * }
+     * ```
+     */
+    listMarketRewards(request: ListMarketRewardsRequest): Paginated<MarketReward>;
+};
+type RewardsActions = Prettify<RewardsPublicActions & {
+    /**
+     * Fetches whether a single order is currently scoring.
+     *
+     * @throws {@link FetchOrderScoringError}
+     * Thrown on failure.
+     *
+     * @example
+     * ```ts
+     * const scoring = await client.fetchOrderScoring({
+     *   orderId: '123',
+     * });
+     * ```
+     */
+    fetchOrderScoring(request: FetchOrderScoringRequest): Promise<boolean>;
+    /**
+     * Fetches scoring state for multiple orders.
+     *
+     * @throws {@link FetchOrdersScoringError}
+     * Thrown on failure.
+     *
+     * @example
+     * ```ts
+     * const scoring = await client.fetchOrdersScoring({
+     *   orderIds: ['1', '2'],
+     * });
+     * ```
+     */
+    fetchOrdersScoring(request: FetchOrdersScoringRequest): Promise<OrdersScoringResponse>;
+    /**
+     * Lists per-market earnings for the authenticated account on a given day.
+     *
+     * @throws {@link ListUserEarningsForDayError}
+     * Thrown on failure.
+     *
+     * @example
+     * Fetch the first page of results:
+     * ```ts
+     * const paginator = client.listUserEarningsForDay({
+     *   date: '2026-04-16',
+     * });
+     *
+     * const firstPage = await paginator.firstPage();
+     *
+     * // Optionally, fetch additional pages:
+     * for await (const page of paginator.from(firstPage.nextCursor)) {
+     *   // page.items: UserEarning[]
+     * }
+     * ```
+     *
+     * @example
+     * Loop through all pages with `for await`:
+     * ```ts
+     * const paginator = client.listUserEarningsForDay({
+     *   date: '2026-04-16',
+     * });
+     *
+     * for await (const page of paginator) {
+     *   // page.items: UserEarning[]
+     * }
+     * ```
+     */
+    listUserEarningsForDay(request: ListUserEarningsForDayRequest): Paginated<UserEarning>;
+    /**
+     * Fetches total earnings for the authenticated account on a given day.
+     *
+     * @throws {@link FetchTotalEarningsForUserForDayError}
+     * Thrown on failure.
+     *
+     * @example
+     * ```ts
+     * const earnings = await client.fetchTotalEarningsForUserForDay({
+     *   date: '2026-04-16',
+     * });
+     * ```
+     */
+    fetchTotalEarningsForUserForDay(request: FetchTotalEarningsForUserForDayRequest): Promise<TotalUserEarning[]>;
+    /**
+     * Lists market reward configuration and earnings for the authenticated account on a given day.
+     *
+     * @throws {@link ListUserEarningsAndMarketsConfigError}
+     * Thrown on failure.
+     *
+     * @example
+     * Fetch the first page of results:
+     * ```ts
+     * const paginator = client.listUserEarningsAndMarketsConfig({
+     *   date: '2026-04-16',
+     * });
+     *
+     * const firstPage = await paginator.firstPage();
+     *
+     * // Optionally, fetch additional pages:
+     * for await (const page of paginator.from(firstPage.nextCursor)) {
+     *   // page.items: UserRewardsEarning[]
+     * }
+     * ```
+     *
+     * @example
+     * Loop through all pages with `for await`:
+     * ```ts
+     * const paginator = client.listUserEarningsAndMarketsConfig({
+     *   date: '2026-04-16',
+     * });
+     *
+     * for await (const page of paginator) {
+     *   // page.items: UserRewardsEarning[]
+     * }
+     * ```
+     */
+    listUserEarningsAndMarketsConfig(request: ListUserEarningsAndMarketsConfigRequest): Paginated<UserRewardsEarning>;
+    /**
+     * Fetches reward percentages for the authenticated account.
+     *
+     * @throws {@link FetchRewardPercentagesError}
+     * Thrown on failure.
+     *
+     * @example
+     * ```ts
+     * const percentages = await client.fetchRewardPercentages();
+     * ```
+     */
+    fetchRewardPercentages(): Promise<RewardsPercentages>;
+}>;
+declare function rewardsActions(client: BasePublicClient): RewardsPublicActions;
+declare function rewardsActions(client: BaseSecureClient): RewardsActions;
+
+type ResponseValidationContext = {
+    endpoint: string;
+};
+
+/**
+ * Error thrown when an action input fails SDK validation before a request is
+ * sent.
+ */
+declare class UserInputError extends PolymarketError {
+    name: "UserInputError";
+    constructor(message: string, options?: ErrorOptions);
+    static fromZodError(error: ZodError): UserInputError;
+}
+/**
+ * Error thrown when a service response does not match the action's expected
+ * response shape.
+ */
+declare class UnexpectedResponseError extends PolymarketError {
+    name: "UnexpectedResponseError";
+    constructor(message: string, options?: ErrorOptions);
+    static fromZodError(error: ZodError, context: ResponseValidationContext): UnexpectedResponseError;
+}
+/**
+ * Error thrown when the SDK cannot complete a request because of a network or
+ * runtime transport failure.
+ */
+declare class TransportError extends PolymarketError {
+    name: "TransportError";
+    constructor(message: string, options?: ErrorOptions);
+    static fromError(error: unknown): TransportError;
+}
+type RequestRejectedErrorOptions = {
+    status: number;
+};
+/**
+ * Error thrown when a service responds with a non-success status other than
+ * rate limiting.
+ */
+declare class RequestRejectedError extends PolymarketError {
+    name: "RequestRejectedError";
+    readonly status: number;
+    constructor(message: string, options: ErrorOptions & RequestRejectedErrorOptions);
+}
+/**
+ * Error thrown when the service rejects a request because the rate limit has
+ * been exceeded.
+ */
+declare class RateLimitError extends PolymarketError {
+    name: "RateLimitError";
+}
+/**
+ * Error thrown when an async wait operation exceeds its allotted polling time.
+ */
+declare class TimeoutError extends PolymarketError {
+    name: "TimeoutError";
+    constructor(message: string, options?: ErrorOptions);
+}
+/**
+ * Error thrown when a submitted transaction reaches a terminal failure state.
+ */
+declare class TransactionFailedError extends PolymarketError {
+    name: "TransactionFailedError";
+    constructor(message: string, options?: ErrorOptions);
+}
+/**
+ * Error thrown when the user cancels a required wallet signing action.
+ */
+declare class CancelledSigningError extends PolymarketError {
+    name: "CancelledSigningError";
+    constructor(message: string, options?: ErrorOptions);
+    static fromError(error: Error): CancelledSigningError;
+}
+/**
+ * Error thrown when there is not enough resting market liquidity to satisfy the
+ * requested execution semantics.
+ */
+declare class InsufficientLiquidityError extends PolymarketError {
+    name: "InsufficientLiquidityError";
+    constructor(message: string, options?: ErrorOptions);
+}
+/**
+ * Error thrown when the SDK cannot produce a required signature or
+ * authentication payload.
+ */
+declare class SigningError extends PolymarketError {
+    name: "SigningError";
+    constructor(message: string, options?: ErrorOptions);
+    static fromError(error: unknown, message?: string): SigningError;
+}
+
+declare const CancelOrderRequestSchema: z.ZodObject<{
+    orderId: z.ZodString;
+}, z.core.$strip>;
+declare const CancelOrdersRequestSchema: z.ZodObject<{
+    orderIds: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+declare const CancelMarketOrdersRequestSchema: z.ZodObject<{
+    assetId: z.ZodOptional<z.ZodString>;
+    market: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type CancelOrderRequest = z.input<typeof CancelOrderRequestSchema>;
+type CancelOrderError = RequestRejectedError | RateLimitError | SigningError | TransportError | UnexpectedResponseError | UserInputError;
+/**
+ * Cancels a single open order for the authenticated account.
+ *
+ * @throws {@link CancelOrderError}
+ * Thrown on failure.
+ *
+ * @example
+ * ```ts
+ * const response = await cancelOrder(client, {
+ *   orderId: '123',
+ * });
+ *
+ * // response.canceled: string[]
+ * ```
+ */
+declare function cancelOrder(client: BaseSecureClient, request: CancelOrderRequest): Promise<CancelOrdersResponse>;
+type CancelOrdersRequest = z.input<typeof CancelOrdersRequestSchema>;
+type CancelOrdersError = RequestRejectedError | RateLimitError | SigningError | TransportError | UnexpectedResponseError | UserInputError;
+/**
+ * Cancels multiple open orders for the authenticated account.
+ *
+ * @throws {@link CancelOrdersError}
+ * Thrown on failure.
+ *
+ * @example
+ * ```ts
+ * const response = await cancelOrders(client, {
+ *   orderIds: ['1', '2'],
+ * });
+ *
+ * // response.canceled: string[]
+ * ```
+ */
+declare function cancelOrders(client: BaseSecureClient, request: CancelOrdersRequest): Promise<CancelOrdersResponse>;
+type CancelAllError = RequestRejectedError | RateLimitError | SigningError | TransportError | UnexpectedResponseError;
+/**
+ * Cancels all open orders for the authenticated account.
+ *
+ * @throws {@link CancelAllError}
+ * Thrown on failure.
+ *
+ * @example
+ * ```ts
+ * const response = await cancelAll(client);
+ *
+ * // response.canceled: string[]
+ * ```
+ */
+declare function cancelAll(client: BaseSecureClient): Promise<CancelOrdersResponse>;
+type CancelMarketOrdersRequest = z.input<typeof CancelMarketOrdersRequestSchema>;
+type CancelMarketOrdersError = RequestRejectedError | RateLimitError | SigningError | TransportError | UnexpectedResponseError | UserInputError;
+/**
+ * Cancels all open orders for the authenticated account that match the market
+ * or asset filter.
+ *
+ * @throws {@link CancelMarketOrdersError}
+ * Thrown on failure.
+ *
+ * @example
+ * ```ts
+ * const response = await cancelMarketOrders(client, {
+ *   market: '0x0000000000000000000000000000000000000000000000000000000000000001',
+ * });
+ *
+ * // response.canceled: string[]
+ * ```
+ */
+declare function cancelMarketOrders(client: BaseSecureClient, request: CancelMarketOrdersRequest): Promise<CancelOrdersResponse>;
+
+declare const EstimateMarketPriceRequestSchema: z.ZodObject<{
+    tokenId: z.ZodString;
+    amount: z.ZodNumber;
+    side: z.ZodEnum<typeof OrderSide>;
+    orderType: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<OrderType.FAK>, z.ZodLiteral<OrderType.FOK>]>>;
+}, z.core.$strip>;
+type EstimateMarketPriceRequest = z.input<typeof EstimateMarketPriceRequestSchema>;
+type EstimateMarketPriceError = InsufficientLiquidityError | RateLimitError | RequestRejectedError | TransportError | UnexpectedResponseError | UserInputError;
+/**
+ * Estimates the price level a market order would cross at current book depth.
+ *
+ * For BUY orders, `amount` is the amount of collateral to spend. For SELL orders,
+ * `amount` is the number of shares to sell.
+ *
+ * When `orderType` is `FOK`, this estimate requires enough resting liquidity to
+ * satisfy the full requested amount and throws if the book is too thin. When
+ * `orderType` is `FAK`, the estimate may fall back to the best currently
+ * available price level even if the full requested amount cannot fill, so it
+ * should be treated as a partial-fill execution estimate rather than a full-fill
+ * guarantee.
+ *
+ * @example
+ * ```ts
+ * const price = await estimateMarketPrice(client, {
+ *   tokenId:
+ *     '8501497159083948713316135768103773293754490207922884688769443031624417212426',
+ *   side: OrderSide.BUY,
+ *   amount: 10,
+ * });
+ *
+ * // price === 0.53
+ * ```
+ *
+ * @throws {@link EstimateMarketPriceError}
+ * Thrown on failure.
+ */
+declare function estimateMarketPrice(client: BaseClient, request: EstimateMarketPriceRequest): Promise<number>;
+
+type SignerTransactionRequest = {
+    chainId: number;
+    data?: HexString;
+    to: EvmAddress;
+    value?: bigint;
+};
+type RequestAddressRequest = {
+    kind: 'requestAddress';
+};
+type SignAuthMessageRequest = {
+    kind: 'signAuthMessage';
+    payload: TypedDataPayload;
+};
+type SendErc20ApprovalTransactionRequest = {
+    kind: 'sendErc20ApprovalTransaction';
+    request: SignerTransactionRequest;
+};
+type SendErc1155ApprovalForAllTransactionRequest = {
+    kind: 'sendErc1155ApprovalForAllTransaction';
+    request: SignerTransactionRequest;
+};
+type SendErc20TransferTransactionRequest = {
+    kind: 'sendErc20TransferTransaction';
+    request: SignerTransactionRequest;
+};
+type SignGaslessTypedDataRequest = {
+    kind: 'signGaslessTypedData';
+    payload: TypedDataPayload;
+};
+type SignGaslessMessageRequest = {
+    kind: 'signGaslessMessage';
+    payload: TypedDataPayload;
+};
+type SendSplitPositionTransactionRequest = {
+    kind: 'sendSplitPositionTransaction';
+    request: SignerTransactionRequest;
+};
+type SendMergePositionsTransactionRequest = {
+    kind: 'sendMergePositionsTransaction';
+    request: SignerTransactionRequest;
+};
+type SendRedeemPositionsTransactionRequest = {
+    kind: 'sendRedeemPositionsTransaction';
+    request: SignerTransactionRequest;
+};
+type SignOrderRequest = {
+    kind: 'signOrder';
+    payload: TypedDataPayload;
+};
+type AuthenticationWorkflowRequest = RequestAddressRequest | SignAuthMessageRequest;
+type AuthenticationWorkflow<TReturn> = AsyncGenerator<AuthenticationWorkflowRequest, TReturn, EvmAddress | EvmSignature>;
+type AuthenticateWith = <TReturn>(workflow: AuthenticationWorkflow<TReturn>) => Promise<TReturn>;
+type AuthenticateWithError = CancelledSigningError | SigningError;
+type CompleteWithError = CancelledSigningError | SigningError;
+type CompleteWorkflowRequest = RequestAddressRequest | SendErc20ApprovalTransactionRequest | SendErc1155ApprovalForAllTransactionRequest | SendErc20TransferTransactionRequest | SignGaslessTypedDataRequest | SignGaslessMessageRequest | SendSplitPositionTransactionRequest | SendMergePositionsTransactionRequest | SendRedeemPositionsTransactionRequest | SignOrderRequest;
+type CompleteWorkflowNext = EvmAddress | EvmSignature | TransactionHandle;
+type CompleteWith = <TRequest extends CompleteWorkflowRequest, TReturn>(workflow: AsyncGenerator<TRequest, TReturn, CompleteWorkflowNext>) => Promise<TReturn>;
+
+declare const FetchExecuteParamsRequestSchema: z.ZodObject<{
+    address: z.ZodString;
+    type: z.ZodEnum<typeof RelayerTransactionType>;
+}, z.core.$strip>;
+type FetchExecuteParamsRequest = z.input<typeof FetchExecuteParamsRequestSchema>;
+type FetchExecuteParamsError = RateLimitError | RequestRejectedError | TransportError | UnexpectedResponseError | UserInputError;
+/**
+ * Fetches the parameters needed to prepare a low-level transaction submission.
+ *
+ * @remarks
+ * This is a low-level action that most SDK consumers will not need.
+ *
+ * @throws {@link FetchExecuteParamsError}
+ * Thrown on failure.
+ */
+declare function fetchExecuteParams(client: BaseClient, request: FetchExecuteParamsRequest): Promise<RelayerExecuteParams>;
+declare const FetchGaslessTransactionRequestSchema: z.ZodObject<{
+    transactionId: z.ZodPipe<z.ZodString, z.ZodTransform<_polymarket_bindings.TransactionId, string>>;
+}, z.core.$strip>;
+type FetchGaslessTransactionRequest = z.input<typeof FetchGaslessTransactionRequestSchema>;
+declare const IsGaslessReadyRequestSchema: z.ZodObject<{
+    wallet: z.ZodPipe<z.ZodString, z.ZodTransform<EvmAddress, string>>;
+}, z.core.$strip>;
+type IsGaslessReadyRequest = z.input<typeof IsGaslessReadyRequestSchema>;
+type IsGaslessReadyError = RateLimitError | RequestRejectedError | TransportError | UnexpectedResponseError | UserInputError;
+/**
+ * Checks whether a wallet is ready for gasless transactions.
+ *
+ * @throws {@link IsGaslessReadyError}
+ * Thrown on failure.
+ *
+ * @example
+ * ```ts
+ * const ready = await isGaslessReady(client, {
+ *   wallet: '0x1234...',
+ * });
+ * ```
+ */
+declare function isGaslessReady(client: BaseClient, request: IsGaslessReadyRequest): Promise<boolean>;
+type GaslessWalletWorkflowRequest = RequestAddressRequest | SignGaslessTypedDataRequest;
+type GaslessWalletWorkflow = AsyncGenerator<GaslessWalletWorkflowRequest, DeployTransactionHandle, EvmAddress | EvmSignature | TransactionHandle>;
+type PrepareGaslessWalletError = ExecuteGaslessError | IsGaslessReadyError | UserInputError;
+/**
+ * Starts preparing the wallet for gasless transactions.
+ *
+ * @throws {@link PrepareGaslessWalletError}
+ * Thrown on failure.
+ *
+ * @example
+ * ```ts
+ * const handle = await prepareGaslessWallet(client).then(completeWith(wallet));
+ *
+ * const outcome = await handle.wait();
+ *
+ * // outcome.transactionHash: TxHash
+ * ```
+ */
+declare function prepareGaslessWallet(client: BaseClient): Promise<GaslessWalletWorkflow>;
+/**
+ * Fetches a submitted transaction.
+ *
+ * @remarks
+ * This is a low-level action that most SDK consumers will not need.
+ *
+ * @throws {@link FetchGaslessTransactionError}
+ * Thrown on failure.
+ */
+declare function fetchTransaction(client: BaseClient, request: FetchGaslessTransactionRequest): Promise<GaslessTransaction>;
+declare const GaslessTransactionMetadataSchema: z.ZodString;
+declare const PrepareGaslessTransactionRequestSchema: z.ZodObject<{
+    calls: z.ZodPipe<z.ZodArray<z.ZodObject<{
+        data: z.ZodCustom<`0x${string}`, `0x${string}`>;
+        to: z.ZodPipe<z.ZodString, z.ZodTransform<EvmAddress, string>>;
+        value: z.ZodOptional<z.ZodBigInt>;
+    }, z.core.$strip>>, z.ZodTransform<NonEmptyArray<{
+        data: `0x${string}`;
+        to: EvmAddress;
+        value?: bigint | undefined;
+    }>, {
+        data: `0x${string}`;
+        to: EvmAddress;
+        value?: bigint | undefined;
+    }[]>>;
+    metadata: z.ZodString;
+}, z.core.$strip>;
+type PrepareGaslessTransactionRequest = z.input<typeof PrepareGaslessTransactionRequestSchema>;
+type GaslessWorkflowRequest = RequestAddressRequest | SignGaslessMessageRequest;
+type GaslessWorkflow = AsyncGenerator<GaslessWorkflowRequest, TransactionHandle, EvmAddress | EvmSignature | TransactionHandle>;
+type PrepareGaslessTransactionError = ExecuteGaslessError | FetchExecuteParamsError | UserInputError;
+/**
+ * Starts preparing a low-level transaction workflow from one or more calls.
+ *
+ * @remarks
+ * This is a low-level action that most SDK consumers will not need.
+ *
+ * @throws {@link PrepareGaslessTransactionError}
+ * Thrown on failure.
+ */
+declare function prepareGaslessTransaction(client: BaseSecureClient, request: PrepareGaslessTransactionRequest): Promise<GaslessWorkflow>;
+type ExecuteGaslessError = RateLimitError | RequestRejectedError | TransportError | UnexpectedResponseError | UserInputError;
+type WaitForGaslessTransactionError = RateLimitError | RequestRejectedError | TransportError | UnexpectedResponseError | UserInputError | TimeoutError | TransactionFailedError;
+
+type Erc20ApprovalWorkflowRequest = GaslessWorkflowRequest | SendErc20ApprovalTransactionRequest;
+type Erc20ApprovalWorkflow = AsyncGenerator<Erc20ApprovalWorkflowRequest, TransactionHandle, EvmAddress$1 | EvmSignature | TransactionHandle>;
+declare const PrepareErc20ApprovalRequestSchema: z.ZodObject<{
+    amount: z.ZodUnion<readonly [z.ZodBigInt, z.ZodLiteral<"max">]>;
+    metadata: z.ZodOptional<z.ZodString>;
+    spenderAddress: z.ZodPipe<z.ZodString, z.ZodTransform<EvmAddress$1, string>>;
+    tokenAddress: z.ZodPipe<z.ZodString, z.ZodTransform<EvmAddress$1, string>>;
+}, z.core.$strip>;
+type PrepareErc20ApprovalRequest = z.input<typeof PrepareErc20ApprovalRequestSchema>;
+type PrepareErc20ApprovalError = UserInputError;
+/**
+ * Starts an ERC-20 approval workflow.
+ *
+ * @example
+ * ```ts
+ * const handle = await prepareErc20Approval(client, {
+ *   amount: 'max',
+ *   spenderAddress: '0x1234…',
+ *   tokenAddress: '0x5678…',
+ * }).then(completeWith(wallet));
+ *
+ * const outcome = await handle.wait();
+ *
+ * // outcome.transactionHash: TxHash
+ * ```
+ *
+ * @throws {@link PrepareErc20ApprovalError}
+ * Thrown on failure.
+ */
+declare function prepareErc20Approval(client: BaseSecureClient, request: PrepareErc20ApprovalRequest): Promise<Erc20ApprovalWorkflow>;
+type Erc1155ApprovalForAllWorkflowRequest = GaslessWorkflowRequest | SendErc1155ApprovalForAllTransactionRequest;
+type Erc1155ApprovalForAllWorkflow = AsyncGenerator<Erc1155ApprovalForAllWorkflowRequest, TransactionHandle, EvmAddress$1 | EvmSignature | TransactionHandle>;
+declare const PrepareErc1155ApprovalForAllRequestSchema: z.ZodObject<{
+    approved: z.ZodDefault<z.ZodBoolean>;
+    metadata: z.ZodOptional<z.ZodString>;
+    operatorAddress: z.ZodPipe<z.ZodString, z.ZodTransform<EvmAddress$1, string>>;
+    tokenAddress: z.ZodPipe<z.ZodString, z.ZodTransform<EvmAddress$1, string>>;
+}, z.core.$strip>;
+type PrepareErc1155ApprovalForAllRequest = z.input<typeof PrepareErc1155ApprovalForAllRequestSchema>;
+type PrepareErc1155ApprovalForAllError = UserInputError;
+/**
+ * Starts an ERC-1155 approval-for-all workflow.
+ *
+ * @example
+ * ```ts
+ * const handle = await prepareErc1155ApprovalForAll(client, {
+ *   operatorAddress: '0x1234…',
+ *   tokenAddress: '0x5678…',
+ * }).then(completeWith(wallet));
+ *
+ * const outcome = await handle.wait();
+ *
+ * // outcome.transactionHash: TxHash
+ * ```
+ *
+ * @throws {@link PrepareErc1155ApprovalForAllError}
+ * Thrown on failure.
+ */
+declare function prepareErc1155ApprovalForAll(client: BaseSecureClient, request: PrepareErc1155ApprovalForAllRequest): Promise<Erc1155ApprovalForAllWorkflow>;
+type TradingApprovalsWorkflowRequest = GaslessWorkflowRequest | SendErc20ApprovalTransactionRequest | SendErc1155ApprovalForAllTransactionRequest;
+type TradingApprovalsWorkflow = AsyncGenerator<TradingApprovalsWorkflowRequest, TransactionHandle, EvmAddress$1 | EvmSignature | TransactionHandle>;
+type PrepareTradingApprovalsError = UserInputError;
+/**
+ * Starts a trading-setup approval workflow.
+ *
+ * Prepares all approvals required for trading, including collateral and
+ * position token approvals for both standard and neg-risk market flows.
+ * The neg-risk adapter approvals cover split, merge, and redemption workflows
+ * on neg-risk markets.
+ *
+ * @example
+ * ```ts
+ * const handle = await prepareTradingApprovals(client).then(completeWith(wallet));
+ *
+ * const outcome = await handle.wait();
+ *
+ * // outcome.transactionHash: TxHash
+ * ```
+ *
+ * @throws {@link PrepareTradingApprovalsError}
+ * Thrown on failure.
+ */
+declare function prepareTradingApprovals(client: BaseSecureClient): Promise<TradingApprovalsWorkflow>;
+
+type PrepareMarketOrderRequest = {
+    /** TokenID of the Conditional token asset being traded */
+    tokenId: string;
+    /**
+     * BUY orders: dollar amount to spend
+     * SELL orders: number of shares to sell
+     */
+    amount: number;
+    /** Side of the order */
+    side: OrderSide;
+    /** Taker address. Omit for public orders (zero address is equivalent). */
+    taker?: string;
+    /**
+     * Specifies the type of order execution.
+     * - FOK (Fill or Kill): must be filled entirely or not at all
+     * - FAK (Fill and Kill): partially fills, cancels any unfilled remainder
+     *
+     * @defaultValue OrderType.FAK
+     */
+    orderType?: OrderType.FAK | OrderType.FOK;
+};
+type PrepareLimitOrderRequest = {
+    /** TokenID of the Conditional token asset being traded */
+    tokenId: string;
+    /** Price used to create the order */
+    price: number;
+    /** Size in terms of the conditional token */
+    size: number;
+    /** Side of the order */
+    side: OrderSide;
+    /** Taker address. Omit for public orders (zero address is equivalent). */
+    taker?: string;
+    /**
+     * Posts the prepared order as post-only when submitted.
+     *
+     * @defaultValue false
+     */
+    postOnly?: boolean;
+    /**
+     * Unix timestamp in seconds after which the order expires.
+     *
+     * When provided, the SDK prepares a Good-Til-Date (GTD) limit order that
+     * expires at the given timestamp.
+     *
+     * When omitted, the SDK prepares a Good-Til-Cancelled (GTC) limit order.
+     */
+    expiration?: number;
+};
+type OrderDraft = {
+    chainId: number;
+    exchangeAddress: EvmAddress;
+    expiration: number;
+    feeRateBps: number;
+    funderAddress: EvmAddress;
+    offeredAmount: bigint;
+    orderType: OrderType;
+    side: OrderSide;
+    signer: EvmAddress;
+    allowedTaker?: EvmAddress;
+    requestedAmount: bigint;
+    tokenId: TokenId;
+};
+type SignedOrder = {
+    expiration: number;
+    feeRateBps: number;
+    maker: EvmAddress;
+    makerAmount: string;
+    nonce: number;
+    orderType: OrderType;
+    salt: string;
+    side: OrderSide;
+    signatureType: SignatureType;
+    signer: EvmAddress;
+    taker: EvmAddress;
+    takerAmount: string;
+    tokenId: TokenId;
+    signature: EvmSignature;
+    postOnly?: boolean;
+};
+type OrderWorkflowRequest = Erc20ApprovalWorkflowRequest | Erc1155ApprovalForAllWorkflowRequest | SignOrderRequest;
+type OrderWorkflow = AsyncGenerator<OrderWorkflowRequest, SignedOrder, EvmAddress | EvmSignature | TransactionHandle>;
+type OrderPostingWorkflow = AsyncGenerator<OrderWorkflowRequest, OrderResponse, EvmAddress | EvmSignature | TransactionHandle>;
+
+declare const PostOrdersRequestSchema: z.ZodArray<z.ZodCustom<SignedOrder, SignedOrder>>;
+type PostOrdersRequest = z.input<typeof PostOrdersRequestSchema>;
+type PostOrderError = RateLimitError | RequestRejectedError | SigningError | TransportError | UnexpectedResponseError;
+type PostOrdersError = RateLimitError | RequestRejectedError | SigningError | TransportError | UnexpectedResponseError | UserInputError;
+/**
+ * Posts a signed order for the authenticated account.
+ *
+ * @example
+ * ```ts
+ * const response = await prepareMarketOrder(client, {
+ *   amount: 10,
+ *   side: OrderSide.BUY,
+ *   tokenId: '123',
+ * })
+ *   .then(completeWith(wallet))
+ *   .then(postOrder(client));
+ * ```
+ *
+ * @throws {@link PostOrderError}
+ * Thrown on failure.
+ */
+declare function postOrder(client: BaseSecureClient): (order: SignedOrder) => Promise<OrderResponse>;
+/**
+ * Posts multiple signed orders for the authenticated account.
+ *
+ * @remarks
+ * Accepts between 1 and 15 orders, matching the current service limit.
+ *
+ * @example
+ * ```ts
+ * const responses = await postOrders(client)([firstSignedOrder, secondSignedOrder]);
+ * ```
+ *
+ * @throws {@link PostOrdersError}
+ * Thrown on failure.
+ */
+declare function postOrders(client: BaseSecureClient): (orders: PostOrdersRequest) => Promise<OrderResponses>;
+
+type TradingActions = {
+    /**
+     * Starts the market-order workflow.
+     *
+     * @throws {@link PrepareMarketOrderError}
+     * Thrown on failure.
+     *
+     * @example
+     * ```ts
+     * const order = await client.prepareMarketOrder({
+     *   amount: 10,
+     *   side: OrderSide.BUY,
+     *   tokenId: '123',
+     * }).then(completeWith(wallet));
+     *
+     * const response = await client.postOrder(order);
+     *
+     * // response: OrderResponse
+     * ```
+     */
+    prepareMarketOrder(request: PrepareMarketOrderRequest): Promise<OrderWorkflow>;
+    /**
+     * Starts and posts a market-order workflow.
+     *
+     * @throws {@link PrepareMarketOrderPostingError}
+     * Thrown on failure.
+     *
+     * @example
+     * ```ts
+     * const response = await client.prepareMarketOrderPosting({
+     *   amount: 10,
+     *   side: OrderSide.BUY,
+     *   tokenId: '123',
+     * }).then(completeWith(wallet));
+     *
+     * // response: OrderResponse
+     * ```
+     */
+    prepareMarketOrderPosting(request: PrepareMarketOrderRequest): Promise<OrderPostingWorkflow>;
+    /**
+     * Starts the limit-order workflow.
+     *
+     * @throws {@link PrepareLimitOrderError}
+     * Thrown on failure.
+     *
+     * @example
+     * ```ts
+     * const order = await client.prepareLimitOrder({
+     *   postOnly: true,
+     *   price: 0.52,
+     *   side: OrderSide.BUY,
+     *   size: 10,
+     *   tokenId: '123',
+     * }).then(completeWith(wallet));
+     *
+     * const response = await client.postOrder(order);
+     *
+     * // response: OrderResponse
+     * ```
+     */
+    prepareLimitOrder(request: PrepareLimitOrderRequest): Promise<OrderWorkflow>;
+    /**
+     * Starts and posts a limit-order workflow.
+     *
+     * @throws {@link PrepareLimitOrderPostingError}
+     * Thrown on failure.
+     *
+     * @example
+     * ```ts
+     * const response = await client.prepareLimitOrderPosting({
+     *   postOnly: true,
+     *   price: 0.52,
+     *   side: OrderSide.BUY,
+     *   size: 10,
+     *   tokenId: '123',
+     * }).then(completeWith(wallet));
+     *
+     * // response: OrderResponse
+     * ```
+     */
+    prepareLimitOrderPosting(request: PrepareLimitOrderRequest): Promise<OrderPostingWorkflow>;
+    /**
+     * Posts a signed order for the authenticated account.
+     *
+     * @throws {@link PostOrderError}
+     * Thrown on failure.
+     *
+     * @example
+     * ```ts
+     * const response = await client.postOrder(signedOrder);
+     * ```
+     */
+    postOrder(order: SignedOrder): Promise<OrderResponse>;
+    /**
+     * Posts multiple signed orders for the authenticated account.
+     *
+     * @remarks
+     * Accepts between 1 and 15 orders, matching the current service limit.
+     *
+     * @throws {@link PostOrdersError}
+     * Thrown on failure.
+     *
+     * @example
+     * ```ts
+     * const responses = await client.postOrders([firstSignedOrder, secondSignedOrder]);
+     * ```
+     */
+    postOrders(orders: PostOrdersRequest): Promise<OrderResponses>;
+    /**
+     * Cancels a single open order for the authenticated account.
+     *
+     * @throws {@link CancelOrderError}
+     * Thrown on failure.
+     *
+     * @example
+     * ```ts
+     * const response = await client.cancelOrder({ orderId: '123' });
+     *
+     * // response.canceled: string[]
+     * ```
+     */
+    cancelOrder(request: CancelOrderRequest): Promise<CancelOrdersResponse>;
+    /**
+     * Cancels multiple open orders for the authenticated account.
+     *
+     * @throws {@link CancelOrdersError}
+     * Thrown on failure.
+     *
+     * @example
+     * ```ts
+     * const response = await client.cancelOrders({ orderIds: ['1', '2'] });
+     *
+     * // response.canceled: string[]
+     * ```
+     */
+    cancelOrders(request: CancelOrdersRequest): Promise<CancelOrdersResponse>;
+    /**
+     * Cancels all open orders for the authenticated account.
+     *
+     * @throws {@link CancelAllError}
+     * Thrown on failure.
+     *
+     * @example
+     * ```ts
+     * const response = await client.cancelAll();
+     *
+     * // response.canceled: string[]
+     * ```
+     */
+    cancelAll(): Promise<CancelOrdersResponse>;
+    /**
+     * Cancels all open orders for the authenticated account that match the market or asset filter.
+     *
+     * @throws {@link CancelMarketOrdersError}
+     * Thrown on failure.
+     *
+     * @example
+     * ```ts
+     * const response = await client.cancelMarketOrders({
+     *   market: '0x0000000000000000000000000000000000000000000000000000000000000001',
+     * });
+     *
+     * // response.canceled: string[]
+     * ```
+     */
+    cancelMarketOrders(request: CancelMarketOrdersRequest): Promise<CancelOrdersResponse>;
+    /**
+     * Lists open orders for the authenticated account across all pages.
+     *
+     * @throws {@link ListOpenOrdersError}
+     * Thrown on failure.
+     *
+     * @example
+     * Fetch the first page of results:
+     * ```ts
+     * const paginator = client.listOpenOrders({
+     *   market: '0x0000000000000000000000000000000000000000000000000000000000000001',
+     * });
+     *
+     * const firstPage = await paginator.firstPage();
+     *
+     * // Optionally, fetch additional pages:
+     * for await (const page of paginator.from(firstPage.nextCursor)) {
+     *   // page.items: OpenOrder[]
+     * }
+     * ```
+     *
+     * @example
+     * Loop through all pages with `for await`:
+     * ```ts
+     * const paginator = client.listOpenOrders({
+     *   market: '0x0000000000000000000000000000000000000000000000000000000000000001',
+     * });
+     *
+     * for await (const page of paginator) {
+     *   // page.items: OpenOrder[]
+     * }
+     * ```
+     */
+    listOpenOrders(request?: ListOpenOrdersRequest): Paginated<OpenOrder>;
+    /**
+     * Fetches a single order for the authenticated account.
+     *
+     * @throws {@link FetchOrderError}
+     * Thrown on failure.
+     *
+     * @example
+     * ```ts
+     * const order = await client.fetchOrder({ orderId: '123' });
+     * ```
+     */
+    fetchOrder(request: FetchOrderRequest): Promise<OpenOrder>;
+};
+declare function tradingActions(client: BaseSecureClient): TradingActions;
+
+type PublicWalletActions = {
+    /**
+     * Checks whether a wallet is ready for gasless transactions.
+     *
+     * @throws {@link IsGaslessReadyError}
+     * Thrown on failure.
+     *
+     * @example
+     * ```ts
+     * const ready = await client.isGaslessReady({
+     *   wallet: '0x1234...',
+     * });
+     * ```
+     */
+    isGaslessReady(request: IsGaslessReadyRequest): Promise<boolean>;
+    /**
+     * Starts preparing the wallet for gasless transactions.
+     *
+     * @throws {@link PrepareGaslessWalletError}
+     * Thrown on failure.
+     *
+     * @example
+     * ```ts
+     * const handle = await client.prepareGaslessWallet().then(completeWith(wallet));
+     *
+     * const outcome = await handle.wait();
+     *
+     * // outcome.transactionHash: TxHash
+     * ```
+     */
+    prepareGaslessWallet(): Promise<GaslessWalletWorkflow>;
+};
+type SecureWalletActions = Prettify<PublicWalletActions & {
+    /**
+     * Starts a trading-setup approval workflow.
+     *
+     * @throws {@link PrepareTradingApprovalsError}
+     * Thrown on failure.
+     *
+     * @example
+     * ```ts
+     * const handle = await client.prepareTradingApprovals().then(completeWith(wallet));
+     *
+     * const outcome = await handle.wait();
+     *
+     * // outcome.transactionHash: TxHash
+     * ```
+     */
+    prepareTradingApprovals(): Promise<TradingApprovalsWorkflow>;
+    /**
+     * Starts an ERC-20 approval workflow.
+     *
+     * @throws {@link PrepareErc20ApprovalError}
+     * Thrown on failure.
+     *
+     * @example
+     * ```ts
+     * const handle = await client.prepareErc20Approval({
+     *   amount: 'max',
+     *   spenderAddress: '0x1234…',
+     *   tokenAddress: '0x5678…',
+     * }).then(completeWith(wallet));
+     *
+     * const outcome = await handle.wait();
+     *
+     * // outcome.transactionHash: TxHash
+     * ```
+     */
+    prepareErc20Approval(request: PrepareErc20ApprovalRequest): Promise<Erc20ApprovalWorkflow>;
+    /**
+     * Starts an ERC-1155 approval-for-all workflow.
+     *
+     * @throws {@link PrepareErc1155ApprovalForAllError}
+     * Thrown on failure.
+     *
+     * @example
+     * ```ts
+     * const handle = await client.prepareErc1155ApprovalForAll({
+     *   operatorAddress: '0x1234…',
+     *   tokenAddress: '0x5678…',
+     * }).then(completeWith(wallet));
+     *
+     * const outcome = await handle.wait();
+     *
+     * // outcome.transactionHash: TxHash
+     * ```
+     */
+    prepareErc1155ApprovalForAll(request: PrepareErc1155ApprovalForAllRequest): Promise<Erc1155ApprovalForAllWorkflow>;
+    /**
+     * Starts an ERC-20 transfer workflow.
+     *
+     * @throws {@link PrepareErc20TransferError}
+     * Thrown on failure.
+     *
+     * @example
+     * ```ts
+     * const handle = await client.prepareErc20Transfer({
+     *   amount: 1n,
+     *   recipientAddress: client.account.signer,
+     *   tokenAddress: client.environment.collateralToken,
+     * }).then(completeWith(wallet));
+     *
+     * const outcome = await handle.wait();
+     *
+     * // outcome.transactionHash: TxHash
+     * ```
+     */
+    prepareErc20Transfer(request: PrepareErc20TransferRequest): Promise<Erc20TransferWorkflow>;
+    /**
+     * Starts a split workflow for a market condition.
+     *
+     * @throws {@link PrepareSplitPositionError}
+     * Thrown on failure.
+     *
+     * @example
+     * ```ts
+     * const handle = await client.prepareSplitPosition({
+     *   amount: 1n,
+     *   conditionId:
+     *     '0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef',
+     * }).then(completeWith(wallet));
+     *
+     * const outcome = await handle.wait();
+     *
+     * // outcome.transactionHash: TxHash
+     * ```
+     */
+    prepareSplitPosition(request: PrepareSplitPositionRequest): Promise<SplitPositionWorkflow>;
+    /**
+     * Starts a workflow to merge complementary positions in a market back into collateral.
+     *
+     * @throws {@link PrepareMergePositionsError}
+     * Thrown on failure.
+     *
+     * @example
+     * ```ts
+     * const handle = await client.prepareMergePositions({
+     *   amount: 'max',
+     *   conditionId:
+     *     '0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef',
+     * }).then(completeWith(wallet));
+     *
+     * const outcome = await handle.wait();
+     *
+     * // outcome.transactionHash: TxHash
+     * ```
+     */
+    prepareMergePositions(request: PrepareMergePositionsRequest): Promise<MergePositionsWorkflow>;
+    /**
+     * Starts a redemption workflow for resolved positions.
+     *
+     * @throws {@link PrepareRedeemPositionsError}
+     * Thrown on failure.
+     *
+     * @example
+     * ```ts
+     * const handle = await client.prepareRedeemPositions({
+     *   conditionId:
+     *     '0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef',
+     * }).then(completeWith(wallet));
+     *
+     * const outcome = await handle.wait();
+     *
+     * // outcome.transactionHash: TxHash
+     * ```
+     */
+    prepareRedeemPositions(request: PrepareRedeemPositionsRequest): Promise<RedeemPositionsWorkflow>;
+}>;
+declare function walletActions(client: BasePublicClient): PublicWalletActions;
+declare function walletActions(client: BaseSecureClient): SecureWalletActions;
+
+type PublicActions = Prettify<DiscoveryActions & DataActions & AnalyticsActions & AccountPublicActions & RewardsPublicActions & PublicWalletActions>;
+type SecureActions = Prettify<DiscoveryActions & DataActions & AnalyticsActions & AccountActions & RewardsActions & SecureWalletActions & TradingActions>;
+declare function allActions(client: BasePublicClient): PublicActions;
+declare function allActions(client: BaseSecureClient): SecureActions;
+
+type WalletDerivationConfig = {
+    proxyFactory: EvmAddress;
+    proxyImplementation: EvmAddress;
+    safeFactory: EvmAddress;
+    safeInitCodeHash: Hex.Hex;
+};
+type EnvironmentConfig = {
+    name: string;
+    chainId: number;
+};
+/**
+ * The production environment configuration.
+ */
+declare const production: EnvironmentConfig;
+
+type ServiceRequest = {
+    method: 'DELETE' | 'GET' | 'POST';
+    path: string;
+    body?: string;
+    headers?: HeadersInit;
+    json?: unknown;
+    params?: URLSearchParams;
+};
+
+type PublicContext = {};
+type ClientActions = {};
+type ClientDecorator<TPublicActions extends ClientActions = ClientActions, TSecureActions extends ClientActions = TPublicActions> = {
+    (client: BasePublicClient<ClientActions, ClientActions>): TPublicActions;
+    (client: BaseSecureClient<ClientActions, ClientActions>): TSecureActions;
+};
+type DecoratorPublicActions<TDecorator extends ClientDecorator> = TDecorator extends ClientDecorator<infer TPublicActions, infer _TSecureActions> ? TPublicActions : never;
+type DecoratorSecureActions<TDecorator extends ClientDecorator> = TDecorator extends ClientDecorator<infer _TPublicActions, infer TSecureActions> ? TSecureActions : never;
+declare abstract class AbstractClient<TContext extends PublicContext> {
+    #private;
+    protected get context(): TContext;
+    protected get decorators(): readonly ClientDecorator[];
+    constructor(context: TContext);
+    protected resolveClobHeaders(request: ServiceRequest): Promise<HeadersInit>;
+    protected resolveRelayerHeaders(request: ServiceRequest): Promise<HeadersInit>;
+    protected rememberDecorator(decorator: ClientDecorator): void;
+}
+/**
+ * Persistable authenticated session state that can later be passed to
+ * {@link PublicClient.beginAuthentication}.
+ */
+type SessionSnapshot = {
+    /**
+     * Wallet address to authenticate as.
+     *
+     * Pass the signer address itself to authenticate as an EOA account.
+     */
+    wallet: string;
+    /**
+     * Existing API credentials to reuse when they remain valid.
+     */
+    credentials: ApiKeyCreds;
+    nonce?: never;
+};
+type FreshAuthenticationRequest = {
+    /**
+     * Wallet address to authenticate as.
+     *
+     * Pass the signer address itself to authenticate as an EOA account.
+     */
+    wallet: string;
+    /**
+     * Nonce used when creating or deriving fresh credentials.
+     *
+     * @defaultValue 0
+     */
+    nonce?: number;
+    credentials?: never;
+};
+type BeginAuthenticationRequest = SessionSnapshot | FreshAuthenticationRequest;
+type PublicClientConfig = {
+    environment: EnvironmentConfig;
+    apiKey?: ApiKeyAuthorization;
+};
+declare class BasePublicClient<TPublicActions extends ClientActions = ClientActions, TSecureActions extends ClientActions = TPublicActions> extends AbstractClient<PublicContext> {
+    #private;
+    constructor(config: PublicClientConfig);
+    /**
+     * Use this to narrow a {@link Client} union to {@link SecureClient}.
+     *
+     * @example
+     * ```ts
+     * if (client.isSecureClient()) {
+     *   client.credentials; // SecureClient
+     * }
+     * ```
+     */
+    isSecureClient(): this is BaseSecureClient<TPublicActions, TSecureActions>;
+    /**
+     * Use this to narrow a {@link Client} union to {@link PublicClient}.
+     *
+     * @example
+     * ```ts
+     * if (client.isPublicClient()) {
+     *   client.beginAuthentication(...); // PublicClient
+     * }
+     * ```
+     */
+    isPublicClient(): this is BasePublicClient<TPublicActions, TSecureActions>;
+    /**
+     * Returns a client typed with the methods contributed by the decorator.
+     */
+    extend<TDecorator extends ClientDecorator>(decorator: TDecorator): PublicClient<Prettify<TPublicActions & DecoratorPublicActions<TDecorator>>, Prettify<TSecureActions & DecoratorSecureActions<TDecorator>>>;
+    /**
+     * Begins an authentication workflow that produces a {@link SecureClient}.
+     *
+     * @remarks
+     * Pass a {@link SessionSnapshot} to reuse stored credentials when they remain
+     * valid. If the stored credential is no longer valid, the workflow falls back
+     * to fresh authentication.
+     */
+    beginAuthentication(request: BeginAuthenticationRequest): Promise<AuthenticationWorkflow<SecureClient<TPublicActions, TSecureActions>>>;
+}
+declare class BaseSecureClient<TPublicActions extends ClientActions = ClientActions, TSecureActions extends ClientActions = TPublicActions> extends AbstractClient<SecureContext> {
+    #private;
+    /**
+     * @remarks This is the choking point for all requests, so we can ensure that once
+     * `endAuthentication` is called, no further authenticated requests can be made with this client instance.
+     */
+    protected get context(): SecureContext;
+    protected endAuthenticationLifecycle(): void;
+    constructor(config: SecureClientConfig);
+    /**
+     * Use this to narrow a {@link Client} union to {@link SecureClient}.
+     *
+     * @example
+     * ```ts
+     * if (client.isSecureClient()) {
+     *   client.credentials; // SecureClient
+     * }
+     * ```
+     */
+    isSecureClient(): this is BaseSecureClient<TPublicActions, TSecureActions>;
+    /**
+     * Use this to narrow a {@link Client} union to {@link PublicClient}.
+     *
+     * @example
+     * ```ts
+     * if (client.isPublicClient()) {
+     *   client.beginAuthentication(...); // PublicClient
+     * }
+     * ```
+     */
+    isPublicClient(): this is BasePublicClient<TPublicActions, TSecureActions>;
+    /**
+     * Returns a secure client typed with the methods contributed by the decorator.
+     */
+    extend<TDecorator extends ClientDecorator>(decorator: TDecorator): SecureClient<TPublicActions, Prettify<TSecureActions & DecoratorSecureActions<TDecorator>>>;
+    /**
+     * Returns a persistable snapshot of the current authenticated session.
+     *
+     * @remarks
+     * Pass the returned snapshot to {@link PublicClient.beginAuthentication} to
+     * reuse the current session in a later authentication attempt. Capture the
+     * snapshot before calling {@link endAuthentication}; ending authentication
+     * revokes the current credential, so reusing an older snapshot will fall back
+     * to fresh authentication.
+     *
+     * @example
+     * ```ts
+     * const snapshot = secureClient.getSessionSnapshot();
+     * ```
+     */
+    getSessionSnapshot(): SessionSnapshot;
+    /**
+     * Ends authentication for this client and returns a public client.
+     *
+     * @remarks
+     * This revokes the current authenticated credential and invalidates the
+     * current `SecureClient` instance.
+     *
+     * @example
+     * ```ts
+     * const publicClient = await secureClient.endAuthentication();
+     * ```
+     */
+    endAuthentication(): Promise<PublicClient<TPublicActions, TSecureActions>>;
+}
+type SecureContext = PublicContext & {};
+type SecureClientConfig = PublicClientConfig & {
+    account: AccountIdentity;
+    credentials: ApiKeyCreds;
+};
+type PublicClient<TPublicActions extends ClientActions = ClientActions, TSecureActions extends ClientActions = TPublicActions> = BasePublicClient<TPublicActions, TSecureActions> & TPublicActions;
+type SecureClient<TPublicActions extends ClientActions = ClientActions, TSecureActions extends ClientActions = TPublicActions> = BaseSecureClient<TPublicActions, TSecureActions> & TSecureActions;
+
+type BaseClient<TPublicActions extends ClientActions = ClientActions, TSecureActions extends ClientActions = TPublicActions> = BasePublicClient<TPublicActions, TSecureActions> | BaseSecureClient<TPublicActions, TSecureActions>;
+type Client<TPublicActions extends ClientActions = ClientActions, TSecureActions extends ClientActions = TPublicActions> = PublicClient<TPublicActions, TSecureActions> | SecureClient<TPublicActions, TSecureActions>;
+type PublicClientOptions = {
+    /**
+     * The environment configuration used by the client.
+     *
+     * @defaultValue `production`
+     */
+    environment?: EnvironmentConfig;
+    /**
+     * Optional request authorization applied by the client when needed.
+     */
+    apiKey?: ApiKeyAuthorization;
+};
+/**
+ * Creates a new `PublicClient` instance.
+ *
+ * @example
+ * ```ts
+ * const client = createPublicClient();
+ * ```
+ */
+declare function createPublicClient(options?: PublicClientOptions): PublicClient<PublicActions, SecureActions>;
+
+type FetchClosedOnlyModeError = RateLimitError | RequestRejectedError | SigningError | TransportError | UnexpectedResponseError;
+/**
+ * Fetches whether the account is restricted to closed-only trading.
+ *
+ * @throws {@link FetchClosedOnlyModeError}
+ *
+ * @example
+ * ```ts
+ * const closedOnly = await fetchClosedOnlyMode(client);
+ * ```
+ */
+declare function fetchClosedOnlyMode(client: BaseSecureClient): Promise<boolean>;
+declare const ListOpenOrdersRequestSchema: z.ZodDefault<z.ZodObject<{
+    assetId: z.ZodOptional<z.ZodString>;
+    cursor: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<_polymarket_bindings.PaginationCursor, string>>>;
+    id: z.ZodOptional<z.ZodString>;
+    market: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>;
+type ListOpenOrdersRequest = z.input<typeof ListOpenOrdersRequestSchema>;
+type ListOpenOrdersError = RateLimitError | RequestRejectedError | SigningError | TransportError | UnexpectedResponseError | UserInputError;
+/**
+ * Lists open orders for the authenticated account across all pages.
+ *
+ * @throws {@link ListOpenOrdersError}
+ *
+ * @example
+ * Fetch the first page of results:
+ * ```ts
+ * const result = listOpenOrders(client, {
+ *   market: '0x0000000000000000000000000000000000000000000000000000000000000001',
+ * });
+ *
+ * const firstPage = await result.firstPage();
+ *
+ * // Optionally, fetch additional pages:
+ * for await (const page of result.from(firstPage.nextCursor)) {
+ *   // page.items: OpenOrder[]
+ * }
+ * ```
+ *
+ * @example
+ * Loop through all pages with `for await`:
+ * ```ts
+ * const result = listOpenOrders(client, {
+ *   market: '0x0000000000000000000000000000000000000000000000000000000000000001',
+ * });
+ *
+ * for await (const page of result) {
+ *   // page.items: OpenOrder[]
+ * }
+ * ```
+ */
+declare function listOpenOrders(client: BaseSecureClient, request?: ListOpenOrdersRequest): Paginated<OpenOrder>;
+declare const FetchOrderRequestSchema: z.ZodObject<{
+    orderId: z.ZodString;
+}, z.core.$strip>;
+type FetchOrderRequest = z.input<typeof FetchOrderRequestSchema>;
+type FetchOrderError = RateLimitError | RequestRejectedError | SigningError | TransportError | UnexpectedResponseError | UserInputError;
+/**
+ * Fetches a single order for the authenticated account.
+ *
+ * @throws {@link FetchOrderError}
+ *
+ * @example
+ * ```ts
+ * const order = await fetchOrder(client, {
+ *   orderId: '123',
+ * });
+ * ```
+ */
+declare function fetchOrder(client: BaseSecureClient, request: FetchOrderRequest): Promise<OpenOrder>;
+declare const ListAccountTradesRequestSchema: z.ZodDefault<z.ZodObject<{
+    after: z.ZodOptional<z.ZodString>;
+    assetId: z.ZodOptional<z.ZodString>;
+    before: z.ZodOptional<z.ZodString>;
+    cursor: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<_polymarket_bindings.PaginationCursor, string>>>;
+    id: z.ZodOptional<z.ZodString>;
+    makerAddress: z.ZodOptional<z.ZodString>;
+    market: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>;
+type ListAccountTradesRequest = z.input<typeof ListAccountTradesRequestSchema>;
+type ListAccountTradesError = RateLimitError | RequestRejectedError | SigningError | TransportError | UnexpectedResponseError | UserInputError;
+/**
+ * Lists trades for the authenticated account across all pages.
+ *
+ * @throws {@link ListAccountTradesError}
+ *
+ * @example
+ * Fetch the first page of results:
+ * ```ts
+ * const result = listAccountTrades(client, {
+ *   market: '0x0000000000000000000000000000000000000000000000000000000000000001',
+ * });
+ *
+ * const firstPage = await result.firstPage();
+ *
+ * // Optionally, fetch additional pages:
+ * for await (const page of result.from(firstPage.nextCursor)) {
+ *   // page.items: ClobTrade[]
+ * }
+ * ```
+ *
+ * @example
+ * Loop through all pages with `for await`:
+ * ```ts
+ * const result = listAccountTrades(client, {
+ *   market: '0x0000000000000000000000000000000000000000000000000000000000000001',
+ * });
+ *
+ * for await (const page of result) {
+ *   // page.items: ClobTrade[]
+ * }
+ * ```
+ */
+declare function listAccountTrades(client: BaseSecureClient, request?: ListAccountTradesRequest): Paginated<ClobTrade>;
+type FetchNotificationsError = RateLimitError | RequestRejectedError | SigningError | TransportError | UnexpectedResponseError;
+declare const DropNotificationsRequestSchema: z.ZodObject<{
+    ids: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+type DropNotificationsRequest = z.input<typeof DropNotificationsRequestSchema>;
+/**
+ * Fetches notifications for the authenticated account.
+ *
+ * @throws {@link FetchNotificationsError}
+ *
+ * @example
+ * ```ts
+ * const notifications = await fetchNotifications(client);
+ * ```
+ */
+declare function fetchNotifications(client: BaseSecureClient): Promise<NotificationsResponse>;
+type DropNotificationsError = RateLimitError | RequestRejectedError | SigningError | TransportError | UnexpectedResponseError | UserInputError;
+/**
+ * Drops notifications for the authenticated account.
+ *
+ * @throws {@link DropNotificationsError}
+ * Thrown on failure.
+ *
+ * @example
+ * ```ts
+ * await dropNotifications(client, {
+ *   ids: ['1', '2'],
+ * });
+ * ```
+ */
+declare function dropNotifications(client: BaseSecureClient, request: DropNotificationsRequest): Promise<void>;
+declare const FetchBalanceAllowanceRequestSchema: z.ZodObject<{
+    assetType: z.ZodEnum<typeof _polymarket_bindings_clob.AssetType>;
+    tokenId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type FetchBalanceAllowanceRequest = z.input<typeof FetchBalanceAllowanceRequestSchema>;
+type FetchBalanceAllowanceError = RateLimitError | RequestRejectedError | SigningError | TransportError | UnexpectedResponseError | UserInputError;
+/**
+ * Fetches balance and allowance for the authenticated account.
+ *
+ * @remarks
+ * This is a low-level action that most SDK consumers will not need.
+ *
+ * @throws {@link FetchBalanceAllowanceError}
+ * Thrown on failure.
+ *
+ * @example
+ * ```ts
+ * const balanceAllowance = await fetchBalanceAllowance(client, {
+ *   assetType: AssetType.COLLATERAL,
+ * });
+ * ```
+ */
+declare function fetchBalanceAllowance(client: BaseSecureClient, request: FetchBalanceAllowanceRequest): Promise<BalanceAllowanceResponse>;
+declare const UpdateBalanceAllowanceRequestSchema: z.ZodObject<{
+    assetType: z.ZodEnum<typeof _polymarket_bindings_clob.AssetType>;
+    tokenId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type UpdateBalanceAllowanceRequest = z.input<typeof UpdateBalanceAllowanceRequestSchema>;
+type UpdateBalanceAllowanceError = RateLimitError | RequestRejectedError | SigningError | TransportError | UnexpectedResponseError | UserInputError;
+/**
+ * Refreshes balance and allowance for the authenticated account.
+ *
+ * @remarks
+ * This is a low-level action that most SDK consumers will not need.
+ *
+ * @throws {@link UpdateBalanceAllowanceError}
+ * Thrown on failure.
+ *
+ * @example
+ * ```ts
+ * const balanceAllowance = await updateBalanceAllowance(client, {
+ *   assetType: AssetType.COLLATERAL,
+ * });
+ * ```
+ */
+declare function updateBalanceAllowance(client: BaseSecureClient, request: UpdateBalanceAllowanceRequest): Promise<BalanceAllowanceResponse>;
+declare const FetchOrderScoringRequestSchema: z.ZodObject<{
+    orderId: z.ZodString;
+}, z.core.$strip>;
+type FetchOrderScoringRequest = z.input<typeof FetchOrderScoringRequestSchema>;
+type FetchOrderScoringError = RateLimitError | RequestRejectedError | SigningError | TransportError | UnexpectedResponseError | UserInputError;
+/**
+ * Fetches whether a single order is currently scoring.
+ *
+ * @throws {@link FetchOrderScoringError}
+ *
+ * @example
+ * ```ts
+ * const scoring = await fetchOrderScoring(client, {
+ *   orderId: '123',
+ * });
+ * ```
+ */
+declare function fetchOrderScoring(client: BaseSecureClient, request: FetchOrderScoringRequest): Promise<boolean>;
+declare const FetchOrdersScoringRequestSchema: z.ZodObject<{
+    orderIds: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+type FetchOrdersScoringRequest = z.input<typeof FetchOrdersScoringRequestSchema>;
+type FetchOrdersScoringError = RateLimitError | RequestRejectedError | SigningError | TransportError | UnexpectedResponseError | UserInputError;
+/**
+ * Fetches scoring state for multiple orders.
+ *
+ * @throws {@link FetchOrdersScoringError}
+ *
+ * @example
+ * ```ts
+ * const scoring = await fetchOrdersScoring(client, {
+ *   orderIds: ['1', '2'],
+ * });
+ * ```
+ */
+declare function fetchOrdersScoring(client: BaseSecureClient, request: FetchOrdersScoringRequest): Promise<OrdersScoringResponse>;
+declare const ListUserEarningsForDayRequestSchema: z.ZodObject<{
+    cursor: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<_polymarket_bindings.PaginationCursor, string>>>;
+    date: z.ZodString;
+}, z.core.$strip>;
+type ListUserEarningsForDayRequest = z.input<typeof ListUserEarningsForDayRequestSchema>;
+type ListUserEarningsForDayError = RateLimitError | RequestRejectedError | SigningError | TransportError | UnexpectedResponseError | UserInputError;
+/**
+ * Lists per-market earnings for the authenticated account on a given day.
+ *
+ * @throws {@link ListUserEarningsForDayError}
+ *
+ * @example
+ * Fetch the first page of results:
+ * ```ts
+ * const result = listUserEarningsForDay(client, {
+ *   date: '2026-04-16',
+ * });
+ *
+ * const firstPage = await result.firstPage();
+ *
+ * // Optionally, fetch additional pages:
+ * for await (const page of result.from(firstPage.nextCursor)) {
+ *   // page.items: UserEarning[]
+ * }
+ * ```
+ *
+ * @example
+ * Loop through all pages with `for await`:
+ * ```ts
+ * const result = listUserEarningsForDay(client, {
+ *   date: '2026-04-16',
+ * });
+ *
+ * for await (const page of result) {
+ *   // page.items: UserEarning[]
+ * }
+ * ```
+ */
+declare function listUserEarningsForDay(client: BaseSecureClient, request: ListUserEarningsForDayRequest): Paginated<UserEarning>;
+type FetchTotalEarningsForUserForDayRequest = z.input<typeof ListUserEarningsForDayRequestSchema>;
+type FetchTotalEarningsForUserForDayError = RateLimitError | RequestRejectedError | SigningError | TransportError | UnexpectedResponseError | UserInputError;
+/**
+ * Fetches total earnings for the authenticated account on a given day.
+ *
+ * @throws {@link FetchTotalEarningsForUserForDayError}
+ *
+ * @example
+ * ```ts
+ * const earnings = await fetchTotalEarningsForUserForDay(client, {
+ *   date: '2026-04-16',
+ * });
+ * ```
+ */
+declare function fetchTotalEarningsForUserForDay(client: BaseSecureClient, request: FetchTotalEarningsForUserForDayRequest): Promise<TotalUserEarning[]>;
+declare const ListUserEarningsAndMarketsConfigRequestSchema: z.ZodObject<{
+    cursor: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<_polymarket_bindings.PaginationCursor, string>>>;
+    date: z.ZodString;
+    noCompetition: z.ZodOptional<z.ZodBoolean>;
+    orderBy: z.ZodOptional<z.ZodString>;
+    pageSize: z.ZodDefault<z.ZodNumber>;
+    position: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type ListUserEarningsAndMarketsConfigRequest = z.input<typeof ListUserEarningsAndMarketsConfigRequestSchema>;
+type ListUserEarningsAndMarketsConfigError = RateLimitError | RequestRejectedError | SigningError | TransportError | UnexpectedResponseError | UserInputError;
+/**
+ * Lists market reward configuration and earnings for the authenticated account on a given day.
+ *
+ * @throws {@link ListUserEarningsAndMarketsConfigError}
+ *
+ * @example
+ * Fetch the first page of results:
+ * ```ts
+ * const result = listUserEarningsAndMarketsConfig(client, {
+ *   date: '2026-04-16',
+ * });
+ *
+ * const firstPage = await result.firstPage();
+ *
+ * // Optionally, fetch additional pages:
+ * for await (const page of result.from(firstPage.nextCursor)) {
+ *   // page.items: UserRewardsEarning[]
+ * }
+ * ```
+ *
+ * @example
+ * Loop through all pages with `for await`:
+ * ```ts
+ * const result = listUserEarningsAndMarketsConfig(client, {
+ *   date: '2026-04-16',
+ * });
+ *
+ * for await (const page of result) {
+ *   // page.items: UserRewardsEarning[]
+ * }
+ * ```
+ */
+declare function listUserEarningsAndMarketsConfig(client: BaseSecureClient, request: ListUserEarningsAndMarketsConfigRequest): Paginated<UserRewardsEarning>;
+type FetchRewardPercentagesError = RateLimitError | RequestRejectedError | SigningError | TransportError | UnexpectedResponseError;
+/**
+ * Fetches reward percentages for the authenticated account.
+ *
+ * @throws {@link FetchRewardPercentagesError}
+ *
+ * @example
+ * ```ts
+ * const percentages = await fetchRewardPercentages(client);
+ * ```
+ */
+declare function fetchRewardPercentages(client: BaseSecureClient): Promise<RewardsPercentages>;
+
+declare const ListTradesRequestSchema: z.ZodObject<{
+    cursor: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<_polymarket_bindings.PaginationCursor, string>>>;
+    pageSize: z.ZodDefault<z.ZodNumber>;
+    takerOnly: z.ZodOptional<z.ZodBoolean>;
+    filterType: z.ZodOptional<z.ZodEnum<{
+        TOKENS: "TOKENS";
+        CASH: "CASH";
+    }>>;
+    filterAmount: z.ZodOptional<z.ZodNumber>;
+    market: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    eventId: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+    user: z.ZodOptional<z.ZodString>;
+    side: z.ZodOptional<z.ZodEnum<{
+        BUY: "BUY";
+        SELL: "SELL";
+    }>>;
+}, z.core.$strip>;
+declare const ListActivityRequestSchema: z.ZodObject<{
+    cursor: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<_polymarket_bindings.PaginationCursor, string>>>;
+    pageSize: z.ZodDefault<z.ZodNumber>;
+    user: z.ZodString;
+    market: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    eventId: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+    type: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        TRADE: "TRADE";
+        SPLIT: "SPLIT";
+        MERGE: "MERGE";
+        REDEEM: "REDEEM";
+        REWARD: "REWARD";
+        CONVERSION: "CONVERSION";
+        MAKER_REBATE: "MAKER_REBATE";
+    }>>>;
+    start: z.ZodOptional<z.ZodNumber>;
+    end: z.ZodOptional<z.ZodNumber>;
+    sortBy: z.ZodOptional<z.ZodEnum<{
+        TOKENS: "TOKENS";
+        TIMESTAMP: "TIMESTAMP";
+        CASH: "CASH";
+    }>>;
+    sortDirection: z.ZodOptional<z.ZodEnum<{
+        ASC: "ASC";
+        DESC: "DESC";
+    }>>;
+    side: z.ZodOptional<z.ZodEnum<{
+        BUY: "BUY";
+        SELL: "SELL";
+    }>>;
+}, z.core.$strip>;
+type ListTradesRequest = z.input<typeof ListTradesRequestSchema>;
+type ListActivityRequest = z.input<typeof ListActivityRequestSchema>;
+type ListTradesError = RateLimitError | RequestRejectedError | TransportError | UnexpectedResponseError | UserInputError;
+/**
+ * Lists trades for a wallet, market, or event.
+ *
+ * @throws {@link ListTradesError}
+ * Thrown on failure.
+ *
+ * @example
+ * Fetch the first page of results:
+ * ```ts
+ * const result = listTrades(client, {
+ *   user: '0x7c3db723f1d4d8cb9c550095203b686cb11e5c6b',
+ *   pageSize: 10,
+ * });
+ *
+ * const firstPage = await result.firstPage();
+ *
+ * // Optionally, fetch additional pages:
+ * for await (const page of result.from(firstPage.nextCursor)) {
+ *   // page.items: Trade[]
+ * }
+ * ```
+ *
+ * @example
+ * Loop through all pages with `for await`:
+ * ```ts
+ * const result = listTrades(client, {
+ *   user: '0x7c3db723f1d4d8cb9c550095203b686cb11e5c6b',
+ *   pageSize: 10,
+ * });
+ *
+ * for await (const page of result) {
+ *   // page.items: Trade[]
+ * }
+ * ```
+ */
+declare function listTrades(client: BaseClient, request?: ListTradesRequest): Paginated<Trade>;
+type ListActivityError = RateLimitError | RequestRejectedError | TransportError | UnexpectedResponseError | UserInputError;
+/**
+ * Lists wallet activity.
+ *
+ * @throws {@link ListActivityError}
+ * Thrown on failure.
+ *
+ * @example
+ * Fetch the first page of results:
+ * ```ts
+ * const result = listActivity(client, {
+ *   user: '0x7c3db723f1d4d8cb9c550095203b686cb11e5c6b',
+ *   pageSize: 10,
+ * });
+ *
+ * const firstPage = await result.firstPage();
+ *
+ * // Optionally, fetch additional pages:
+ * for await (const page of result.from(firstPage.nextCursor)) {
+ *   // page.items: Activity[]
+ * }
+ * ```
+ *
+ * @example
+ * Loop through all pages with `for await`:
+ * ```ts
+ * const result = listActivity(client, {
+ *   user: '0x7c3db723f1d4d8cb9c550095203b686cb11e5c6b',
+ *   pageSize: 10,
+ * });
+ *
+ * for await (const page of result) {
+ *   // page.items: Activity[]
+ * }
+ * ```
+ */
+declare function listActivity(client: BaseClient, request: ListActivityRequest): Paginated<Activity>;
+
+declare const ListBuilderTradesRequestSchema: z.ZodObject<{
+    after: z.ZodOptional<z.ZodString>;
+    before: z.ZodOptional<z.ZodString>;
+    builder: z.ZodOptional<z.ZodString>;
+    cursor: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<_polymarket_bindings.PaginationCursor, string>>>;
+    id: z.ZodOptional<z.ZodString>;
+    market: z.ZodOptional<z.ZodString>;
+    tokenId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type ListBuilderTradesRequest = z.input<typeof ListBuilderTradesRequestSchema>;
+type ListBuilderTradesError = RateLimitError | RequestRejectedError | TransportError | UnexpectedResponseError | UserInputError;
+/**
+ * Lists builder-attributed trades.
+ *
+ * @throws {@link ListBuilderTradesError}
+ * Thrown on failure.
+ *
+ * @example
+ * Fetch the first page of results:
+ * ```ts
+ * const result = listBuilderTrades(client);
+ *
+ * const firstPage = await result.firstPage();
+ *
+ * // Optionally, fetch additional pages:
+ * for await (const page of result.from(firstPage.nextCursor)) {
+ *   // page.items: BuilderTrade[]
+ * }
+ * ```
+ *
+ * @example
+ * Loop through all pages with `for await`:
+ * ```ts
+ * const result = listBuilderTrades(client);
+ *
+ * for await (const page of result) {
+ *   // page.items: BuilderTrade[]
+ * }
+ * ```
+ */
+declare function listBuilderTrades(client: BaseClient, request?: ListBuilderTradesRequest): Paginated<BuilderTrade>;
+
+declare const FetchMidpointRequestSchema: z.ZodObject<{
+    tokenId: z.ZodString;
+}, z.core.$strip>;
+type FetchMidpointRequest = z.input<typeof FetchMidpointRequestSchema>;
+type FetchMidpointError = RateLimitError | RequestRejectedError | TransportError | UnexpectedResponseError | UserInputError;
+/**
+ * Fetches the midpoint price for a token.
+ *
+ * @throws {@link FetchMidpointError}
+ * Thrown on failure.
+ *
+ * @example
+ * ```ts
+ * const midpoint = await fetchMidpoint(client, {
+ *   tokenId:
+ *     '8501497159083948713316135768103773293754490207922884688769443031624417212426',
+ * });
+ *
+ * // midpoint === '0.53'
+ * ```
+ *
+ */
+declare function fetchMidpoint(client: BaseClient, request: FetchMidpointRequest): Promise<string>;
+declare const FetchMidpointsRequestSchema: z.ZodArray<z.ZodObject<{
+    tokenId: z.ZodString;
+}, z.core.$strip>>;
+type FetchMidpointsRequest = z.input<typeof FetchMidpointsRequestSchema>;
+type FetchMidpointsError = RateLimitError | RequestRejectedError | TransportError | UnexpectedResponseError | UserInputError;
+/**
+ * Fetches midpoint prices for multiple tokens.
+ *
+ * @throws {@link FetchMidpointsError}
+ * Thrown on failure.
+ *
+ * @example
+ * ```ts
+ * const midpoints = await fetchMidpoints(client, [
+ *   {
+ *     tokenId:
+ *       '8501497159083948713316135768103773293754490207922884688769443031624417212426',
+ *   },
+ * ]);
+ *
+ * // midpoints[tokenId] === '0.53'
+ * ```
+ *
+ */
+declare function fetchMidpoints(client: BaseClient, request: FetchMidpointsRequest): Promise<Record<string, string>>;
+declare const FetchTickSizeRequestSchema: z.ZodObject<{
+    tokenId: z.ZodString;
+}, z.core.$strip>;
+type FetchTickSizeRequest = z.input<typeof FetchTickSizeRequestSchema>;
+type FetchTickSizeError = RateLimitError | RequestRejectedError | TransportError | UnexpectedResponseError | UserInputError;
+/**
+ * Fetches the minimum price tick size for a token's order book.
+ *
+ * @remarks
+ * This is a low-level market action that most SDK consumers will not need.
+ *
+ * @throws {@link FetchTickSizeError}
+ * Thrown on failure.
+ *
+ * @example
+ * ```ts
+ * const tickSize = await fetchTickSize(client, {
+ *   tokenId:
+ *     '8501497159083948713316135768103773293754490207922884688769443031624417212426',
+ * });
+ *
+ * // tickSize === 0.01
+ * ```
+ */
+declare function fetchTickSize(client: BaseClient, request: FetchTickSizeRequest): Promise<TickSizeValue>;
+declare const FetchNegRiskRequestSchema: z.ZodObject<{
+    tokenId: z.ZodString;
+}, z.core.$strip>;
+type FetchNegRiskRequest = z.input<typeof FetchNegRiskRequestSchema>;
+type FetchNegRiskError = RateLimitError | RequestRejectedError | TransportError | UnexpectedResponseError | UserInputError;
+/**
+ * Fetches whether a token is in a negative-risk market.
+ *
+ * @remarks
+ * This is a low-level market action that most SDK consumers will not need.
+ *
+ * @throws {@link FetchNegRiskError}
+ * Thrown on failure.
+ *
+ * @example
+ * ```ts
+ * const negRisk = await fetchNegRisk(client, {
+ *   tokenId:
+ *     '8501497159083948713316135768103773293754490207922884688769443031624417212426',
+ * });
+ *
+ * // negRisk === false
+ * ```
+ */
+declare function fetchNegRisk(client: BaseClient, request: FetchNegRiskRequest): Promise<boolean>;
+declare const FetchFeeRateRequestSchema: z.ZodObject<{
+    tokenId: z.ZodString;
+}, z.core.$strip>;
+type FetchFeeRateRequest = z.input<typeof FetchFeeRateRequestSchema>;
+type FetchFeeRateError = RateLimitError | RequestRejectedError | TransportError | UnexpectedResponseError | UserInputError;
+/**
+ * Fetches the base fee rate, in basis points, for a token's order book.
+ *
+ * @remarks
+ * This is a low-level market action that most SDK consumers will not need.
+ *
+ * @throws {@link FetchFeeRateError}
+ * Thrown on failure.
+ *
+ * @example
+ * ```ts
+ * const feeRate = await fetchFeeRate(client, {
+ *   tokenId:
+ *     '8501497159083948713316135768103773293754490207922884688769443031624417212426',
+ * });
+ *
+ * // feeRate === 0
+ * ```
+ */
+declare function fetchFeeRate(client: BaseClient, request: FetchFeeRateRequest): Promise<number>;
+declare const FetchPriceRequestSchema: z.ZodObject<{
+    tokenId: z.ZodString;
+    side: z.ZodEnum<typeof _polymarket_bindings_clob.OrderSide>;
+}, z.core.$strip>;
+type FetchPriceRequest = z.input<typeof FetchPriceRequestSchema>;
+type FetchPriceError = RateLimitError | RequestRejectedError | TransportError | UnexpectedResponseError | UserInputError;
+/**
+ * Fetches the current quoted price for a token and side.
+ *
+ * @throws {@link FetchPriceError}
+ * Thrown on failure.
+ *
+ * @example
+ * ```ts
+ * const price = await fetchPrice(client, {
+ *   tokenId:
+ *     '8501497159083948713316135768103773293754490207922884688769443031624417212426',
+ *   side: OrderSide.BUY,
+ * });
+ *
+ * // price === '0.52'
+ * ```
+ *
+ */
+declare function fetchPrice(client: BaseClient, request: FetchPriceRequest): Promise<string>;
+declare const FetchPricesRequestSchema: z.ZodArray<z.ZodObject<{
+    tokenId: z.ZodString;
+    side: z.ZodEnum<typeof _polymarket_bindings_clob.OrderSide>;
+}, z.core.$strip>>;
+type FetchPricesRequest = z.input<typeof FetchPricesRequestSchema>;
+type FetchPricesError = RateLimitError | RequestRejectedError | TransportError | UnexpectedResponseError | UserInputError;
+/**
+ * Fetches quoted prices for multiple tokens.
+ *
+ * @throws {@link FetchPricesError}
+ * Thrown on failure.
+ *
+ * @example
+ * ```ts
+ * const prices = await fetchPrices(client, [
+ *   {
+ *     tokenId:
+ *       '8501497159083948713316135768103773293754490207922884688769443031624417212426',
+ *     side: OrderSide.BUY,
+ *   },
+ * ]);
+ *
+ * // prices[tokenId]?.BUY === '0.52'
+ * ```
+ *
+ */
+declare function fetchPrices(client: BaseClient, request: FetchPricesRequest): Promise<Prices>;
+declare const FetchOrderBookRequestSchema: z.ZodObject<{
+    tokenId: z.ZodString;
+}, z.core.$strip>;
+type FetchOrderBookRequest = z.input<typeof FetchOrderBookRequestSchema>;
+type FetchOrderBookError = RateLimitError | RequestRejectedError | TransportError | UnexpectedResponseError | UserInputError;
+/**
+ * Fetches the current order book for a token.
+ *
+ * @throws {@link FetchOrderBookError}
+ * Thrown on failure.
+ *
+ * @example
+ * ```ts
+ * const orderBook = await fetchOrderBook(client, {
+ *   tokenId:
+ *     '8501497159083948713316135768103773293754490207922884688769443031624417212426',
+ * });
+ *
+ * // orderBook.bids / orderBook.asks
+ * ```
+ */
+declare function fetchOrderBook(client: BaseClient, request: FetchOrderBookRequest): Promise<OrderBook>;
+declare const FetchOrderBooksRequestSchema: z.ZodArray<z.ZodObject<{
+    tokenId: z.ZodString;
+}, z.core.$strip>>;
+type FetchOrderBooksRequest = z.input<typeof FetchOrderBooksRequestSchema>;
+type FetchOrderBooksError = RateLimitError | RequestRejectedError | TransportError | UnexpectedResponseError | UserInputError;
+/**
+ * Fetches order books for multiple tokens.
+ *
+ * @throws {@link FetchOrderBooksError}
+ * Thrown on failure.
+ *
+ * @example
+ * ```ts
+ * const books = await fetchOrderBooks(client, [
+ *   {
+ *     tokenId:
+ *       '8501497159083948713316135768103773293754490207922884688769443031624417212426',
+ *   },
+ * ])
+ *
+ * // books: OrderBook[]
+ * ```
+ */
+declare function fetchOrderBooks(client: BaseClient, request: FetchOrderBooksRequest): Promise<OrderBook[]>;
+declare const FetchSpreadRequestSchema: z.ZodObject<{
+    tokenId: z.ZodString;
+}, z.core.$strip>;
+type FetchSpreadRequest = z.input<typeof FetchSpreadRequestSchema>;
+type FetchSpreadError = RateLimitError | RequestRejectedError | TransportError | UnexpectedResponseError | UserInputError;
+/**
+ * Fetches the spread for a token.
+ *
+ * @throws {@link FetchSpreadError}
+ * Thrown on failure.
+ *
+ * @example
+ * ```ts
+ * const spread = await fetchSpread(client, {
+ *   tokenId:
+ *     '8501497159083948713316135768103773293754490207922884688769443031624417212426',
+ * });
+ *
+ * // spread === '0.02'
+ * ```
+ *
+ */
+declare function fetchSpread(client: BaseClient, request: FetchSpreadRequest): Promise<string>;
+declare const FetchSpreadsRequestSchema: z.ZodArray<z.ZodObject<{
+    tokenId: z.ZodString;
+}, z.core.$strip>>;
+type FetchSpreadsRequest = z.input<typeof FetchSpreadsRequestSchema>;
+type FetchSpreadsError = RateLimitError | RequestRejectedError | TransportError | UnexpectedResponseError | UserInputError;
+/**
+ * Fetches spreads for multiple tokens.
+ *
+ * @throws {@link FetchSpreadsError}
+ * Thrown on failure.
+ *
+ * @example
+ * ```ts
+ * const spreads = await fetchSpreads(client, [
+ *   {
+ *     tokenId:
+ *       '8501497159083948713316135768103773293754490207922884688769443031624417212426',
+ *   },
+ * ]);
+ *
+ * // spreads[tokenId] === '0.02'
+ * ```
+ *
+ */
+declare function fetchSpreads(client: BaseClient, request: FetchSpreadsRequest): Promise<Record<string, string>>;
+declare const FetchLastTradePriceRequestSchema: z.ZodObject<{
+    tokenId: z.ZodString;
+}, z.core.$strip>;
+type FetchLastTradePriceRequest = z.input<typeof FetchLastTradePriceRequestSchema>;
+type FetchLastTradePriceError = RateLimitError | RequestRejectedError | TransportError | UnexpectedResponseError | UserInputError;
+/**
+ * Fetches the last traded price for a token.
+ *
+ * @throws {@link FetchLastTradePriceError}
+ * Thrown on failure.
+ *
+ * @example
+ * ```ts
+ * const trade = await fetchLastTradePrice(client, {
+ *   tokenId:
+ *     '8501497159083948713316135768103773293754490207922884688769443031624417212426',
+ * });
+ *
+ * // trade === { price: '0.53', side: OrderSide.BUY }
+ * ```
+ *
+ */
+declare function fetchLastTradePrice(client: BaseClient, request: FetchLastTradePriceRequest): Promise<LastTradePrice>;
+declare const FetchLastTradePricesRequestSchema: z.ZodArray<z.ZodObject<{
+    tokenId: z.ZodString;
+}, z.core.$strip>>;
+type FetchLastTradePricesRequest = z.input<typeof FetchLastTradePricesRequestSchema>;
+type FetchLastTradePricesError = RateLimitError | RequestRejectedError | TransportError | UnexpectedResponseError | UserInputError;
+/**
+ * Fetches last traded prices for multiple tokens.
+ *
+ * @throws {@link FetchLastTradePricesError}
+ * Thrown on failure.
+ *
+ * @example
+ * ```ts
+ * const trades = await fetchLastTradePrices(client, [
+ *   {
+ *     tokenId:
+ *       '8501497159083948713316135768103773293754490207922884688769443031624417212426',
+ *   },
+ * ]);
+ *
+ * // trades[0] === { tokenId, price: '0.53', side: OrderSide.BUY }
+ * ```
+ *
+ */
+declare function fetchLastTradePrices(client: BaseClient, request: FetchLastTradePricesRequest): Promise<LastTradePriceForToken[]>;
+declare const ListPriceHistoryRequestSchema: z.ZodObject<{
+    tokenId: z.ZodString;
+    startTs: z.ZodOptional<z.ZodNumber>;
+    endTs: z.ZodOptional<z.ZodNumber>;
+    fidelity: z.ZodOptional<z.ZodNumber>;
+    interval: z.ZodOptional<z.ZodEnum<typeof _polymarket_bindings_clob.PriceHistoryInterval>>;
+}, z.core.$strip>;
+type FetchPriceHistoryRequest = z.input<typeof ListPriceHistoryRequestSchema>;
+type FetchPriceHistoryError = RateLimitError | RequestRejectedError | TransportError | UnexpectedResponseError | UserInputError;
+/**
+ * Fetches historical price points for a token.
+ *
+ * @throws {@link FetchPriceHistoryError}
+ * Thrown on failure.
+ *
+ * @example
+ * ```ts
+ * const history = await fetchPriceHistory(client, {
+ *   tokenId:
+ *     '8501497159083948713316135768103773293754490207922884688769443031624417212426',
+ *   interval: PriceHistoryInterval.ONE_DAY,
+ *   fidelity: 60,
+ * });
+ *
+ * // history === PriceHistoryPoint[]
+ * ```
+ *
+ */
+declare function fetchPriceHistory(client: BaseClient, request: FetchPriceHistoryRequest): Promise<PriceHistoryPoint[]>;
+declare const ListCurrentRewardsRequestSchema: z.ZodDefault<z.ZodObject<{
+    cursor: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<_polymarket_bindings.PaginationCursor, string>>>;
+    sponsored: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>>;
+type ListCurrentRewardsRequest = z.input<typeof ListCurrentRewardsRequestSchema>;
+type ListCurrentRewardsError = RateLimitError | RequestRejectedError | TransportError | UnexpectedResponseError | UserInputError;
+/**
+ * Lists current active market rewards.
+ *
+ * @throws {@link ListCurrentRewardsError}
+ * Thrown on failure.
+ *
+ * @example
+ * Fetch the first page of results:
+ * ```ts
+ * const result = listCurrentRewards(client);
+ *
+ * const firstPage = await result.firstPage();
+ *
+ * // Optionally, fetch additional pages:
+ * for await (const page of result.from(firstPage.nextCursor)) {
+ *   // page.items: CurrentReward[]
+ * }
+ * ```
+ *
+ * @example
+ * Loop through all pages with `for await`:
+ * ```ts
+ * const result = listCurrentRewards(client);
+ *
+ * for await (const page of result) {
+ *   // page.items: CurrentReward[]
+ * }
+ * ```
+ */
+declare function listCurrentRewards(client: BaseClient, request?: ListCurrentRewardsRequest): Paginated<CurrentReward>;
+declare const ListMarketRewardsRequestSchema: z.ZodObject<{
+    conditionId: z.ZodPipe<z.ZodString, z.ZodTransform<_polymarket_bindings.ConditionId, string>>;
+    cursor: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<_polymarket_bindings.PaginationCursor, string>>>;
+    sponsored: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+type ListMarketRewardsRequest = z.input<typeof ListMarketRewardsRequestSchema>;
+type ListMarketRewardsError = RateLimitError | RequestRejectedError | TransportError | UnexpectedResponseError | UserInputError;
+/**
+ * Lists reward configurations for a market.
+ *
+ * @throws {@link ListMarketRewardsError}
+ * Thrown on failure.
+ *
+ * @example
+ * Fetch the first page of results:
+ * ```ts
+ * const result = listMarketRewards(client, {
+ *   conditionId:
+ *     '0xbd31dc8a20211944f6b70f31557f1001557b59905b7738480ca09bd4532f84af',
+ * });
+ *
+ * const firstPage = await result.firstPage();
+ *
+ * // Optionally, fetch additional pages:
+ * for await (const page of result.from(firstPage.nextCursor)) {
+ *   // page.items: MarketReward[]
+ * }
+ * ```
+ *
+ * @example
+ * Loop through all pages with `for await`:
+ * ```ts
+ * const result = listMarketRewards(client, {
+ *   conditionId:
+ *     '0xbd31dc8a20211944f6b70f31557f1001557b59905b7738480ca09bd4532f84af',
+ * });
+ *
+ * for await (const page of result) {
+ *   // page.items: MarketReward[]
+ * }
+ * ```
+ */
+declare function listMarketRewards(client: BaseClient, request: ListMarketRewardsRequest): Paginated<MarketReward>;
+
+declare const ListCommentsRequestSchema: z.ZodObject<{
+    ascending: z.ZodOptional<z.ZodBoolean>;
+    cursor: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<_polymarket_bindings.PaginationCursor, string>>>;
+    pageSize: z.ZodDefault<z.ZodNumber>;
+    getPositions: z.ZodOptional<z.ZodBoolean>;
+    holdersOnly: z.ZodOptional<z.ZodBoolean>;
+    order: z.ZodOptional<z.ZodString>;
+    parentEntityId: z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodPipe<z.ZodNumber, z.ZodTransform<string, number>>]>, z.ZodTransform<_polymarket_bindings.EventId, string>>, z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodPipe<z.ZodNumber, z.ZodTransform<string, number>>]>, z.ZodTransform<_polymarket_bindings.SeriesId, string>>]>;
+    parentEntityType: z.ZodEnum<{
+        Event: "Event";
+        Series: "Series";
+    }>;
+}, z.core.$strip>;
+declare const FetchCommentsByIdRequestSchema: z.ZodObject<{
+    getPositions: z.ZodOptional<z.ZodBoolean>;
+    id: z.ZodPipe<z.ZodString, z.ZodTransform<_polymarket_bindings.CommentId, string>>;
+}, z.core.$strip>;
+declare const ListCommentsByUserAddressRequestSchema: z.ZodObject<{
+    address: z.ZodString;
+    ascending: z.ZodOptional<z.ZodBoolean>;
+    cursor: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<_polymarket_bindings.PaginationCursor, string>>>;
+    order: z.ZodOptional<z.ZodString>;
+    pageSize: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+type ListCommentsRequest = z.input<typeof ListCommentsRequestSchema>;
+type FetchCommentsByIdRequest = z.input<typeof FetchCommentsByIdRequestSchema>;
+type ListCommentsByUserAddressRequest = z.input<typeof ListCommentsByUserAddressRequestSchema>;
+type ListCommentsError = RateLimitError | RequestRejectedError | TransportError | UnexpectedResponseError | UserInputError;
+/**
+ * Lists comments for an event or series.
+ *
+ * @throws {@link ListCommentsError}
+ * Thrown on failure.
+ *
+ * @example
+ * Fetch the first page of results:
+ * ```ts
+ * const result = listComments(client, {
+ *   parentEntityId: '123',
+ *   parentEntityType: 'Event',
+ *   pageSize: 20,
+ * });
+ *
+ * const firstPage = await result.firstPage();
+ *
+ * // Optionally, fetch additional pages:
+ * for await (const page of result.from(firstPage.nextCursor)) {
+ *   // page.items: Comment[]
+ * }
+ * ```
+ *
+ * @example
+ * Loop through all pages with `for await`:
+ * ```ts
+ * const result = listComments(client, {
+ *   parentEntityId: '123',
+ *   parentEntityType: 'Event',
+ *   pageSize: 20,
+ * });
+ *
+ * for await (const page of result) {
+ *   // page.items: Comment[]
+ * }
+ * ```
+ */
+declare function listComments(client: BaseClient, request: ListCommentsRequest): Paginated<Comment>;
+type FetchCommentsByIdError = RateLimitError | RequestRejectedError | TransportError | UnexpectedResponseError | UserInputError;
+/**
+ * Fetches a comment thread by comment id.
+ *
+ * @throws {@link FetchCommentsByIdError}
+ * Thrown on failure.
+ *
+ * @example
+ * ```ts
+ * const thread = await fetchCommentsById(client, {
+ *   id: '456',
+ *   getPositions: true,
+ * });
+ *
+ * // thread: Comment[]
+ * ```
+ */
+declare function fetchCommentsById(client: BaseClient, request: FetchCommentsByIdRequest): Promise<Comment[]>;
+type ListCommentsByUserAddressError = RateLimitError | RequestRejectedError | TransportError | UnexpectedResponseError | UserInputError;
+/**
+ * Lists comments written by a wallet address.
+ *
+ * @throws {@link ListCommentsByUserAddressError}
+ * Thrown on failure.
+ *
+ * @example
+ * Fetch the first page of results:
+ * ```ts
+ * const result = listCommentsByUserAddress(client, {
+ *   address: '0x1234...',
+ *   pageSize: 10,
+ *   order: 'DESC',
+ * });
+ *
+ * const firstPage = await result.firstPage();
+ *
+ * // Optionally, fetch additional pages:
+ * for await (const page of result.from(firstPage.nextCursor)) {
+ *   // page.items: Comment[]
+ * }
+ * ```
+ *
+ * @example
+ * Loop through all pages with `for await`:
+ * ```ts
+ * const result = listCommentsByUserAddress(client, {
+ *   address: '0x1234...',
+ *   pageSize: 10,
+ *   order: 'DESC',
+ * });
+ *
+ * for await (const page of result) {
+ *   // page.items: Comment[]
+ * }
+ * ```
+ */
+declare function listCommentsByUserAddress(client: BaseClient, request: ListCommentsByUserAddressRequest): Paginated<Comment>;
+
+declare const ListEventsRequestSchema: z.ZodObject<{
+    ascending: z.ZodOptional<z.ZodBoolean>;
+    closed: z.ZodOptional<z.ZodBoolean>;
+    cursor: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<_polymarket_bindings.PaginationCursor, string>>>;
+    pageSize: z.ZodOptional<z.ZodNumber>;
+    cyom: z.ZodOptional<z.ZodBoolean>;
+    endDateMax: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodPipe<z.ZodDate, z.ZodTransform<string, Date>>]>>;
+    endDateMin: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodPipe<z.ZodDate, z.ZodTransform<string, Date>>]>>;
+    ended: z.ZodOptional<z.ZodBoolean>;
+    eventDate: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodPipe<z.ZodDate, z.ZodTransform<string, Date>>]>>;
+    eventWeek: z.ZodOptional<z.ZodNumber>;
+    excludeTagIds: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+    featured: z.ZodOptional<z.ZodBoolean>;
+    featuredOrder: z.ZodOptional<z.ZodBoolean>;
+    gameIds: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+    ids: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+    includeBestLines: z.ZodOptional<z.ZodBoolean>;
+    includeChat: z.ZodOptional<z.ZodBoolean>;
+    includeChildren: z.ZodOptional<z.ZodBoolean>;
+    includeTemplate: z.ZodOptional<z.ZodBoolean>;
+    liquidityMax: z.ZodOptional<z.ZodNumber>;
+    liquidityMin: z.ZodOptional<z.ZodNumber>;
+    live: z.ZodOptional<z.ZodBoolean>;
+    locale: z.ZodOptional<z.ZodString>;
+    order: z.ZodOptional<z.ZodString>;
+    parentEventId: z.ZodOptional<z.ZodNumber>;
+    partnerSlug: z.ZodOptional<z.ZodString>;
+    recurrence: z.ZodOptional<z.ZodEnum<{
+        daily: "daily";
+        weekly: "weekly";
+        monthly: "monthly";
+    }>>;
+    relatedTags: z.ZodOptional<z.ZodBoolean>;
+    seriesIds: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+    slug: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    startDateMax: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodPipe<z.ZodDate, z.ZodTransform<string, Date>>]>>;
+    startDateMin: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodPipe<z.ZodDate, z.ZodTransform<string, Date>>]>>;
+    startTimeMax: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodPipe<z.ZodDate, z.ZodTransform<string, Date>>]>>;
+    startTimeMin: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodPipe<z.ZodDate, z.ZodTransform<string, Date>>]>>;
+    tagIds: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+    tagMatch: z.ZodOptional<z.ZodEnum<{
+        any: "any";
+        all: "all";
+    }>>;
+    tagSlug: z.ZodOptional<z.ZodString>;
+    titleSearch: z.ZodOptional<z.ZodString>;
+    volumeMax: z.ZodOptional<z.ZodNumber>;
+    volumeMin: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+type ListEventsRequest = z.input<typeof ListEventsRequestSchema>;
+declare const FetchEventRequestSchema: z.ZodUnion<readonly [z.ZodObject<{
+    id: z.ZodString;
+    includeBestLines: z.ZodOptional<z.ZodBoolean>;
+    includeChat: z.ZodOptional<z.ZodBoolean>;
+    includeTemplate: z.ZodOptional<z.ZodBoolean>;
+    locale: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    slug: z.ZodString;
+    includeBestLines: z.ZodOptional<z.ZodBoolean>;
+    includeChat: z.ZodOptional<z.ZodBoolean>;
+    includeTemplate: z.ZodOptional<z.ZodBoolean>;
+    locale: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>]>;
+type FetchEventRequest = z.input<typeof FetchEventRequestSchema>;
+declare const FetchEventTagsRequestSchema: z.ZodObject<{
+    id: z.ZodString;
+}, z.core.$strip>;
+type FetchEventTagsRequest = z.input<typeof FetchEventTagsRequestSchema>;
+declare const FetchEventLiveVolumeRequestSchema: z.ZodObject<{
+    id: z.ZodString;
+}, z.core.$strip>;
+type FetchEventLiveVolumeRequest = z.input<typeof FetchEventLiveVolumeRequestSchema>;
+type ListEventsError = RateLimitError | RequestRejectedError | TransportError | UnexpectedResponseError | UserInputError;
+/**
+ * Lists events.
+ *
+ * @throws {@link ListEventsError}
+ * Thrown on failure.
+ *
+ * @example
+ * Fetch the first page of results:
+ * ```ts
+ * const result = listEvents(client, {
+ *   closed: false,
+ *   pageSize: 10,
+ * });
+ *
+ * const firstPage = await result.firstPage();
+ *
+ * // Optionally, fetch additional pages:
+ * for await (const page of result.from(firstPage.nextCursor)) {
+ *   // page.items: Event[]
+ * }
+ * ```
+ *
+ * @example
+ * Loop through all pages with `for await`:
+ * ```ts
+ * const result = listEvents(client, {
+ *   closed: false,
+ *   pageSize: 10,
+ * });
+ *
+ * for await (const page of result) {
+ *   // page.items: Event[]
+ * }
+ * ```
+ */
+declare function listEvents(client: BaseClient, request?: ListEventsRequest): Paginated<Event>;
+type FetchEventError = RateLimitError | RequestRejectedError | TransportError | UnexpectedResponseError | UserInputError;
+/**
+ * Fetches an event.
+ *
+ * @throws {@link FetchEventError}
+ * Thrown on failure.
+ *
+ * @example
+ * ```ts
+ * const event = await fetchEvent(client, {
+ *   id: '12345',
+ * });
+ *
+ * // event === Event
+ * ```
+ */
+declare function fetchEvent(client: BaseClient, request: FetchEventRequest): Promise<Event>;
+type FetchEventTagsError = RateLimitError | RequestRejectedError | TransportError | UnexpectedResponseError | UserInputError;
+/**
+ * Fetches an event's tags.
+ *
+ * @throws {@link FetchEventTagsError}
+ * Thrown on failure.
+ *
+ * @example
+ * ```ts
+ * const tags = await fetchEventTags(client, {
+ *   id: '12345',
+ * });
+ *
+ * // tags: TagReference[]
+ * ```
+ */
+declare function fetchEventTags(client: BaseClient, request: FetchEventTagsRequest): Promise<TagReference[]>;
+type FetchEventLiveVolumeError = RateLimitError | RequestRejectedError | TransportError | UnexpectedResponseError | UserInputError;
+/**
+ * Fetches live volume for an event.
+ *
+ * @throws {@link FetchEventLiveVolumeError}
+ * Thrown on failure.
+ *
+ * @example
+ * ```ts
+ * const volume = await fetchEventLiveVolume(client, {
+ *   id: '160707',
+ * });
+ *
+ * // volume: LiveVolume[]
+ * ```
+ */
+declare function fetchEventLiveVolume(client: BaseClient, request: FetchEventLiveVolumeRequest): Promise<LiveVolume[]>;
+
+declare const ListBuilderLeaderboardRequestSchema: z.ZodObject<{
+    cursor: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<_polymarket_bindings.PaginationCursor, string>>>;
+    pageSize: z.ZodDefault<z.ZodNumber>;
+    timePeriod: z.ZodOptional<z.ZodEnum<{
+        DAY: "DAY";
+        WEEK: "WEEK";
+        MONTH: "MONTH";
+        ALL: "ALL";
+    }>>;
+}, z.core.$strip>;
+declare const ListBuilderVolumeRequestSchema: z.ZodObject<{
+    timePeriod: z.ZodOptional<z.ZodEnum<{
+        DAY: "DAY";
+        WEEK: "WEEK";
+        MONTH: "MONTH";
+        ALL: "ALL";
+    }>>;
+}, z.core.$strip>;
+declare const ListTraderLeaderboardRequestSchema: z.ZodObject<{
+    category: z.ZodOptional<z.ZodEnum<{
+        OVERALL: "OVERALL";
+        POLITICS: "POLITICS";
+        SPORTS: "SPORTS";
+        CRYPTO: "CRYPTO";
+        CULTURE: "CULTURE";
+        MENTIONS: "MENTIONS";
+        WEATHER: "WEATHER";
+        ECONOMICS: "ECONOMICS";
+        TECH: "TECH";
+        FINANCE: "FINANCE";
+    }>>;
+    cursor: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<_polymarket_bindings.PaginationCursor, string>>>;
+    pageSize: z.ZodDefault<z.ZodNumber>;
+    timePeriod: z.ZodOptional<z.ZodEnum<{
+        DAY: "DAY";
+        WEEK: "WEEK";
+        MONTH: "MONTH";
+        ALL: "ALL";
+    }>>;
+    orderBy: z.ZodOptional<z.ZodEnum<{
+        PNL: "PNL";
+        VOL: "VOL";
+    }>>;
+    user: z.ZodOptional<z.ZodString>;
+    userName: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type ListBuilderLeaderboardRequest = z.input<typeof ListBuilderLeaderboardRequestSchema>;
+type ListBuilderVolumeRequest = z.input<typeof ListBuilderVolumeRequestSchema>;
+type ListTraderLeaderboardRequest = z.input<typeof ListTraderLeaderboardRequestSchema>;
+type ListBuilderLeaderboardError = RateLimitError | RequestRejectedError | TransportError | UnexpectedResponseError | UserInputError;
+/**
+ * Lists builder leaderboard rankings.
+ *
+ * @throws {@link ListBuilderLeaderboardError}
+ * Thrown on failure.
+ *
+ * @example
+ * Fetch the first page of results:
+ * ```ts
+ * const result = listBuilderLeaderboard(client, {
+ *   pageSize: 10,
+ *   timePeriod: 'DAY',
+ * });
+ *
+ * const firstPage = await result.firstPage();
+ *
+ * // Optionally, fetch additional pages:
+ * for await (const page of result.from(firstPage.nextCursor)) {
+ *   // page.items: LeaderboardEntry[]
+ * }
+ * ```
+ *
+ * @example
+ * Loop through all pages with `for await`:
+ * ```ts
+ * const result = listBuilderLeaderboard(client, {
+ *   pageSize: 10,
+ *   timePeriod: 'DAY',
+ * });
+ *
+ * for await (const page of result) {
+ *   // page.items: LeaderboardEntry[]
+ * }
+ * ```
+ */
+declare function listBuilderLeaderboard(client: BaseClient, request?: ListBuilderLeaderboardRequest): Paginated<LeaderboardEntry>;
+type ListBuilderVolumeError = RateLimitError | RequestRejectedError | TransportError | UnexpectedResponseError | UserInputError;
+/**
+ * Lists daily builder volume entries.
+ *
+ * @throws {@link ListBuilderVolumeError}
+ * Thrown on failure.
+ *
+ * @example
+ * ```ts
+ * const volume = await fetchBuilderVolume(client, {
+ *   timePeriod: 'DAY',
+ * });
+ *
+ * // volume: BuilderVolumeEntry[]
+ * ```
+ */
+declare function fetchBuilderVolume(client: BaseClient, request?: ListBuilderVolumeRequest): Promise<BuilderVolumeEntry[]>;
+type ListTraderLeaderboardError = RateLimitError | RequestRejectedError | TransportError | UnexpectedResponseError | UserInputError;
+/**
+ * Lists trader leaderboard rankings.
+ *
+ * @throws {@link ListTraderLeaderboardError}
+ * Thrown on failure.
+ *
+ * @example
+ * Fetch the first page of results:
+ * ```ts
+ * const result = listTraderLeaderboard(client, {
+ *   orderBy: 'PNL',
+ *   pageSize: 10,
+ *   timePeriod: 'DAY',
+ * });
+ *
+ * const firstPage = await result.firstPage();
+ *
+ * // Optionally, fetch additional pages:
+ * for await (const page of result.from(firstPage.nextCursor)) {
+ *   // page.items: TraderLeaderboardEntry[]
+ * }
+ * ```
+ *
+ * @example
+ * Loop through all pages with `for await`:
+ * ```ts
+ * const result = listTraderLeaderboard(client, {
+ *   orderBy: 'PNL',
+ *   pageSize: 10,
+ *   timePeriod: 'DAY',
+ * });
+ *
+ * for await (const page of result) {
+ *   // page.items: TraderLeaderboardEntry[]
+ * }
+ * ```
+ */
+declare function listTraderLeaderboard(client: BaseClient, request?: ListTraderLeaderboardRequest): Paginated<TraderLeaderboardEntry>;
+
+declare const ListMarketsRequestSchema: z.ZodObject<{
+    ascending: z.ZodOptional<z.ZodBoolean>;
+    closed: z.ZodOptional<z.ZodBoolean>;
+    clobTokenIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    cursor: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<_polymarket_bindings.PaginationCursor, string>>>;
+    pageSize: z.ZodOptional<z.ZodNumber>;
+    conditionIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    cyom: z.ZodOptional<z.ZodBoolean>;
+    decimalized: z.ZodOptional<z.ZodBoolean>;
+    endDateMax: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodPipe<z.ZodDate, z.ZodTransform<string, Date>>]>>;
+    endDateMin: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodPipe<z.ZodDate, z.ZodTransform<string, Date>>]>>;
+    gameId: z.ZodOptional<z.ZodString>;
+    ids: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+    includeTag: z.ZodOptional<z.ZodBoolean>;
+    liquidityNumMax: z.ZodOptional<z.ZodNumber>;
+    liquidityNumMin: z.ZodOptional<z.ZodNumber>;
+    locale: z.ZodOptional<z.ZodString>;
+    marketMakerAddresses: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    order: z.ZodOptional<z.ZodString>;
+    questionIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    relatedTags: z.ZodOptional<z.ZodBoolean>;
+    rfqEnabled: z.ZodOptional<z.ZodBoolean>;
+    rewardsMinSize: z.ZodOptional<z.ZodNumber>;
+    slug: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    sportsMarketTypes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    startDateMax: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodPipe<z.ZodDate, z.ZodTransform<string, Date>>]>>;
+    startDateMin: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodPipe<z.ZodDate, z.ZodTransform<string, Date>>]>>;
+    tagId: z.ZodOptional<z.ZodNumber>;
+    tagMatch: z.ZodOptional<z.ZodEnum<{
+        any: "any";
+        all: "all";
+    }>>;
+    umaResolutionStatus: z.ZodOptional<z.ZodString>;
+    volumeNumMax: z.ZodOptional<z.ZodNumber>;
+    volumeNumMin: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+type ListMarketsRequest = z.input<typeof ListMarketsRequestSchema>;
+declare const FetchMarketRequestSchema: z.ZodUnion<readonly [z.ZodObject<{
+    id: z.ZodString;
+    includeTag: z.ZodOptional<z.ZodBoolean>;
+    locale: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    slug: z.ZodString;
+    includeTag: z.ZodOptional<z.ZodBoolean>;
+    locale: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>]>;
+type FetchMarketRequest = z.input<typeof FetchMarketRequestSchema>;
+declare const FetchMarketTagsRequestSchema: z.ZodObject<{
+    id: z.ZodString;
+}, z.core.$strip>;
+type FetchMarketTagsRequest = z.input<typeof FetchMarketTagsRequestSchema>;
+declare const ListMarketHoldersRequestSchema: z.ZodObject<{
+    limit: z.ZodOptional<z.ZodNumber>;
+    market: z.ZodArray<z.ZodString>;
+    minBalance: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+declare const ListOpenInterestRequestSchema: z.ZodObject<{
+    market: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+declare const ListMarketPositionsRequestSchema: z.ZodObject<{
+    cursor: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<_polymarket_bindings.PaginationCursor, string>>>;
+    market: z.ZodString;
+    pageSize: z.ZodDefault<z.ZodNumber>;
+    user: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodEnum<{
+        OPEN: "OPEN";
+        CLOSED: "CLOSED";
+        ALL: "ALL";
+    }>>;
+    sortBy: z.ZodOptional<z.ZodEnum<{
+        TOKENS: "TOKENS";
+        CASH_PNL: "CASH_PNL";
+        REALIZED_PNL: "REALIZED_PNL";
+        TOTAL_PNL: "TOTAL_PNL";
+    }>>;
+    sortDirection: z.ZodOptional<z.ZodEnum<{
+        ASC: "ASC";
+        DESC: "DESC";
+    }>>;
+}, z.core.$strip>;
+type ListMarketHoldersRequest = z.input<typeof ListMarketHoldersRequestSchema>;
+type ListOpenInterestRequest = z.input<typeof ListOpenInterestRequestSchema>;
+type ListMarketPositionsRequest = z.input<typeof ListMarketPositionsRequestSchema>;
+type ListMarketsError = RateLimitError | RequestRejectedError | TransportError | UnexpectedResponseError | UserInputError;
+/**
+ * Lists markets.
+ *
+ * @throws {@link ListMarketsError}
+ * Thrown on failure.
+ *
+ * @example
+ * Fetch the first page of results:
+ * ```ts
+ * const result = listMarkets(client, {
+ *   closed: false,
+ *   pageSize: 10,
+ * });
+ *
+ * const firstPage = await result.firstPage();
+ *
+ * // Optionally, fetch additional pages:
+ * for await (const page of result.from(firstPage.nextCursor)) {
+ *   // page.items: Market[]
+ * }
+ * ```
+ *
+ * @example
+ * Loop through all pages with `for await`:
+ * ```ts
+ * const result = listMarkets(client, {
+ *   closed: false,
+ *   pageSize: 10,
+ * });
+ *
+ * for await (const page of result) {
+ *   // page.items: Market[]
+ * }
+ * ```
+ */
+declare function listMarkets(client: BaseClient, request?: ListMarketsRequest): Paginated<Market>;
+type FetchMarketError = RateLimitError | RequestRejectedError | TransportError | UnexpectedResponseError | UserInputError;
+/**
+ * Fetches a market.
+ *
+ * @throws {@link FetchMarketError}
+ * Thrown on failure.
+ *
+ * @example
+ * ```ts
+ * const market = await fetchMarket(client, {
+ *   id: '12345',
+ * });
+ *
+ * // market === Market
+ * ```
+ */
+declare function fetchMarket(client: BaseClient, request: FetchMarketRequest): Promise<Market>;
+type FetchMarketTagsError = RateLimitError | RequestRejectedError | TransportError | UnexpectedResponseError | UserInputError;
+/**
+ * Fetches a market's tags.
+ *
+ * @throws {@link FetchMarketTagsError}
+ * Thrown on failure.
+ *
+ * @example
+ * ```ts
+ * const tags = await fetchMarketTags(client, {
+ *   id: '12345',
+ * });
+ *
+ * // tags: TagReference[]
+ * ```
+ */
+declare function fetchMarketTags(client: BaseClient, request: FetchMarketTagsRequest): Promise<TagReference[]>;
+type ListMarketHoldersError = RateLimitError | RequestRejectedError | TransportError | UnexpectedResponseError | UserInputError;
+/**
+ * Lists the top holders for one or more markets.
+ *
+ * @throws {@link ListMarketHoldersError}
+ * Thrown on failure.
+ *
+ * @example
+ * ```ts
+ * const holders = await listMarketHolders(client, {
+ *   market: ['0xe546672750517f62c45a5a00067481981e62b9c20fa8220203232c9dc8fd2093'],
+ *   limit: 5,
+ * });
+ *
+ * // holders: MetaHolder[]
+ * ```
+ */
+declare function listMarketHolders(client: BaseClient, request: ListMarketHoldersRequest): Promise<MetaHolder[]>;
+type ListOpenInterestError = RateLimitError | RequestRejectedError | TransportError | UnexpectedResponseError | UserInputError;
+/**
+ * Lists open interest for one or more markets.
+ *
+ * @throws {@link ListOpenInterestError}
+ * Thrown on failure.
+ *
+ * @example
+ * ```ts
+ * const openInterest = await listOpenInterest(client, {
+ *   market: ['0xe546672750517f62c45a5a00067481981e62b9c20fa8220203232c9dc8fd2093'],
+ * });
+ *
+ * // openInterest: OpenInterest[]
+ * ```
+ */
+declare function listOpenInterest(client: BaseClient, request?: ListOpenInterestRequest): Promise<OpenInterest[]>;
+type ListMarketPositionsError = RateLimitError | RequestRejectedError | TransportError | UnexpectedResponseError | UserInputError;
+/**
+ * Lists positions for a market.
+ *
+ * @throws {@link ListMarketPositionsError}
+ * Thrown on failure.
+ *
+ * @example
+ * Fetch the first page of results:
+ * ```ts
+ * const result = listMarketPositions(client, {
+ *   market: '0xe546672750517f62c45a5a00067481981e62b9c20fa8220203232c9dc8fd2093',
+ *   pageSize: 10,
+ * });
+ *
+ * const firstPage = await result.firstPage();
+ *
+ * // Optionally, fetch additional pages:
+ * for await (const page of result.from(firstPage.nextCursor)) {
+ *   // page.items: MetaMarketPositionV1[]
+ * }
+ * ```
+ *
+ * @example
+ * Loop through all pages with `for await`:
+ * ```ts
+ * const result = listMarketPositions(client, {
+ *   market: '0xe546672750517f62c45a5a00067481981e62b9c20fa8220203232c9dc8fd2093',
+ *   pageSize: 10,
+ * });
+ *
+ * for await (const page of result) {
+ *   // page.items: MetaMarketPositionV1[]
+ * }
+ * ```
+ */
+declare function listMarketPositions(client: BaseClient, request: ListMarketPositionsRequest): Paginated<MetaMarketPositionV1>;
+
+declare const ListPositionsRequestSchema: z.ZodObject<{
+    cursor: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<_polymarket_bindings.PaginationCursor, string>>>;
+    user: z.ZodString;
+    market: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    eventId: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+    sizeThreshold: z.ZodOptional<z.ZodNumber>;
+    redeemable: z.ZodOptional<z.ZodBoolean>;
+    mergeable: z.ZodOptional<z.ZodBoolean>;
+    pageSize: z.ZodDefault<z.ZodNumber>;
+    sortBy: z.ZodOptional<z.ZodEnum<{
+        CURRENT: "CURRENT";
+        INITIAL: "INITIAL";
+        TOKENS: "TOKENS";
+        CASHPNL: "CASHPNL";
+        PERCENTPNL: "PERCENTPNL";
+        TITLE: "TITLE";
+        RESOLVING: "RESOLVING";
+        PRICE: "PRICE";
+        AVGPRICE: "AVGPRICE";
+    }>>;
+    sortDirection: z.ZodOptional<z.ZodEnum<{
+        ASC: "ASC";
+        DESC: "DESC";
+    }>>;
+    title: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const ListClosedPositionsRequestSchema: z.ZodObject<{
+    cursor: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<_polymarket_bindings.PaginationCursor, string>>>;
+    user: z.ZodString;
+    market: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    title: z.ZodOptional<z.ZodString>;
+    eventId: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+    pageSize: z.ZodDefault<z.ZodNumber>;
+    sortBy: z.ZodOptional<z.ZodEnum<{
+        TITLE: "TITLE";
+        PRICE: "PRICE";
+        AVGPRICE: "AVGPRICE";
+        REALIZEDPNL: "REALIZEDPNL";
+        TIMESTAMP: "TIMESTAMP";
+    }>>;
+    sortDirection: z.ZodOptional<z.ZodEnum<{
+        ASC: "ASC";
+        DESC: "DESC";
+    }>>;
+}, z.core.$strip>;
+declare const FetchPortfolioValueRequestSchema: z.ZodObject<{
+    user: z.ZodString;
+    market: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+declare const FetchTradedMarketCountRequestSchema: z.ZodObject<{
+    user: z.ZodString;
+}, z.core.$strip>;
+declare const DownloadAccountingSnapshotRequestSchema: z.ZodObject<{
+    user: z.ZodString;
+}, z.core.$strip>;
+type ListPositionsRequest = z.input<typeof ListPositionsRequestSchema>;
+type ListClosedPositionsRequest = z.input<typeof ListClosedPositionsRequestSchema>;
+type FetchPortfolioValueRequest = z.input<typeof FetchPortfolioValueRequestSchema>;
+type FetchTradedMarketCountRequest = z.input<typeof FetchTradedMarketCountRequestSchema>;
+type DownloadAccountingSnapshotRequest = z.input<typeof DownloadAccountingSnapshotRequestSchema>;
+type ListPositionsError = RateLimitError | RequestRejectedError | TransportError | UnexpectedResponseError | UserInputError;
+/**
+ * Lists current positions for a wallet.
+ *
+ * @throws {@link ListPositionsError}
+ * Thrown on failure.
+ *
+ * @example
+ * Fetch the first page of results:
+ * ```ts
+ * const result = listPositions(client, {
+ *   user: '0x7c3db723f1d4d8cb9c550095203b686cb11e5c6b',
+ *   pageSize: 10,
+ * });
+ *
+ * const firstPage = await result.firstPage();
+ *
+ * // Optionally, fetch additional pages:
+ * for await (const page of result.from(firstPage.nextCursor)) {
+ *   // page.items: Position[]
+ * }
+ * ```
+ *
+ * @example
+ * Loop through all pages with `for await`:
+ * ```ts
+ * const result = listPositions(client, {
+ *   user: '0x7c3db723f1d4d8cb9c550095203b686cb11e5c6b',
+ *   pageSize: 10,
+ * });
+ *
+ * for await (const page of result) {
+ *   // page.items: Position[]
+ * }
+ * ```
+ */
+declare function listPositions(client: BaseClient, request: ListPositionsRequest): Paginated<Position>;
+type ListClosedPositionsError = RateLimitError | RequestRejectedError | TransportError | UnexpectedResponseError | UserInputError;
+/**
+ * Lists closed positions for a wallet.
+ *
+ * @throws {@link ListClosedPositionsError}
+ * Thrown on failure.
+ *
+ * @example
+ * Fetch the first page of results:
+ * ```ts
+ * const result = listClosedPositions(client, {
+ *   user: '0x7c3db723f1d4d8cb9c550095203b686cb11e5c6b',
+ *   pageSize: 10,
+ * });
+ *
+ * const firstPage = await result.firstPage();
+ *
+ * // Optionally, fetch additional pages:
+ * for await (const page of result.from(firstPage.nextCursor)) {
+ *   // page.items: ClosedPosition[]
+ * }
+ * ```
+ *
+ * @example
+ * Loop through all pages with `for await`:
+ * ```ts
+ * const result = listClosedPositions(client, {
+ *   user: '0x7c3db723f1d4d8cb9c550095203b686cb11e5c6b',
+ *   pageSize: 10,
+ * });
+ *
+ * for await (const page of result) {
+ *   // page.items: ClosedPosition[]
+ * }
+ * ```
+ */
+declare function listClosedPositions(client: BaseClient, request: ListClosedPositionsRequest): Paginated<ClosedPosition>;
+type FetchPortfolioValueError = RateLimitError | RequestRejectedError | TransportError | UnexpectedResponseError | UserInputError;
+/**
+ * Fetches the total value for a wallet's positions.
+ *
+ * @throws {@link FetchPortfolioValueError}
+ * Thrown on failure.
+ *
+ * @example
+ * ```ts
+ * const value = await fetchPortfolioValue(client, {
+ *   user: '0x7c3db723f1d4d8cb9c550095203b686cb11e5c6b',
+ * });
+ *
+ * // value: Value[]
+ * ```
+ */
+declare function fetchPortfolioValue(client: BaseClient, request: FetchPortfolioValueRequest): Promise<Value[]>;
+type FetchTradedMarketCountError = RateLimitError | RequestRejectedError | TransportError | UnexpectedResponseError | UserInputError;
+/**
+ * Fetches the total number of markets a wallet has traded.
+ *
+ * @throws {@link FetchTradedMarketCountError}
+ * Thrown on failure.
+ *
+ * @example
+ * ```ts
+ * const traded = await fetchTradedMarketCount(client, {
+ *   user: '0x7c3db723f1d4d8cb9c550095203b686cb11e5c6b',
+ * });
+ *
+ * // traded === Traded
+ * ```
+ */
+declare function fetchTradedMarketCount(client: BaseClient, request: FetchTradedMarketCountRequest): Promise<Traded>;
+type DownloadAccountingSnapshotError = RateLimitError | RequestRejectedError | TransportError | UnexpectedResponseError | UserInputError;
+/**
+ * Downloads an accounting snapshot archive for a wallet.
+ *
+ * @throws {@link DownloadAccountingSnapshotError}
+ * Thrown on failure.
+ *
+ * @example
+ * ```ts
+ * const snapshot = await downloadAccountingSnapshot(client, {
+ *   user: '0x7c3db723f1d4d8cb9c550095203b686cb11e5c6b',
+ * });
+ *
+ * // snapshot === Blob
+ * ```
+ */
+declare function downloadAccountingSnapshot(client: BaseClient, request: DownloadAccountingSnapshotRequest): Promise<Blob>;
+
+declare const PrepareSplitPositionRequestSchema: z.ZodObject<{
+    amount: z.ZodBigInt;
+    conditionId: z.ZodPipe<z.ZodString, z.ZodTransform<ConditionId, string>>;
+    metadata: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const PrepareMergePositionsRequestSchema: z.ZodObject<{
+    amount: z.ZodUnion<readonly [z.ZodBigInt, z.ZodLiteral<"max">]>;
+    conditionId: z.ZodPipe<z.ZodString, z.ZodTransform<ConditionId, string>>;
+    metadata: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const PrepareRedeemPositionsRequestSchema: z.ZodObject<{
+    conditionId: z.ZodPipe<z.ZodString, z.ZodTransform<ConditionId, string>>;
+    metadata: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type SplitPositionWorkflowRequest = GaslessWorkflowRequest | SendSplitPositionTransactionRequest;
+type MergePositionsWorkflowRequest = GaslessWorkflowRequest | SendMergePositionsTransactionRequest;
+type RedeemPositionsWorkflowRequest = GaslessWorkflowRequest | SendRedeemPositionsTransactionRequest;
+type SplitPositionWorkflow = AsyncGenerator<SplitPositionWorkflowRequest, TransactionHandle, EvmAddress | EvmSignature | TransactionHandle>;
+type MergePositionsWorkflow = AsyncGenerator<MergePositionsWorkflowRequest, TransactionHandle, EvmAddress | EvmSignature | TransactionHandle>;
+type RedeemPositionsWorkflow = AsyncGenerator<RedeemPositionsWorkflowRequest, TransactionHandle, EvmAddress | EvmSignature | TransactionHandle>;
+type PrepareSplitPositionRequest = z.input<typeof PrepareSplitPositionRequestSchema>;
+type PrepareMergePositionsRequest = z.input<typeof PrepareMergePositionsRequestSchema>;
+type PrepareRedeemPositionsRequest = z.input<typeof PrepareRedeemPositionsRequestSchema>;
+type PrepareSplitPositionError = UserInputError;
+type PrepareMergePositionsError = RateLimitError | RequestRejectedError | TransportError | UnexpectedResponseError | UserInputError;
+type PrepareRedeemPositionsError = RateLimitError | RequestRejectedError | TransportError | UnexpectedResponseError | UserInputError;
+/**
+ * Starts a split workflow for a market condition.
+ *
+ * @example
+ * ```ts
+ * const handle = await prepareSplitPosition(client, {
+ *   amount: 1n,
+ *   conditionId:
+ *     '0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef',
+ * }).then(completeWith(wallet));
+ *
+ * const outcome = await handle.wait();
+ *
+ * // outcome.transactionHash: TxHash
+ * ```
+ *
+ * @throws {@link PrepareSplitPositionError}
+ * Thrown on failure.
+ */
+declare function prepareSplitPosition(client: BaseSecureClient, request: PrepareSplitPositionRequest): Promise<SplitPositionWorkflow>;
+/**
+ * Starts a workflow to merge complementary positions in a market back into collateral.
+ *
+ * @example
+ * ```ts
+ * const handle = await prepareMergePositions(client, {
+ *   amount: 'max',
+ *   conditionId:
+ *     '0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef',
+ * }).then(completeWith(wallet));
+ *
+ * const outcome = await handle.wait();
+ *
+ * // outcome.transactionHash: TxHash
+ * ```
+ *
+ * @throws {@link PrepareMergePositionsError}
+ * Thrown on failure.
+ */
+declare function prepareMergePositions(client: BaseSecureClient, request: PrepareMergePositionsRequest): Promise<MergePositionsWorkflow>;
+/**
+ * Starts a redemption workflow for resolved positions.
+ *
+ * @example
+ * ```ts
+ * const handle = await prepareRedeemPositions(client, {
+ *   conditionId:
+ *     '0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef',
+ * }).then(completeWith(wallet));
+ *
+ * const outcome = await handle.wait();
+ *
+ * // outcome.transactionHash: TxHash
+ * ```
+ *
+ * @throws {@link PrepareRedeemPositionsError}
+ * Thrown on failure.
+ */
+declare function prepareRedeemPositions(client: BaseSecureClient, request: PrepareRedeemPositionsRequest): Promise<RedeemPositionsWorkflow>;
+
+declare const FetchPublicProfileRequestSchema: z.ZodObject<{
+    address: z.ZodString;
+}, z.core.$strip>;
+type FetchPublicProfileRequest = z.input<typeof FetchPublicProfileRequestSchema>;
+type FetchPublicProfileError = RateLimitError | RequestRejectedError | TransportError | UnexpectedResponseError | UserInputError;
+/**
+ * Fetches a public profile by wallet address.
+ *
+ * @throws {@link FetchPublicProfileError}
+ * Thrown on failure.
+ *
+ * @example
+ * ```ts
+ * const profile = await fetchPublicProfile(client, {
+ *   address: '0x7c3db723f1d4d8cb9c550095203b686cb11e5c6b',
+ * });
+ *
+ * // profile === PublicProfile | null
+ * ```
+ */
+declare function fetchPublicProfile(client: BaseClient, request: FetchPublicProfileRequest): Promise<PublicProfile | null>;
+
+declare const SearchRequestSchema: z.ZodObject<{
+    q: z.ZodString;
+    ascending: z.ZodOptional<z.ZodBoolean>;
+    cache: z.ZodOptional<z.ZodBoolean>;
+    eventsStatus: z.ZodOptional<z.ZodString>;
+    eventsTag: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    excludeTagIds: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+    keepClosedMarkets: z.ZodOptional<z.ZodNumber>;
+    limitPerType: z.ZodOptional<z.ZodNumber>;
+    optimized: z.ZodOptional<z.ZodBoolean>;
+    page: z.ZodOptional<z.ZodNumber>;
+    presets: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    recurrence: z.ZodOptional<z.ZodEnum<{
+        daily: "daily";
+        weekly: "weekly";
+        monthly: "monthly";
+    }>>;
+    searchProfiles: z.ZodOptional<z.ZodBoolean>;
+    searchTags: z.ZodOptional<z.ZodBoolean>;
+    sort: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type SearchRequest = z.input<typeof SearchRequestSchema>;
+type SearchError = RateLimitError | RequestRejectedError | TransportError | UnexpectedResponseError | UserInputError;
+/**
+ * Runs a public full-text search.
+ *
+ * @throws {@link SearchError}
+ * Thrown on failure.
+ *
+ * @example
+ * ```ts
+ * const result = await search(client, {
+ *   q: 'trump',
+ *   limitPerType: 3,
+ * });
+ *
+ * // result === PublicSearchResponse
+ * ```
+ */
+declare function search(client: BaseClient, request: SearchRequest): Promise<PublicSearchResponse>;
+
+declare const ListSeriesRequestSchema: z.ZodObject<{
+    ascending: z.ZodOptional<z.ZodBoolean>;
+    categoriesIds: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+    categoriesLabels: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    closed: z.ZodOptional<z.ZodBoolean>;
+    cursor: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<_polymarket_bindings.PaginationCursor, string>>>;
+    excludeEvents: z.ZodOptional<z.ZodBoolean>;
+    includeChat: z.ZodOptional<z.ZodBoolean>;
+    locale: z.ZodOptional<z.ZodString>;
+    order: z.ZodOptional<z.ZodString>;
+    pageSize: z.ZodDefault<z.ZodNumber>;
+    recurrence: z.ZodOptional<z.ZodEnum<{
+        daily: "daily";
+        weekly: "weekly";
+        monthly: "monthly";
+    }>>;
+    slug: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+declare const FetchSeriesRequestSchema: z.ZodObject<{
+    id: z.ZodString;
+    includeChat: z.ZodOptional<z.ZodBoolean>;
+    locale: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type ListSeriesRequest = z.input<typeof ListSeriesRequestSchema>;
+type FetchSeriesRequest = z.input<typeof FetchSeriesRequestSchema>;
+type ListSeriesError = RateLimitError | RequestRejectedError | TransportError | UnexpectedResponseError | UserInputError;
+/**
+ * Lists series.
+ *
+ * @throws {@link ListSeriesError}
+ * Thrown on failure.
+ *
+ * @example
+ * Fetch the first page of results:
+ * ```ts
+ * const result = listSeries(client, {
+ *   closed: false,
+ *   pageSize: 10,
+ * });
+ *
+ * const firstPage = await result.firstPage();
+ *
+ * // Optionally, fetch additional pages:
+ * for await (const page of result.from(firstPage.nextCursor)) {
+ *   // page.items: Series[]
+ * }
+ * ```
+ *
+ * @example
+ * Loop through all pages with `for await`:
+ * ```ts
+ * const result = listSeries(client, {
+ *   closed: false,
+ *   pageSize: 10,
+ * });
+ *
+ * for await (const page of result) {
+ *   // page.items: Series[]
+ * }
+ * ```
+ */
+declare function listSeries(client: BaseClient, request?: ListSeriesRequest): Paginated<Series>;
+type FetchSeriesError = RateLimitError | RequestRejectedError | TransportError | UnexpectedResponseError | UserInputError;
+/**
+ * Fetches a series.
+ *
+ * @throws {@link FetchSeriesError}
+ * Thrown on failure.
+ *
+ * @example
+ * ```ts
+ * const series = await fetchSeries(client, {
+ *   id: 'fed-daily-series',
+ *   includeChat: true,
+ * });
+ *
+ * // series === Series
+ * ```
+ */
+declare function fetchSeries(client: BaseClient, request: FetchSeriesRequest): Promise<Series>;
+
+declare const ListTagsRequestSchema: z.ZodObject<{
+    ascending: z.ZodOptional<z.ZodBoolean>;
+    cursor: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<_polymarket_bindings.PaginationCursor, string>>>;
+    includeChat: z.ZodOptional<z.ZodBoolean>;
+    includeTemplate: z.ZodOptional<z.ZodBoolean>;
+    isCarousel: z.ZodOptional<z.ZodBoolean>;
+    locale: z.ZodOptional<z.ZodString>;
+    order: z.ZodOptional<z.ZodString>;
+    pageSize: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+declare const FetchTagRequestSchema: z.ZodUnion<readonly [z.ZodObject<{
+    id: z.ZodString;
+    includeChat: z.ZodOptional<z.ZodBoolean>;
+    includeTemplate: z.ZodOptional<z.ZodBoolean>;
+    locale: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    slug: z.ZodString;
+    locale: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>]>;
+declare const RelatedTagsByIdRequestSchema: z.ZodObject<{
+    id: z.ZodString;
+    omitEmpty: z.ZodOptional<z.ZodBoolean>;
+    status: z.ZodOptional<z.ZodEnum<{
+        closed: "closed";
+        all: "all";
+        active: "active";
+    }>>;
+}, z.core.$strip>;
+declare const RelatedTagsBySlugRequestSchema: z.ZodObject<{
+    slug: z.ZodString;
+}, z.core.$strip>;
+declare const RelatedTagResourcesByIdRequestSchema: z.ZodObject<{
+    id: z.ZodString;
+    locale: z.ZodOptional<z.ZodString>;
+    omitEmpty: z.ZodOptional<z.ZodBoolean>;
+    status: z.ZodOptional<z.ZodEnum<{
+        closed: "closed";
+        all: "all";
+        active: "active";
+    }>>;
+}, z.core.$strip>;
+declare const RelatedTagResourcesBySlugRequestSchema: z.ZodObject<{
+    locale: z.ZodOptional<z.ZodString>;
+    slug: z.ZodString;
+    omitEmpty: z.ZodOptional<z.ZodBoolean>;
+    status: z.ZodOptional<z.ZodEnum<{
+        closed: "closed";
+        all: "all";
+        active: "active";
+    }>>;
+}, z.core.$strip>;
+type ListTagsRequest = z.input<typeof ListTagsRequestSchema>;
+type FetchTagRequest = z.input<typeof FetchTagRequestSchema>;
+type FetchRelatedTagsRequest = z.input<typeof RelatedTagsByIdRequestSchema> | z.input<typeof RelatedTagsBySlugRequestSchema>;
+type FetchRelatedTagResourcesRequest = z.input<typeof RelatedTagResourcesByIdRequestSchema> | z.input<typeof RelatedTagResourcesBySlugRequestSchema>;
+type ListTagsError = RateLimitError | RequestRejectedError | TransportError | UnexpectedResponseError | UserInputError;
+/**
+ * Lists tags.
+ *
+ * @throws {@link ListTagsError}
+ * Thrown on failure.
+ *
+ * @example
+ * Fetch the first page of results:
+ * ```ts
+ * const result = listTags(client, {
+ *   includeTemplate: true,
+ *   pageSize: 12,
+ * });
+ *
+ * const firstPage = await result.firstPage();
+ *
+ * // Optionally, fetch additional pages:
+ * for await (const page of result.from(firstPage.nextCursor)) {
+ *   // page.items: Tag[]
+ * }
+ * ```
+ *
+ * @example
+ * Loop through all pages with `for await`:
+ * ```ts
+ * const result = listTags(client, {
+ *   includeTemplate: true,
+ *   pageSize: 12,
+ * });
+ *
+ * for await (const page of result) {
+ *   // page.items: Tag[]
+ * }
+ * ```
+ */
+declare function listTags(client: BaseClient, request?: ListTagsRequest): Paginated<Tag>;
+type FetchTagError = RateLimitError | RequestRejectedError | TransportError | UnexpectedResponseError | UserInputError;
+/**
+ * Fetches a tag by id or slug.
+ *
+ * @throws {@link FetchTagError}
+ * Thrown on failure.
+ *
+ * @example
+ * ```ts
+ * const tag = await fetchTag(client, {
+ *   slug: 'politics',
+ *   locale: 'en',
+ * });
+ *
+ * // tag === Tag
+ * ```
+ */
+declare function fetchTag(client: BaseClient, request: FetchTagRequest): Promise<Tag>;
+type FetchRelatedTagsError = RateLimitError | RequestRejectedError | TransportError | UnexpectedResponseError | UserInputError;
+/**
+ * Fetches related tag relationships by id or slug.
+ *
+ * @throws {@link FetchRelatedTagsError}
+ * Thrown on failure.
+ *
+ * @example
+ * ```ts
+ * const relatedTags = await fetchRelatedTags(client, {
+ *   id: '42',
+ *   status: 'active',
+ *   omitEmpty: true,
+ * });
+ *
+ * // relatedTags: RelatedTag[]
+ * ```
+ */
+declare function fetchRelatedTags(client: BaseClient, request: FetchRelatedTagsRequest): Promise<RelatedTag[]>;
+type FetchRelatedTagResourcesError = RateLimitError | RequestRejectedError | TransportError | UnexpectedResponseError | UserInputError;
+/**
+ * Fetches resources linked from related tag relationships by id or slug.
+ *
+ * @throws {@link FetchRelatedTagResourcesError}
+ * Thrown on failure.
+ *
+ * @example
+ * ```ts
+ * const relatedResources = await fetchRelatedTagResources(client, {
+ *   slug: 'election',
+ *   status: 'active',
+ *   omitEmpty: true,
+ * });
+ *
+ * // relatedResources: Tag[]
+ * ```
+ */
+declare function fetchRelatedTagResources(client: BaseClient, request: FetchRelatedTagResourcesRequest): Promise<Tag[]>;
+
+declare const ListTeamsRequestSchema: z.ZodObject<{
+    abbreviation: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    ascending: z.ZodOptional<z.ZodBoolean>;
+    cursor: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<_polymarket_bindings.PaginationCursor, string>>>;
+    league: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    name: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    order: z.ZodOptional<z.ZodString>;
+    pageSize: z.ZodDefault<z.ZodNumber>;
+    providerId: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+}, z.core.$strip>;
+type ListTeamsRequest = z.input<typeof ListTeamsRequestSchema>;
+type ListTeamsError = RateLimitError | RequestRejectedError | TransportError | UnexpectedResponseError | UserInputError;
+/**
+ * Lists teams.
+ *
+ * @throws {@link ListTeamsError}
+ * Thrown on failure.
+ *
+ * @example
+ * Fetch the first page of results:
+ * ```ts
+ * const result = listTeams(client, {
+ *   league: ['NBA'],
+ *   pageSize: 10,
+ * });
+ *
+ * const firstPage = await result.firstPage();
+ *
+ * // Optionally, fetch additional pages:
+ * for await (const page of result.from(firstPage.nextCursor)) {
+ *   // page.items: Team[]
+ * }
+ * ```
+ *
+ * @example
+ * Loop through all pages with `for await`:
+ * ```ts
+ * const result = listTeams(client, {
+ *   league: ['NBA'],
+ *   pageSize: 10,
+ * });
+ *
+ * for await (const page of result) {
+ *   // page.items: Team[]
+ * }
+ * ```
+ */
+declare function listTeams(client: BaseClient, request?: ListTeamsRequest): Paginated<Team>;
+
+type Erc20TransferWorkflowRequest = GaslessWorkflowRequest | SendErc20TransferTransactionRequest;
+type Erc20TransferWorkflow = AsyncGenerator<Erc20TransferWorkflowRequest, TransactionHandle, EvmAddress$1 | EvmSignature | TransactionHandle>;
+declare const PrepareErc20TransferRequestSchema: z.ZodObject<{
+    amount: z.ZodBigInt;
+    metadata: z.ZodOptional<z.ZodString>;
+    recipientAddress: z.ZodPipe<z.ZodString, z.ZodTransform<EvmAddress$1, string>>;
+    tokenAddress: z.ZodPipe<z.ZodString, z.ZodTransform<EvmAddress$1, string>>;
+}, z.core.$strip>;
+type PrepareErc20TransferRequest = z.input<typeof PrepareErc20TransferRequestSchema>;
+type PrepareErc20TransferError = UserInputError;
+/**
+ * Starts an ERC-20 transfer workflow.
+ *
+ * @example
+ * ```ts
+ * const handle = await prepareErc20Transfer(client, {
+ *   amount: 1n,
+ *   recipientAddress: client.account.signer,
+ *   tokenAddress: client.environment.collateralToken,
+ * }).then(completeWith(wallet));
+ *
+ * const outcome = await handle.wait();
+ *
+ * // outcome.transactionHash: TxHash
+ * ```
+ *
+ * @throws {@link PrepareErc20TransferError}
+ * Thrown on failure.
+ */
+declare function prepareErc20Transfer(client: BaseSecureClient, request: PrepareErc20TransferRequest): Promise<Erc20TransferWorkflow>;
+
+type TypedDataField = {
+    name: string;
+    type: string;
+};
+type TypedData = Record<string, readonly TypedDataField[]>;
+type TypedDataDomain = {
+    chainId?: number;
+    name?: string;
+    salt?: HexString;
+    verifyingContract?: EvmAddress;
+    version?: string;
+};
+type TypedDataPayload = {
+    domain: TypedDataDomain;
+    message: Record<string, unknown>;
+    primaryType: string;
+    types: TypedData;
+};
+type TransactionCall = {
+    data: HexString;
+    to: EvmAddress;
+    value?: bigint;
+};
+interface ApiKeyAuthorization {
+}
+type TransactionOutcome = {
+    /**
+     * The hash of the settled transaction.
+     */
+    transactionHash: TxHash;
+    /**
+     * The unique identifier of the settled transaction when submitted through the Polymarket API,
+     * or null if the transaction was submitted directly to the blockchain.
+     */
+    transactionId: TransactionId | null;
+};
+type WaitForTransactionError = WaitForGaslessTransactionError;
+interface TransactionHandle {
+    /**
+     * The hash of the submitted transaction, or null if the transaction is pending submission.
+     */
+    readonly transactionHash: TxHash | null;
+    /**
+     * The unique identifier of the submitted transaction when submitted through the Polymarket API,
+     * or null if the transaction was submitted directly to the blockchain.
+     */
+    readonly transactionId: TransactionId | null;
+    /**
+     * Waits for the submitted transaction to settle.
+     *
+     * @throws {@link WaitForTransactionError}
+     * Thrown when polling times out, the transaction reaches a terminal failure state, or a later read returns an unexpected response.
+     */
+    wait(): Promise<TransactionOutcome>;
+}
+interface DeployTransactionHandle extends TransactionHandle {
+    /**
+     * The deterministic address of the Safe wallet being deployed by this transaction.
+     */
+    readonly wallet: EvmAddress;
+}
+
+export { type TypedDataField as $, type AuthenticateWith as A, type BaseClient as B, type CompleteWith as C, type DataActions as D, type EnvironmentConfig as E, type FreshAuthenticationRequest as F, RequestRejectedError as G, type RequestRejectedErrorOptions as H, InsufficientLiquidityError as I, type RewardsActions as J, type RewardsPublicActions as K, type SecureClient as L, type SecureWalletActions as M, type SessionSnapshot as N, SigningError as O, type Page as P, TimeoutError as Q, RateLimitError as R, type SecureActions as S, type TypedDataPayload as T, UserInputError as U, type TradingActions as V, TransactionFailedError as W, type TransactionHandle as X, type TransactionOutcome as Y, TransportError as Z, type TypedDataDomain as _, type TypedData as a, type FetchMidpointsRequest as a$, UnexpectedResponseError as a0, type WaitForTransactionError as a1, type WalletDerivationConfig as a2, accountActions as a3, allActions as a4, analyticsActions as a5, createPublicClient as a6, dataActions as a7, discoveryActions as a8, production as a9, type FetchBalanceAllowanceError as aA, type FetchBalanceAllowanceRequest as aB, type FetchClosedOnlyModeError as aC, type FetchCommentsByIdError as aD, type FetchCommentsByIdRequest as aE, type FetchEventError as aF, type FetchEventLiveVolumeError as aG, type FetchEventLiveVolumeRequest as aH, type FetchEventRequest as aI, type FetchEventTagsError as aJ, type FetchEventTagsRequest as aK, type FetchExecuteParamsError as aL, type FetchExecuteParamsRequest as aM, type FetchFeeRateError as aN, type FetchFeeRateRequest as aO, type FetchGaslessTransactionRequest as aP, type FetchLastTradePriceError as aQ, type FetchLastTradePriceRequest as aR, type FetchLastTradePricesError as aS, type FetchLastTradePricesRequest as aT, type FetchMarketError as aU, type FetchMarketRequest as aV, type FetchMarketTagsError as aW, type FetchMarketTagsRequest as aX, type FetchMidpointError as aY, type FetchMidpointRequest as aZ, type FetchMidpointsError as a_, rewardsActions as aa, tradingActions as ab, walletActions as ac, type PrepareLimitOrderRequest as ad, type OrderWorkflow as ae, type OrderPostingWorkflow as af, type PrepareMarketOrderRequest as ag, type CancelAllError as ah, type CancelMarketOrdersError as ai, type CancelMarketOrdersRequest as aj, type CancelOrderError as ak, type CancelOrderRequest as al, type CancelOrdersError as am, type CancelOrdersRequest as an, type DownloadAccountingSnapshotError as ao, type DownloadAccountingSnapshotRequest as ap, type DropNotificationsError as aq, type DropNotificationsRequest as ar, type Erc1155ApprovalForAllWorkflow as as, type Erc1155ApprovalForAllWorkflowRequest as at, type Erc20ApprovalWorkflow as au, type Erc20ApprovalWorkflowRequest as av, type Erc20TransferWorkflow as aw, type Erc20TransferWorkflowRequest as ax, type EstimateMarketPriceError as ay, type EstimateMarketPriceRequest as az, type TransactionCall as b, type ListCommentsError as b$, type FetchNegRiskError as b0, type FetchNegRiskRequest as b1, type FetchNotificationsError as b2, type FetchOrderBookError as b3, type FetchOrderBookRequest as b4, type FetchOrderBooksError as b5, type FetchOrderBooksRequest as b6, type FetchOrderError as b7, type FetchOrderRequest as b8, type FetchOrderScoringError as b9, type FetchTickSizeError as bA, type FetchTickSizeRequest as bB, type FetchTotalEarningsForUserForDayError as bC, type FetchTotalEarningsForUserForDayRequest as bD, type FetchTradedMarketCountError as bE, type FetchTradedMarketCountRequest as bF, GaslessTransactionMetadataSchema as bG, type GaslessWalletWorkflow as bH, type GaslessWalletWorkflowRequest as bI, type GaslessWorkflow as bJ, type GaslessWorkflowRequest as bK, type IsGaslessReadyError as bL, type IsGaslessReadyRequest as bM, type ListAccountTradesError as bN, type ListAccountTradesRequest as bO, type ListActivityError as bP, type ListActivityRequest as bQ, type ListBuilderLeaderboardError as bR, type ListBuilderLeaderboardRequest as bS, type ListBuilderTradesError as bT, type ListBuilderTradesRequest as bU, type ListBuilderVolumeError as bV, type ListBuilderVolumeRequest as bW, type ListClosedPositionsError as bX, type ListClosedPositionsRequest as bY, type ListCommentsByUserAddressError as bZ, type ListCommentsByUserAddressRequest as b_, type FetchOrderScoringRequest as ba, type FetchOrdersScoringError as bb, type FetchOrdersScoringRequest as bc, type FetchPortfolioValueError as bd, type FetchPortfolioValueRequest as be, type FetchPriceError as bf, type FetchPriceHistoryError as bg, type FetchPriceHistoryRequest as bh, type FetchPriceRequest as bi, type FetchPricesError as bj, type FetchPricesRequest as bk, type FetchPublicProfileError as bl, type FetchPublicProfileRequest as bm, type FetchRelatedTagResourcesError as bn, type FetchRelatedTagResourcesRequest as bo, type FetchRelatedTagsError as bp, type FetchRelatedTagsRequest as bq, type FetchRewardPercentagesError as br, type FetchSeriesError as bs, type FetchSeriesRequest as bt, type FetchSpreadError as bu, type FetchSpreadRequest as bv, type FetchSpreadsError as bw, type FetchSpreadsRequest as bx, type FetchTagError as by, type FetchTagRequest as bz, type ApiKeyAuthorization as c, type TradingApprovalsWorkflow as c$, type ListCommentsRequest as c0, type ListCurrentRewardsError as c1, type ListCurrentRewardsRequest as c2, type ListEventsError as c3, type ListEventsRequest as c4, type ListMarketHoldersError as c5, type ListMarketHoldersRequest as c6, type ListMarketPositionsError as c7, type ListMarketPositionsRequest as c8, type ListMarketRewardsError as c9, type OrderWorkflowRequest as cA, type PostOrderError as cB, type PostOrdersError as cC, type PostOrdersRequest as cD, type PrepareErc1155ApprovalForAllError as cE, type PrepareErc1155ApprovalForAllRequest as cF, type PrepareErc20ApprovalError as cG, type PrepareErc20ApprovalRequest as cH, type PrepareErc20TransferError as cI, type PrepareErc20TransferRequest as cJ, type PrepareGaslessTransactionError as cK, type PrepareGaslessTransactionRequest as cL, type PrepareGaslessWalletError as cM, type PrepareMergePositionsError as cN, type PrepareMergePositionsRequest as cO, type PrepareRedeemPositionsError as cP, type PrepareRedeemPositionsRequest as cQ, type PrepareSplitPositionError as cR, type PrepareSplitPositionRequest as cS, type PrepareTradingApprovalsError as cT, type RedeemPositionsWorkflow as cU, type RedeemPositionsWorkflowRequest as cV, type SearchError as cW, type SearchRequest as cX, type SignedOrder as cY, type SplitPositionWorkflow as cZ, type SplitPositionWorkflowRequest as c_, type ListMarketRewardsRequest as ca, type ListMarketsError as cb, type ListMarketsRequest as cc, type ListOpenInterestError as cd, type ListOpenInterestRequest as ce, type ListOpenOrdersError as cf, type ListOpenOrdersRequest as cg, type ListPositionsError as ch, type ListPositionsRequest as ci, type ListSeriesError as cj, type ListSeriesRequest as ck, type ListTagsError as cl, type ListTagsRequest as cm, type ListTeamsError as cn, type ListTeamsRequest as co, type ListTraderLeaderboardError as cp, type ListTraderLeaderboardRequest as cq, type ListTradesError as cr, type ListTradesRequest as cs, type ListUserEarningsAndMarketsConfigError as ct, type ListUserEarningsAndMarketsConfigRequest as cu, type ListUserEarningsForDayError as cv, type ListUserEarningsForDayRequest as cw, type MergePositionsWorkflow as cx, type MergePositionsWorkflowRequest as cy, type OrderDraft as cz, type AccountActions as d, listMarkets as d$, type TradingApprovalsWorkflowRequest as d0, type UpdateBalanceAllowanceError as d1, type UpdateBalanceAllowanceRequest as d2, type WaitForGaslessTransactionError as d3, cancelAll as d4, cancelMarketOrders as d5, cancelOrder as d6, cancelOrders as d7, downloadAccountingSnapshot as d8, dropNotifications as d9, fetchPriceHistory as dA, fetchPrices as dB, fetchPublicProfile as dC, fetchRelatedTagResources as dD, fetchRelatedTags as dE, fetchRewardPercentages as dF, fetchSeries as dG, fetchSpread as dH, fetchSpreads as dI, fetchTag as dJ, fetchTickSize as dK, fetchTotalEarningsForUserForDay as dL, fetchTradedMarketCount as dM, fetchTransaction as dN, isGaslessReady as dO, listAccountTrades as dP, listActivity as dQ, listBuilderLeaderboard as dR, listBuilderTrades as dS, listClosedPositions as dT, listComments as dU, listCommentsByUserAddress as dV, listCurrentRewards as dW, listEvents as dX, listMarketHolders as dY, listMarketPositions as dZ, listMarketRewards as d_, estimateMarketPrice as da, fetchBalanceAllowance as db, fetchBuilderVolume as dc, fetchClosedOnlyMode as dd, fetchCommentsById as de, fetchEvent as df, fetchEventLiveVolume as dg, fetchEventTags as dh, fetchExecuteParams as di, fetchFeeRate as dj, fetchLastTradePrice as dk, fetchLastTradePrices as dl, fetchMarket as dm, fetchMarketTags as dn, fetchMidpoint as dp, fetchMidpoints as dq, fetchNegRisk as dr, fetchNotifications as ds, fetchOrder as dt, fetchOrderBook as du, fetchOrderBooks as dv, fetchOrderScoring as dw, fetchOrdersScoring as dx, fetchPortfolioValue as dy, fetchPrice as dz, type AccountIdentity as e, listOpenInterest as e0, listOpenOrders as e1, listPositions as e2, listSeries as e3, listTags as e4, listTeams as e5, listTraderLeaderboard as e6, listTrades as e7, listUserEarningsAndMarketsConfig as e8, listUserEarningsForDay as e9, postOrder as ea, postOrders as eb, prepareErc1155ApprovalForAll as ec, prepareErc20Approval as ed, prepareErc20Transfer as ee, prepareGaslessTransaction as ef, prepareGaslessWallet as eg, prepareMergePositions as eh, prepareRedeemPositions as ei, prepareSplitPosition as ej, prepareTradingApprovals as ek, search as el, updateBalanceAllowance as em, type AccountPublicActions as f, type AnalyticsActions as g, type AuthenticateWithError as h, type AuthenticationWorkflow as i, type AuthenticationWorkflowRequest as j, BasePublicClient as k, BaseSecureClient as l, type BeginAuthenticationRequest as m, CancelledSigningError as n, type Client as o, type ClientActions as p, type ClientDecorator as q, type CompleteWithError as r, type DeployTransactionHandle as s, type DiscoveryActions as t, PageSizeSchema as u, type Paginated as v, type PublicActions as w, type PublicClient as x, type PublicClientOptions as y, type PublicWalletActions as z };