@apicity/polymarket 0.1.0-alpha.0

package/dist/src/types.d.ts

@@ -0,0 +1,728 @@
+import type { z } from "zod";
+import type { PolymarketClobTokenBatchRequest, PolymarketClobPricesBatchRequest, PolymarketClobBatchPricesHistoryRequest } from "./zod";
+export type { PolymarketOptions, PolymarketClobTokenBatchRequest, PolymarketClobPricesBatchRequest, PolymarketClobBatchPricesHistoryRequest, } from "./zod";
+export type PolymarketClobSide = "BUY" | "SELL";
+export type PolymarketServerTime = number;
+export interface PolymarketClobBookLevel {
+    price: string;
+    size: string;
+}
+export interface PolymarketClobBook {
+    market: string;
+    asset_id: string;
+    timestamp: string;
+    hash: string;
+    bids: PolymarketClobBookLevel[];
+    asks: PolymarketClobBookLevel[];
+}
+export interface PolymarketClobPriceResponse {
+    price: string;
+}
+export interface PolymarketClobMidpointResponse {
+    mid: string;
+}
+export interface PolymarketClobSpreadResponse {
+    spread: string;
+}
+export interface PolymarketClobLastTradePriceResponse {
+    price: string;
+    side: PolymarketClobSide;
+}
+export interface PolymarketClobTickSizeResponse {
+    minimum_tick_size: number;
+}
+export interface PolymarketClobFeeRateResponse {
+    base_fee: number;
+}
+export interface PolymarketClobPriceHistoryPoint {
+    t: number;
+    p: number;
+}
+export interface PolymarketClobPriceHistoryResponse {
+    history: PolymarketClobPriceHistoryPoint[];
+}
+export interface PolymarketClobMarketToken {
+    token_id: string;
+    outcome: string;
+    price: number;
+    winner: boolean;
+}
+export interface PolymarketClobMarketRewardRate {
+    asset_address: string;
+    rewards_daily_rate: number;
+}
+export interface PolymarketClobMarketRewards {
+    rates: PolymarketClobMarketRewardRate[] | null;
+    min_size: number;
+    max_spread: number;
+}
+export interface PolymarketClobMarket {
+    enable_order_book: boolean;
+    active: boolean;
+    closed: boolean;
+    archived: boolean;
+    accepting_orders: boolean;
+    accepting_order_timestamp: string | null;
+    minimum_order_size: number;
+    minimum_tick_size: number;
+    condition_id: string;
+    question_id: string;
+    question: string;
+    description: string;
+    market_slug: string;
+    end_date_iso: string | null;
+    game_start_time: string | null;
+    seconds_delay: number;
+    fpmm: string;
+    maker_base_fee: number;
+    taker_base_fee: number;
+    notifications_enabled: boolean;
+    neg_risk: boolean;
+    neg_risk_market_id: string;
+    neg_risk_request_id: string;
+    icon: string;
+    image: string;
+    rewards: PolymarketClobMarketRewards;
+    is_50_50_outcome: boolean;
+    tokens: PolymarketClobMarketToken[];
+    tags: string[];
+}
+export interface PolymarketClobSimplifiedMarket {
+    condition_id: string;
+    rewards: PolymarketClobMarketRewards;
+    tokens: PolymarketClobMarketToken[];
+    active: boolean;
+    closed: boolean;
+    archived: boolean;
+    accepting_orders: boolean;
+}
+export interface PolymarketClobPaginationQuery {
+    next_cursor?: string;
+}
+export interface PolymarketClobPaginatedResponse<T> {
+    data: T[];
+    next_cursor: string;
+    limit: number;
+    count: number;
+}
+export type PolymarketClobMarketListResponse = PolymarketClobPaginatedResponse<PolymarketClobMarket>;
+export type PolymarketClobSimplifiedMarketListResponse = PolymarketClobPaginatedResponse<PolymarketClobSimplifiedMarket>;
+export interface PolymarketClobMarketsByTokenResponse {
+    condition_id: string;
+    primary_token_id: string;
+    secondary_token_id: string;
+}
+export interface PolymarketClobMarketCompactToken {
+    t: string;
+    o: string;
+}
+export interface PolymarketClobMarketCompactRewards {
+    mi: number;
+    ma: number;
+    e: boolean;
+    moas: number;
+}
+export interface PolymarketClobMarketCompactFundingDetails {
+    r: number;
+    e: number;
+    to: boolean;
+}
+export interface PolymarketClobMarketCompact {
+    c: string;
+    t: PolymarketClobMarketCompactToken[];
+    r: PolymarketClobMarketCompactRewards;
+    mos: number;
+    mts: number;
+    mbf: number;
+    tbf: number;
+    ao: boolean;
+    cbos: boolean;
+    aot: string;
+    ibce: boolean;
+    fd: PolymarketClobMarketCompactFundingDetails;
+}
+export type PolymarketClobBooksBatchResponse = PolymarketClobBook[];
+export type PolymarketClobPricesBatchResponse = Record<string, Partial<Record<PolymarketClobSide, string>>>;
+export type PolymarketClobMidpointsBatchResponse = Record<string, string>;
+export type PolymarketClobSpreadsBatchResponse = Record<string, string>;
+export interface PolymarketClobLastTradesPricesEntry {
+    price: string;
+    side: PolymarketClobSide;
+    token_id: string;
+}
+export type PolymarketClobLastTradesPricesBatchResponse = PolymarketClobLastTradesPricesEntry[];
+export interface PolymarketClobBatchPricesHistoryResponse {
+    history: Record<string, PolymarketClobPriceHistoryPoint[]>;
+}
+export interface PolymarketClobTokenQuery {
+    token_id: string;
+}
+export interface PolymarketClobPriceQuery extends PolymarketClobTokenQuery {
+    side: PolymarketClobSide;
+}
+export type PolymarketClobPriceHistoryInterval = "1m" | "1h" | "6h" | "1d" | "1w" | "max";
+export interface PolymarketClobPriceHistoryQuery {
+    market: string;
+    interval?: PolymarketClobPriceHistoryInterval;
+    startTs?: number;
+    endTs?: number;
+    fidelity?: number;
+}
+export declare class PolymarketError extends Error {
+    readonly status: number;
+    readonly body: unknown;
+    constructor(message: string, status: number, body?: unknown);
+}
+export interface PolymarketClobTimeMethod {
+    (signal?: AbortSignal): Promise<PolymarketServerTime>;
+}
+export interface PolymarketClobBookMethod {
+    (params: PolymarketClobTokenQuery, signal?: AbortSignal): Promise<PolymarketClobBook>;
+}
+export interface PolymarketClobPriceMethod {
+    (params: PolymarketClobPriceQuery, signal?: AbortSignal): Promise<PolymarketClobPriceResponse>;
+}
+export interface PolymarketClobMidpointMethod {
+    (params: PolymarketClobTokenQuery, signal?: AbortSignal): Promise<PolymarketClobMidpointResponse>;
+}
+export interface PolymarketClobSpreadMethod {
+    (params: PolymarketClobTokenQuery, signal?: AbortSignal): Promise<PolymarketClobSpreadResponse>;
+}
+export interface PolymarketClobLastTradePriceMethod {
+    (params: PolymarketClobTokenQuery, signal?: AbortSignal): Promise<PolymarketClobLastTradePriceResponse>;
+}
+export interface PolymarketClobTickSizeMethod {
+    (tokenId: string, signal?: AbortSignal): Promise<PolymarketClobTickSizeResponse>;
+}
+export interface PolymarketClobFeeRateMethod {
+    (tokenId: string, signal?: AbortSignal): Promise<PolymarketClobFeeRateResponse>;
+}
+export interface PolymarketClobPricesHistoryMethod {
+    (params: PolymarketClobPriceHistoryQuery, signal?: AbortSignal): Promise<PolymarketClobPriceHistoryResponse>;
+}
+export interface PolymarketClobMarketsMethod {
+    (signal?: AbortSignal): Promise<PolymarketClobMarketListResponse>;
+    (params: PolymarketClobPaginationQuery, signal?: AbortSignal): Promise<PolymarketClobMarketListResponse>;
+    (conditionId: string, signal?: AbortSignal): Promise<PolymarketClobMarket>;
+}
+export interface PolymarketClobSamplingMarketsMethod {
+    (params?: PolymarketClobPaginationQuery, signal?: AbortSignal): Promise<PolymarketClobMarketListResponse>;
+}
+export interface PolymarketClobSimplifiedMarketsMethod {
+    (params?: PolymarketClobPaginationQuery, signal?: AbortSignal): Promise<PolymarketClobSimplifiedMarketListResponse>;
+}
+export interface PolymarketClobSamplingSimplifiedMarketsMethod {
+    (params?: PolymarketClobPaginationQuery, signal?: AbortSignal): Promise<PolymarketClobSimplifiedMarketListResponse>;
+}
+export interface PolymarketClobMarketsByTokenMethod {
+    (tokenId: string, signal?: AbortSignal): Promise<PolymarketClobMarketsByTokenResponse>;
+}
+export interface PolymarketClobMarketsCompactMethod {
+    (conditionId: string, signal?: AbortSignal): Promise<PolymarketClobMarketCompact>;
+}
+export interface PolymarketClobGetNamespace {
+    time: PolymarketClobTimeMethod;
+    book: PolymarketClobBookMethod;
+    price: PolymarketClobPriceMethod;
+    midpoint: PolymarketClobMidpointMethod;
+    spread: PolymarketClobSpreadMethod;
+    lastTradePrice: PolymarketClobLastTradePriceMethod;
+    tickSize: PolymarketClobTickSizeMethod;
+    feeRate: PolymarketClobFeeRateMethod;
+    pricesHistory: PolymarketClobPricesHistoryMethod;
+    markets: PolymarketClobMarketsMethod;
+    samplingMarkets: PolymarketClobSamplingMarketsMethod;
+    simplifiedMarkets: PolymarketClobSimplifiedMarketsMethod;
+    samplingSimplifiedMarkets: PolymarketClobSamplingSimplifiedMarketsMethod;
+    marketsByToken: PolymarketClobMarketsByTokenMethod;
+    clobMarkets: PolymarketClobMarketsCompactMethod;
+}
+export interface PolymarketClobBooksBatchMethod {
+    (req: PolymarketClobTokenBatchRequest, signal?: AbortSignal): Promise<PolymarketClobBooksBatchResponse>;
+    schema: z.ZodType<PolymarketClobTokenBatchRequest>;
+}
+export interface PolymarketClobPricesBatchMethod {
+    (req: PolymarketClobPricesBatchRequest, signal?: AbortSignal): Promise<PolymarketClobPricesBatchResponse>;
+    schema: z.ZodType<PolymarketClobPricesBatchRequest>;
+}
+export interface PolymarketClobMidpointsBatchMethod {
+    (req: PolymarketClobTokenBatchRequest, signal?: AbortSignal): Promise<PolymarketClobMidpointsBatchResponse>;
+    schema: z.ZodType<PolymarketClobTokenBatchRequest>;
+}
+export interface PolymarketClobSpreadsBatchMethod {
+    (req: PolymarketClobTokenBatchRequest, signal?: AbortSignal): Promise<PolymarketClobSpreadsBatchResponse>;
+    schema: z.ZodType<PolymarketClobTokenBatchRequest>;
+}
+export interface PolymarketClobLastTradesPricesBatchMethod {
+    (req: PolymarketClobTokenBatchRequest, signal?: AbortSignal): Promise<PolymarketClobLastTradesPricesBatchResponse>;
+    schema: z.ZodType<PolymarketClobTokenBatchRequest>;
+}
+export interface PolymarketClobBatchPricesHistoryMethod {
+    (req: PolymarketClobBatchPricesHistoryRequest, signal?: AbortSignal): Promise<PolymarketClobBatchPricesHistoryResponse>;
+    schema: z.ZodType<PolymarketClobBatchPricesHistoryRequest>;
+}
+export interface PolymarketClobPostNamespace {
+    books: PolymarketClobBooksBatchMethod;
+    prices: PolymarketClobPricesBatchMethod;
+    midpoints: PolymarketClobMidpointsBatchMethod;
+    spreads: PolymarketClobSpreadsBatchMethod;
+    lastTradesPrices: PolymarketClobLastTradesPricesBatchMethod;
+    batchPricesHistory: PolymarketClobBatchPricesHistoryMethod;
+}
+export interface PolymarketPostNamespace {
+    clob: PolymarketClobPostNamespace;
+}
+export interface PolymarketGammaMarket {
+    id: string;
+    conditionId?: string;
+    questionID?: string;
+    question: string;
+    description: string;
+    slug: string;
+    endDate?: string;
+    startDate?: string;
+    outcomes?: string;
+    outcomePrices?: string;
+    volume?: string;
+    liquidity?: string;
+    active?: boolean;
+    closed?: boolean;
+    archived?: boolean;
+    acceptingOrders?: boolean;
+    enableOrderBook?: boolean;
+    negRisk?: boolean;
+    clobTokenIds?: string;
+    [key: string]: unknown;
+}
+export interface PolymarketGammaEvent {
+    id: string;
+    ticker?: string;
+    slug: string;
+    title: string;
+    description: string;
+    startDate?: string;
+    creationDate?: string;
+    endDate?: string;
+    image?: string;
+    icon?: string;
+    active?: boolean;
+    closed?: boolean;
+    archived?: boolean;
+    new?: boolean;
+    featured?: boolean;
+    restricted?: boolean;
+    liquidity?: number;
+    volume?: number;
+    openInterest?: number;
+    competitive?: number;
+    volume24hr?: number;
+    volume1wk?: number;
+    volume1mo?: number;
+    volume1yr?: number;
+    enableOrderBook?: boolean;
+    liquidityClob?: number;
+    negRisk?: boolean;
+    commentCount?: number;
+    markets: PolymarketGammaMarket[];
+    tags?: PolymarketGammaTag[];
+    [key: string]: unknown;
+}
+export interface PolymarketGammaTag {
+    id: string;
+    label: string;
+    slug: string;
+    forceShow?: boolean;
+    publishedAt?: string;
+    createdAt?: string;
+    updatedAt?: string;
+    isCarousel?: boolean;
+    requiresTranslation?: boolean;
+    [key: string]: unknown;
+}
+export interface PolymarketGammaSeries {
+    id: string;
+    ticker?: string;
+    slug: string;
+    title: string;
+    seriesType?: string;
+    recurrence?: string;
+    description?: string;
+    image?: string;
+    icon?: string;
+    layout?: string;
+    active?: boolean;
+    closed?: boolean;
+    archived?: boolean;
+    new?: boolean;
+    featured?: boolean;
+    restricted?: boolean;
+    commentsEnabled?: boolean;
+    publishedAt?: string;
+    createdBy?: string;
+    updatedBy?: string;
+    createdAt?: string;
+    updatedAt?: string;
+    events?: PolymarketGammaEvent[];
+    [key: string]: unknown;
+}
+export interface PolymarketGammaRelatedTag {
+    id: string;
+    tagID: number;
+    relatedTagID: number;
+    rank: number;
+}
+export interface PolymarketGammaCommentProfile {
+    name?: string;
+    pseudonym?: string;
+    displayUsernamePublic?: boolean;
+    bio?: string;
+    proxyWallet?: string;
+    baseAddress?: string;
+    profileImage?: string;
+    [key: string]: unknown;
+}
+export interface PolymarketGammaComment {
+    id: string;
+    body: string;
+    parentEntityType: "Event" | "Market" | string;
+    parentEntityID: number;
+    userAddress: string;
+    createdAt: string;
+    updatedAt?: string;
+    profile?: PolymarketGammaCommentProfile;
+    [key: string]: unknown;
+}
+export interface PolymarketGammaCommentListQuery {
+    parent_entity_type: "Event" | "Market";
+    parent_entity_id: number | string;
+    limit?: number;
+    offset?: number;
+    order?: string;
+    ascending?: boolean;
+}
+export interface PolymarketGammaCommentByUserQuery {
+    limit?: number;
+    offset?: number;
+}
+export interface PolymarketGammaSearchProfile {
+    proxyWallet?: string;
+    name?: string;
+    pseudonym?: string;
+    bio?: string;
+    profileImage?: string;
+    baseAddress?: string;
+    [key: string]: unknown;
+}
+export interface PolymarketGammaSearchPagination {
+    hasMore: boolean;
+    totalResults: number;
+    [key: string]: unknown;
+}
+export interface PolymarketGammaSearchResponse {
+    events: PolymarketGammaEvent[];
+    markets?: PolymarketGammaMarket[];
+    profiles?: PolymarketGammaSearchProfile[];
+    pagination: PolymarketGammaSearchPagination;
+}
+export interface PolymarketGammaSearchQuery {
+    q: string;
+    limit_per_type?: number;
+    events_status?: string;
+}
+export interface PolymarketGammaSport {
+    id: number;
+    sport: string;
+    image?: string;
+    resolution?: string;
+    ordering?: string;
+    tags?: string;
+    [key: string]: unknown;
+}
+export interface PolymarketGammaSportsMarketTypesResponse {
+    marketTypes: string[];
+}
+export type PolymarketGammaEventListResponse = PolymarketGammaEvent[];
+export interface PolymarketGammaEventKeysetResponse {
+    events: PolymarketGammaEvent[];
+    next_cursor: string;
+}
+export interface PolymarketGammaEventListQuery {
+    limit?: number;
+    offset?: number;
+    order?: string;
+    ascending?: boolean;
+    id?: number | number[];
+    slug?: string | string[];
+    archived?: boolean;
+    active?: boolean;
+    closed?: boolean;
+    liquidity_min?: number;
+    liquidity_max?: number;
+    volume_min?: number;
+    volume_max?: number;
+    start_date_min?: string;
+    start_date_max?: string;
+    end_date_min?: string;
+    end_date_max?: string;
+    tag?: string;
+    tag_id?: number;
+    related_tags?: boolean;
+    tag_slug?: string;
+    featured?: boolean;
+    restricted?: boolean;
+    cyom?: boolean;
+    recurrence?: string;
+}
+export interface PolymarketGammaKeysetQuery extends PolymarketGammaEventListQuery {
+    next_cursor?: string;
+}
+export interface PolymarketGammaMarketListQuery extends PolymarketGammaEventListQuery {
+    clob_token_ids?: string | string[];
+}
+export interface PolymarketGammaMarketKeysetQuery extends PolymarketGammaMarketListQuery {
+    next_cursor?: string;
+}
+export type PolymarketGammaMarketListResponse = PolymarketGammaMarket[];
+export interface PolymarketGammaMarketKeysetResponse {
+    markets: PolymarketGammaMarket[];
+    next_cursor: string;
+}
+export interface PolymarketGammaEventsMethod {
+    (signal?: AbortSignal): Promise<PolymarketGammaEventListResponse>;
+    (params: PolymarketGammaEventListQuery, signal?: AbortSignal): Promise<PolymarketGammaEventListResponse>;
+    (id: string, signal?: AbortSignal): Promise<PolymarketGammaEvent>;
+    keyset(params?: PolymarketGammaKeysetQuery, signal?: AbortSignal): Promise<PolymarketGammaEventKeysetResponse>;
+    slug(slug: string, signal?: AbortSignal): Promise<PolymarketGammaEvent>;
+    tags(id: string, signal?: AbortSignal): Promise<PolymarketGammaTag[]>;
+}
+export interface PolymarketGammaMarketsMethod {
+    (signal?: AbortSignal): Promise<PolymarketGammaMarketListResponse>;
+    (params: PolymarketGammaMarketListQuery, signal?: AbortSignal): Promise<PolymarketGammaMarketListResponse>;
+    (id: string, signal?: AbortSignal): Promise<PolymarketGammaMarket>;
+    keyset(params?: PolymarketGammaMarketKeysetQuery, signal?: AbortSignal): Promise<PolymarketGammaMarketKeysetResponse>;
+    slug(slug: string, signal?: AbortSignal): Promise<PolymarketGammaMarket>;
+    tags(id: string, signal?: AbortSignal): Promise<PolymarketGammaTag[]>;
+}
+export interface PolymarketGammaSeriesMethod {
+    (signal?: AbortSignal): Promise<PolymarketGammaSeries[]>;
+    (params: PolymarketGammaEventListQuery, signal?: AbortSignal): Promise<PolymarketGammaSeries[]>;
+    (id: string, signal?: AbortSignal): Promise<PolymarketGammaSeries>;
+}
+export interface PolymarketGammaTagsMethod {
+    (signal?: AbortSignal): Promise<PolymarketGammaTag[]>;
+    (params: PolymarketGammaEventListQuery, signal?: AbortSignal): Promise<PolymarketGammaTag[]>;
+    (id: string, signal?: AbortSignal): Promise<PolymarketGammaTag>;
+    slug(slug: string, signal?: AbortSignal): Promise<PolymarketGammaTag>;
+    relatedTags: PolymarketGammaTagsRelatedMethod;
+}
+export interface PolymarketGammaTagsRelatedMethod {
+    (id: string, signal?: AbortSignal): Promise<PolymarketGammaRelatedTag[]>;
+    slug(slug: string, signal?: AbortSignal): Promise<PolymarketGammaRelatedTag[]>;
+}
+export interface PolymarketGammaCommentsByUserMethod {
+    (address: string, params?: PolymarketGammaCommentByUserQuery, signal?: AbortSignal): Promise<PolymarketGammaComment[]>;
+}
+export interface PolymarketGammaCommentsMethod {
+    (params: PolymarketGammaCommentListQuery, signal?: AbortSignal): Promise<PolymarketGammaComment[]>;
+    (id: string, signal?: AbortSignal): Promise<PolymarketGammaComment[]>;
+    byUser: PolymarketGammaCommentsByUserMethod;
+}
+export interface PolymarketGammaSearchMethod {
+    (params: PolymarketGammaSearchQuery, signal?: AbortSignal): Promise<PolymarketGammaSearchResponse>;
+}
+export interface PolymarketGammaSportsMarketTypesMethod {
+    (signal?: AbortSignal): Promise<PolymarketGammaSportsMarketTypesResponse>;
+}
+export interface PolymarketGammaSportsMethod {
+    (signal?: AbortSignal): Promise<PolymarketGammaSport[]>;
+    marketTypes: PolymarketGammaSportsMarketTypesMethod;
+}
+export interface PolymarketGammaGetNamespace {
+    events: PolymarketGammaEventsMethod;
+    markets: PolymarketGammaMarketsMethod;
+    series: PolymarketGammaSeriesMethod;
+    tags: PolymarketGammaTagsMethod;
+    comments: PolymarketGammaCommentsMethod;
+    search: PolymarketGammaSearchMethod;
+    sports: PolymarketGammaSportsMethod;
+}
+export interface PolymarketDataPosition {
+    proxyWallet: string;
+    asset: string;
+    conditionId: string;
+    size: number;
+    avgPrice: number;
+    initialValue: number;
+    currentValue: number;
+    cashPnl: number;
+    percentPnl: number;
+    totalBought: number;
+    realizedPnl: number;
+    percentRealizedPnl: number;
+    curPrice: number;
+    redeemable: boolean;
+    mergeable?: boolean;
+    title?: string;
+    slug?: string;
+    icon?: string;
+    eventId?: string;
+    eventSlug?: string;
+    outcome?: string;
+    outcomeIndex?: number;
+    endDate?: string;
+    [key: string]: unknown;
+}
+export interface PolymarketDataPositionsQuery {
+    user: string;
+    market?: string | string[];
+    eventId?: string;
+    sizeThreshold?: number;
+    redeemable?: boolean;
+    mergeable?: boolean;
+    title?: string;
+    sortBy?: string;
+    sortDirection?: "ASC" | "DESC";
+    limit?: number;
+    offset?: number;
+}
+export interface PolymarketDataValueEntry {
+    user: string;
+    value: number;
+}
+export type PolymarketDataValueResponse = PolymarketDataValueEntry[];
+export interface PolymarketDataValueQuery {
+    user: string;
+}
+export interface PolymarketDataPositionsMethod {
+    (params: PolymarketDataPositionsQuery, signal?: AbortSignal): Promise<PolymarketDataPosition[]>;
+}
+export interface PolymarketDataValueMethod {
+    (params: PolymarketDataValueQuery, signal?: AbortSignal): Promise<PolymarketDataValueResponse>;
+}
+export interface PolymarketDataHolderEntry {
+    proxyWallet: string;
+    asset: string;
+    amount: number;
+    outcomeIndex?: number;
+    bio?: string;
+    pseudonym?: string;
+    name?: string;
+    displayUsernamePublic?: boolean;
+    profileImage?: string;
+    profileImageOptimized?: string;
+    verified?: boolean;
+    [key: string]: unknown;
+}
+export interface PolymarketDataHoldersGroup {
+    token: string;
+    holders: PolymarketDataHolderEntry[];
+}
+export interface PolymarketDataHoldersQuery {
+    market: string | string[];
+    limit?: number;
+}
+export type PolymarketDataActivityType = "TRADE" | "REDEEM" | "MERGE" | "SPLIT" | "REWARD" | string;
+export interface PolymarketDataActivityEntry {
+    proxyWallet: string;
+    timestamp: number;
+    conditionId: string;
+    type: PolymarketDataActivityType;
+    size: number;
+    usdcSize?: number;
+    transactionHash: string;
+    asset?: string;
+    price?: number;
+    side?: "BUY" | "SELL";
+    outcomeIndex?: number;
+    title?: string;
+    slug?: string;
+    [key: string]: unknown;
+}
+export interface PolymarketDataActivityQuery {
+    user: string;
+    limit?: number;
+    offset?: number;
+    market?: string | string[];
+    type?: PolymarketDataActivityType | PolymarketDataActivityType[];
+    start?: number;
+    end?: number;
+    side?: "BUY" | "SELL";
+    sortBy?: string;
+    sortDirection?: "ASC" | "DESC";
+}
+export interface PolymarketDataTradeEntry {
+    proxyWallet: string;
+    side: "BUY" | "SELL";
+    asset: string;
+    conditionId: string;
+    size: number;
+    price: number;
+    timestamp: number;
+    title?: string;
+    slug?: string;
+    icon?: string;
+    eventSlug?: string;
+    [key: string]: unknown;
+}
+export interface PolymarketDataTradesQuery {
+    user?: string;
+    market?: string | string[];
+    limit?: number;
+    offset?: number;
+    takerOnly?: boolean;
+    filterType?: string;
+}
+export interface PolymarketDataOpenInterestEntry {
+    market: string;
+    value: number;
+}
+export type PolymarketDataOpenInterestResponse = PolymarketDataOpenInterestEntry[];
+export interface PolymarketDataOpenInterestQuery {
+    market?: string | string[];
+}
+export interface PolymarketDataLiveVolumeMarket {
+    market: string;
+    value: number;
+}
+export interface PolymarketDataLiveVolumeEntry {
+    total: number;
+    markets: PolymarketDataLiveVolumeMarket[];
+}
+export type PolymarketDataLiveVolumeResponse = PolymarketDataLiveVolumeEntry[];
+export interface PolymarketDataLiveVolumeQuery {
+    id: string | number;
+}
+export interface PolymarketDataHoldersMethod {
+    (params: PolymarketDataHoldersQuery, signal?: AbortSignal): Promise<PolymarketDataHoldersGroup[]>;
+}
+export interface PolymarketDataActivityMethod {
+    (params: PolymarketDataActivityQuery, signal?: AbortSignal): Promise<PolymarketDataActivityEntry[]>;
+}
+export interface PolymarketDataTradesMethod {
+    (params: PolymarketDataTradesQuery, signal?: AbortSignal): Promise<PolymarketDataTradeEntry[]>;
+}
+export interface PolymarketDataOpenInterestMethod {
+    (params?: PolymarketDataOpenInterestQuery, signal?: AbortSignal): Promise<PolymarketDataOpenInterestResponse>;
+}
+export interface PolymarketDataLiveVolumeMethod {
+    (params: PolymarketDataLiveVolumeQuery, signal?: AbortSignal): Promise<PolymarketDataLiveVolumeResponse>;
+}
+export interface PolymarketDataGetNamespace {
+    positions: PolymarketDataPositionsMethod;
+    value: PolymarketDataValueMethod;
+    holders: PolymarketDataHoldersMethod;
+    activity: PolymarketDataActivityMethod;
+    trades: PolymarketDataTradesMethod;
+    oi: PolymarketDataOpenInterestMethod;
+    liveVolume: PolymarketDataLiveVolumeMethod;
+}
+export interface PolymarketGetNamespace {
+    clob: PolymarketClobGetNamespace;
+    gamma: PolymarketGammaGetNamespace;
+    data: PolymarketDataGetNamespace;
+}
+export interface PolymarketProvider {
+    get: PolymarketGetNamespace;
+    post: PolymarketPostNamespace;
+}
+//# sourceMappingURL=types.d.ts.map