@taphubhq/sdk-core 0.13.0

package/dist/index.d.mts

@@ -0,0 +1,780 @@
+import EventEmitter from 'eventemitter3';
+
+interface TaphubStorageAdapter {
+    get(key: string): string | null;
+    set(key: string, value: string): void;
+    remove(key: string): void;
+}
+declare function autoDetectStorage(): TaphubStorageAdapter;
+declare const TaphubStorage: {
+    memory(): TaphubStorageAdapter;
+    localStorage(): TaphubStorageAdapter;
+    sessionStorage(): TaphubStorageAdapter;
+};
+
+interface TaphubClientConfig {
+    agencyId: string;
+    endpoint: string;
+    mqttEndpoint?: string;
+    storage?: TaphubStorageAdapter;
+    fetch?: typeof globalThis.fetch;
+}
+
+type SignalSource = 'graphql' | 'rest' | 'mqtt' | 'browser' | 'connection';
+type SampleReason = 'ok' | 'network' | 'timeout' | 'offline' | 'backend5xx' | 'backend4xx' | 'gqlError';
+type Sample = {
+    ts: number;
+    rtt: number;
+    source: SignalSource;
+    reason: SampleReason;
+};
+type NetworkLevel = 'good' | 'fair' | 'poor' | 'offline';
+type BackendHealth = 'ok' | 'degraded' | 'down';
+type NetworkQuality = {
+    network: NetworkLevel;
+    backend: BackendHealth;
+    rtt: number;
+    jitter: number;
+    lossRate: number;
+    mqttConnected: boolean;
+    samplesInWindow: number;
+    lastUpdated: number;
+};
+
+type TaphubEventMap = {
+    'auth-expired': void;
+    'network:change': {
+        previous: NetworkQuality;
+        current: NetworkQuality;
+    };
+};
+type EventHandler<T> = (payload: T) => void;
+declare class TaphubEventBus<EventMap extends Record<string, unknown> = TaphubEventMap> {
+    private target;
+    on<K extends keyof EventMap & string>(event: K, handler: EventHandler<EventMap[K]>): void;
+    off<K extends keyof EventMap & string>(event: K, handler: EventHandler<EventMap[K]>): void;
+    emit<K extends keyof EventMap & string>(event: K, payload?: EventMap[K]): void;
+}
+
+interface GraphQLRequestOpts {
+    signal?: AbortSignal;
+}
+interface GraphQLTransport {
+    request<T>(query: string, variables?: Record<string, unknown>, opts?: GraphQLRequestOpts): Promise<T>;
+}
+
+interface RestRequestOpts {
+    signal?: AbortSignal;
+}
+interface RestTransport {
+    get<T>(path: string, opts?: RestRequestOpts): Promise<T>;
+    post<T>(path: string, body?: unknown, opts?: RestRequestOpts): Promise<T>;
+}
+
+interface Wallet$1 {
+    id: string | null;
+    balance: string;
+    currency: string;
+    isEnabled: boolean;
+}
+interface User {
+    id: string;
+    displayName: string;
+    agencyUid: string | null;
+    currency: string;
+    wallet: Wallet$1;
+}
+interface LoginResult {
+    accessToken: string;
+    user: User;
+    isDemo: boolean;
+}
+
+interface AuthModuleDeps {
+    rest: RestTransport;
+    graphql: GraphQLTransport;
+    graphqlUser: GraphQLTransport;
+    setToken: (token: string | null, opts?: {
+        isDemo?: boolean;
+    }) => void;
+    agencyId: string;
+    onLoginSuccess?: () => Promise<void>;
+    onLogout?: () => void | Promise<void>;
+}
+declare class AuthModule {
+    #private;
+    constructor(deps: AuthModuleDeps);
+    /** @deprecated REST auth endpoints are being retired; use `loginWithSession` instead. */
+    loginWithGoogle(idToken: string): Promise<LoginResult>;
+    /** @deprecated REST auth endpoints are being retired; use `loginWithSession` or `createDemoUser` instead. */
+    demoLogin(username?: string): Promise<LoginResult>;
+    createDemoUser(username?: string, opts?: {
+        signal?: AbortSignal;
+    }): Promise<LoginResult>;
+    loginWithSession(sessionToken: string, opts?: {
+        signal?: AbortSignal;
+    }): Promise<LoginResult>;
+    logout(): Promise<void>;
+}
+
+type BidStatus = 'pending' | 'win' | 'lose' | 'cancelled';
+interface Bid {
+    id: string;
+    userId: string;
+    gameId: string;
+    currency: string;
+    amount: string;
+    coefficient: string;
+    time1: number;
+    time2: number;
+    price1: string;
+    price2: string;
+    status: BidStatus;
+    payout: string | null;
+    slippage: number;
+    /** ISO-8601 string passthrough from the server. */
+    createdAt: string | null;
+}
+interface CancelBidResult {
+    bid: Bid;
+    refundAmount: string;
+    newBalance: string;
+}
+interface PlaceBidInput {
+    gameId: string;
+    /**
+     * UUID of the user's wallet to debit. Required (non-optional) since
+     * grid-api's `PlaceBidInput.wallet_id` is NON_NULL (`ID!`). The SDK stays
+     * builder-agnostic — it doesn't know where the caller sourced this id
+     * (user-service, builder BFF, etc.); it just forwards to grid-api.
+     *
+     * See openspec/changes/bid-260518-wallet-id (design D1, D8).
+     */
+    walletId: string;
+    time1: number;
+    time2: number;
+    price1: string;
+    price2: string;
+    coefficient: string;
+    amount: string;
+    slippage: number;
+}
+
+declare const isPending: (bid: Bid) => boolean;
+declare const isTerminal: (bid: Bid) => boolean;
+declare const isWin: (bid: Bid) => boolean;
+declare const isLoss: (bid: Bid) => boolean;
+declare const isCancelled: (bid: Bid) => boolean;
+
+interface BidModuleDeps {
+    graphql: GraphQLTransport;
+}
+declare class BidModule {
+    #private;
+    constructor(deps: BidModuleDeps);
+    placeBid(input: PlaceBidInput, opts?: {
+        signal?: AbortSignal;
+    }): Promise<Bid>;
+    cancelBid(bidId: string, opts?: {
+        signal?: AbortSignal;
+    }): Promise<CancelBidResult>;
+    listBids(opts?: {
+        status?: BidStatus;
+        limit?: number;
+        offset?: number;
+        gameId?: string;
+        signal?: AbortSignal;
+    }): Promise<Bid[]>;
+}
+
+interface Game {
+    id: string;
+    pair: string;
+    status: string;
+    config: GameConfig;
+    /** ISO-8601 string passthrough from the server. */
+    createdAt: string | null;
+}
+interface GameConfig {
+    gridConfig: GridConfig;
+    constraints: Constraints;
+    acceptableBids: number[];
+    minBidAmount: number;
+    maxBidAmount: number;
+}
+interface GridConfig {
+    cellSizeTime: number;
+    cellSizeValue: number;
+    candleSize: number;
+    baseline: number;
+    baselineTime: number;
+}
+interface Constraints {
+    minBetTime: number;
+    maxBetTime: number;
+    slippage: number;
+    priceMinRange: number;
+    priceMaxRange: number;
+    coefMults: number[];
+    maxCoef: number;
+}
+interface GamePairInfo {
+    /** game_pairs.id — catalog identifier for this pair within a gameplay. */
+    id: string;
+    /** Trading pair symbol, e.g. "BTC/USD". */
+    pair: string;
+    /** ID of the gameplay this pair belongs to. Use as `gameplaySlug` in game.get(). */
+    gameplayId: string;
+    /** Human-readable gameplay name. */
+    gameplayName: string;
+    /** Price feed source, e.g. "binance". */
+    source: string;
+    /**
+     * agency_game_pairs.id — the runtime game ID for this agency.
+     * Present only when the caller is authenticated with a valid JWT.
+     * Use directly as `gameId` in MQTT topic `game/{gameId}/candle`.
+     * Null when called without authentication.
+     */
+    gameId: string | null;
+}
+interface Candle {
+    /** Unix epoch SECONDS (not ms). Multiply by 1000 for JS Date. */
+    time: number;
+    o: number;
+    h: number;
+    l: number;
+    c: number;
+    volatility: number;
+    coefMults: number[];
+}
+
+interface GameModuleDeps {
+    graphql: GraphQLTransport;
+}
+declare class GameModule {
+    #private;
+    constructor(deps: GameModuleDeps);
+    get(pair: string, opts?: {
+        gameplaySlug?: string;
+        signal?: AbortSignal;
+    }): Promise<Game>;
+    /**
+     * Returns available game pairs, optionally filtered by gameplay.
+     *
+     * When called with a valid JWT (authenticated builder), each entry includes
+     * `gameId` — use it directly as the MQTT topic `game/{gameId}/candle`.
+     *
+     * @example
+     * const pairs = await client.game.availableGamePairs({ gameplayId: 'taptrading' });
+     * const game  = await client.game.get(pairs[0].pair, { gameplaySlug: pairs[0].gameplayId });
+     * const ch    = client.realtime?.subscribe(pairs[0].gameId ?? game.id, userId);
+     */
+    availableGamePairs(opts?: {
+        gameplayId?: string;
+        signal?: AbortSignal;
+    }): Promise<GamePairInfo[]>;
+    chartHistory(gameId: string, limit?: number, opts?: {
+        signal?: AbortSignal;
+    }): Promise<Candle[]>;
+}
+
+type LeaderboardPeriod = '24h' | '7d' | '30d' | 'all';
+type LeaderboardSortBy = 'gain' | 'wins' | 'total_payout' | 'total_wagered' | 'total_bids';
+interface LeaderboardEntry {
+    userId: string;
+    username: string;
+    rank: number;
+    totalBids: number;
+    totalWins: number;
+    totalWagered: string;
+    totalPayout: string;
+    gain: string;
+}
+
+interface LeaderboardModuleDeps {
+    graphql: GraphQLTransport;
+}
+declare class LeaderboardModule {
+    #private;
+    constructor(deps: LeaderboardModuleDeps);
+    list(args: {
+        period: LeaderboardPeriod;
+        sortBy: LeaderboardSortBy;
+        signal?: AbortSignal;
+    }): Promise<LeaderboardEntry[]>;
+}
+
+/**
+ * Public-facing types for the Locale module.
+ *
+ * Backend contract: a server-side translations store (typically backed by a
+ * spreadsheet or CMS) served via GraphQL `Query.locales` with `version`-based
+ * not-modified semantics — the canonical hash of the canonical translation
+ * body is returned to the client, which echoes it back on the next request to
+ * short-circuit unchanged content.
+ */
+/** Flat translation map for a single language: key → value. */
+type LocaleTranslations = Record<string, string>;
+/**
+ * Public response shape from LocaleModule.get().
+ *
+ * - `translations` is null when `notModified` is true (caller keeps prior state).
+ * - `version` is a bare hex string (sha256 of canonical body). Pass back as
+ *   `knownVersion` on next poll to short-circuit unchanged content.
+ */
+interface LocaleResponse {
+    lang: string;
+    version: string;
+    notModified: boolean;
+    translations: LocaleTranslations | null;
+}
+/**
+ * Public response shape from LocaleModule.refresh().
+ *
+ * - `refreshed` is the sorted list of language codes the backend repopulated.
+ * - `versions` maps each refreshed language to its new bare-hex version.
+ */
+interface LocaleRefreshResult {
+    refreshed: string[];
+    versions: Record<string, string>;
+}
+
+interface LocaleModuleDeps {
+    graphql: GraphQLTransport;
+}
+/**
+ * LocaleModule wraps the backend `Query.locales` + `Mutation.refreshLocales`
+ * GraphQL operations. Framework-agnostic — sdk-react (or any other consumer)
+ * decides what to render when calls succeed or fail.
+ *
+ * Caller passes the last-seen `version` as `knownVersion` to opt into
+ * not-modified short-circuit semantics; backend returns `notModified: true`
+ * with `translations: null` when the cached body still matches.
+ */
+declare class LocaleModule {
+    #private;
+    constructor(deps: LocaleModuleDeps);
+    /**
+     * Fetch translations for a single language.
+     *
+     * Pass the last-seen `version` as `knownVersion` to opt into not-modified
+     * short-circuit semantics: backend returns `{notModified: true, translations: null}`
+     * when the cached body still matches, and the caller keeps prior state.
+     *
+     * Errors surface as TaphubError subclasses with `extensions.code` codes from
+     * the backend (e.g. `LangNotSupported`, `InsufficientUpstream`, `FeatureDisabled`).
+     * Caller decides the fallback strategy.
+     */
+    get(lang: string, knownVersion?: string, opts?: {
+        signal?: AbortSignal;
+    }): Promise<LocaleResponse>;
+    /**
+     * Trigger an admin refresh — backend re-pulls the source Sheet, invalidates
+     * its cache, and writes fresh entries for every supported language.
+     *
+     * Requires `X-API-Key` header equal to backend `InternalApiKey`. The transport
+     * layer is responsible for attaching the header; this method does not handle
+     * auth concerns directly.
+     */
+    refresh(opts?: {
+        signal?: AbortSignal;
+    }): Promise<LocaleRefreshResult>;
+}
+
+interface MqttWireCandle {
+    type: 'new' | 'update';
+    time: number;
+    o: number;
+    h: number;
+    l: number;
+    c: number;
+    volatility?: number;
+    coef_mults?: number[];
+}
+interface MqttWireAcceptedBid {
+    id: string;
+    userId: string;
+    gameUuid: string;
+    currency: string;
+    amount: string;
+    coefficient: number;
+    coordinates: {
+        time1: number;
+        time2: number;
+        price1: number;
+        price2: number;
+    };
+    createdAt: number;
+}
+interface MqttWireBidAccepted {
+    type: 'accepted';
+    bid: MqttWireAcceptedBid;
+    balance?: string;
+}
+interface MqttWireBidWon {
+    type: 'won';
+    bidId: string;
+    payout: string;
+    user_id: string;
+    balance?: string;
+}
+interface MqttWireBidLost {
+    type: 'lost';
+    bidId: string;
+}
+type MqttWireBidResult = MqttWireBidAccepted | MqttWireBidWon | MqttWireBidLost;
+interface MqttWireBalanceUpdate {
+    type: 'balance_update';
+    userId: string;
+    balance: string;
+}
+interface MqttWireConfig {
+    min_bid_amount: number;
+    max_bid_amount: number;
+    acceptable_bids: number[];
+}
+type MqttWirePayload = MqttWireCandle | MqttWireBidResult | MqttWireBalanceUpdate | MqttWireConfig;
+type MqttMessageHandler = (gameId: string, topic: string, payload: MqttWirePayload) => void;
+type MqttErrorHandler = (err: Error) => void;
+type MqttLifecycleEvent = {
+    kind: 'connect';
+    rttMs: number;
+} | {
+    kind: 'reconnect';
+    rttMs: number;
+} | {
+    kind: 'disconnect';
+} | {
+    kind: 'error';
+    err: unknown;
+} | {
+    kind: 'ping';
+    rttMs: number;
+};
+type MqttLifecycleHook = (event: MqttLifecycleEvent) => void;
+interface MqttTransport {
+    /**
+     * Subscribe to a game's MQTT topics keyed by the tuple `(gameId, userId)`.
+     * When `userId` is nullish (including the empty string `''`), only
+     * game-scoped topics are subscribed and the entry is stored under the
+     * anonymous slot for that gameId. Two calls with the same `(gameId, userId)`
+     * tuple are idempotent; calls with the same `gameId` but a different
+     * `userId` create an independent entry with its own user-scoped topics.
+     */
+    subscribe(gameId: string, userId: string | null | undefined, onMessage: MqttMessageHandler, onError: MqttErrorHandler): void;
+    /**
+     * Tear down one subscription entry for `gameId`. If `userId` is provided,
+     * removes the matching `(gameId, userId)` entry. If omitted and exactly
+     * one entry exists for `gameId`, removes that entry. If omitted and
+     * multiple entries exist for `gameId`, throws `TaphubError` with
+     * `code='AmbiguousUnsubscribe'`.
+     */
+    unsubscribeAll(gameId: string, userId?: string | null): void;
+    close(): void;
+}
+
+/**
+ * Candle tick from MQTT.
+ * WARNING: `time` is Unix epoch MILLISECONDS.
+ * This differs from GQL chartHistory candles where `time` is seconds.
+ * Do NOT multiply MQTT candle time by 1000.
+ */
+interface MqttCandleEvent {
+    type: 'new' | 'update';
+    /** Unix epoch **milliseconds** — differs from GQL chartHistory (seconds) */
+    time: number;
+    o: number;
+    h: number;
+    l: number;
+    c: number;
+    volatility?: number;
+    coefMults?: number[];
+}
+/**
+ * Bid object emitted on `bidAccepted` events. Shape mirrors the grid-api
+ * MQTT wire shape verbatim — NOT the same as the `Bid` returned by `myBids`
+ * GraphQL. `coordinates` is nested; `coefficient` / `price1` / `price2` are
+ * numeric floats; `createdAt` is unix epoch milliseconds.
+ */
+interface MqttAcceptedBid {
+    id: string;
+    userId: string;
+    gameUuid: string;
+    currency: string;
+    amount: string;
+    coefficient: number;
+    coordinates: {
+        time1: number;
+        time2: number;
+        price1: number;
+        price2: number;
+    };
+    /** Unix epoch milliseconds */
+    createdAt: number;
+}
+interface MqttBidAcceptedEvent {
+    bid: MqttAcceptedBid;
+    balance?: string;
+}
+interface MqttBidWonEvent {
+    bidId: string;
+    payout: string;
+    userId: string;
+    balance?: string;
+}
+interface MqttBidLostEvent {
+    bidId: string;
+}
+interface MqttBidCancelledEvent {
+    bidId: string;
+}
+interface MqttBalanceEvent {
+    userId: string;
+    balance: string;
+}
+interface MqttConfigEvent {
+    minBidAmount: number;
+    maxBidAmount: number;
+    acceptableBids: number[];
+}
+interface MqttIdealConfigEvent {
+    cellSizeValue: number;
+    currentPrice: number;
+    reason: string;
+}
+
+interface GameChannelEvents {
+    candle: [MqttCandleEvent];
+    bidAccepted: [MqttBidAcceptedEvent];
+    bidWon: [MqttBidWonEvent];
+    bidLost: [MqttBidLostEvent];
+    bidCancelled: [MqttBidCancelledEvent];
+    balanceUpdate: [MqttBalanceEvent];
+    configUpdate: [MqttConfigEvent];
+    idealConfigUpdate: [MqttIdealConfigEvent];
+    error: [Error];
+}
+declare class GameChannel extends EventEmitter<GameChannelEvents> {
+    readonly gameId: string;
+    constructor(gameId: string);
+}
+
+interface RealtimeModuleOptions {
+    mqttEndpoint: string;
+    /** @internal For testing only */
+    transport?: MqttTransport;
+    /**
+     * Optional MQTT lifecycle hook. When provided, fires on connect /
+     * reconnect / disconnect / error so the network-quality monitor (or
+     * any other observer) can track stability.
+     */
+    onMqttLifecycle?: MqttLifecycleHook;
+}
+interface RealtimeModuleEvents {
+    error: [Error];
+}
+declare class RealtimeModule extends EventEmitter<RealtimeModuleEvents> {
+    #private;
+    constructor(mqttEndpointOrOptions: string | RealtimeModuleOptions);
+    /** @internal Access transport for testing */
+    get _transport(): MqttTransport;
+    subscribe(gameId: string, userId?: string | null): GameChannel;
+    unsubscribe(gameId: string, userId?: string | null): void;
+    disconnect(): void;
+}
+
+interface Me {
+    id: string;
+    username: string;
+    walletAddress: string | null;
+    balance: string;
+    isDemo: boolean;
+}
+interface Currency {
+    code: string;
+    unit: string;
+    unitSymbol: string;
+}
+interface Wallet {
+    id: string;
+    amount: string;
+    currency: string;
+    isEnable: boolean;
+}
+
+interface UserModuleDeps {
+    rest: RestTransport;
+    graphql: GraphQLTransport;
+    graphqlUser: GraphQLTransport;
+}
+interface RequestOpts {
+    signal?: AbortSignal;
+}
+declare class UserModule {
+    #private;
+    constructor(deps: UserModuleDeps);
+    me(): Promise<Me>;
+    wallets(opts?: RequestOpts): Promise<Wallet[]>;
+    walletByCurrency(currency: string, opts?: RequestOpts): Promise<Wallet>;
+    get currencies(): Currency[] | null;
+    refreshCurrencies(): Promise<Currency[]>;
+    clearCurrencies(): void;
+}
+
+type NetworkChangeEvent = {
+    previous: NetworkQuality;
+    current: NetworkQuality;
+};
+type EventMapWithNetwork = Record<string, unknown> & {
+    'network:change': NetworkChangeEvent;
+};
+type NetworkQualityListener = (event: NetworkChangeEvent) => void;
+type ConnectionSeed = {
+    rtt?: number;
+    effectiveType?: 'slow-2g' | '2g' | '3g' | '4g' | string;
+};
+declare class NetworkQualityMonitor {
+    private readonly bus;
+    private readonly buckets;
+    private readonly smoother;
+    private mqttConnected;
+    private mqttDisconnectedAt;
+    private lastSuccessfulHttpAt;
+    private committedNetwork;
+    private committedBackend;
+    private tickHandle;
+    private onlineListener;
+    private offlineListener;
+    private disposed;
+    constructor(opts: {
+        bus: TaphubEventBus<EventMapWithNetwork>;
+    });
+    addSample(sample: Sample, prevMqttConnectedOverride?: boolean): void;
+    seedFromConnection(seed: ConnectionSeed): void;
+    notifyMqttConnect(rttMs: number): void;
+    notifyMqttDisconnect(): void;
+    notifyMqttPing(rttMs: number): void;
+    subscribe(listener: NetworkQualityListener): () => void;
+    getCurrent(): NetworkQuality;
+    reset(): void;
+    tick(): void;
+    dispose(): void;
+    private resolveSeedRtt;
+    private startTick;
+    private attachBrowserListeners;
+    private detachBrowserListeners;
+    private pruneWindow;
+    private recompute;
+    private deriveMetrics;
+    private deriveMetricsFrom;
+    private isHardOffline;
+    private allHttpAndMqttSamples;
+    private snapshot;
+    private now;
+}
+
+declare class TaphubClient {
+    #private;
+    readonly agencyId: string;
+    readonly endpoint: string;
+    readonly storage: TaphubStorageAdapter;
+    /** @readonly User module — reassignment has no effect at runtime. */
+    user: UserModule;
+    /** @readonly Auth module — reassignment has no effect at runtime. */
+    auth: AuthModule;
+    /** @readonly Game module — reassignment has no effect at runtime. */
+    game: GameModule;
+    /** @readonly Bid module — reassignment has no effect at runtime. */
+    bid: BidModule;
+    /** @readonly Leaderboard module — reassignment has no effect at runtime. */
+    leaderboard: LeaderboardModule;
+    /** @readonly Locale module — reassignment has no effect at runtime. */
+    locale: LocaleModule;
+    /** @readonly Realtime module — undefined when mqttEndpoint not configured. */
+    realtime: RealtimeModule | undefined;
+    /** @readonly Network quality monitor — always present (operates passively). */
+    network: NetworkQualityMonitor;
+    private bus;
+    constructor(config: TaphubClientConfig);
+    getToken(): string | null;
+    setToken(token: string | null, opts?: {
+        isDemo?: boolean;
+    }): void;
+    isDemo(): boolean;
+    /** @internal Used by module integrations to access the REST transport. Not part of the public API. */
+    get _rest(): RestTransport;
+    /** @internal Used by module integrations to access the GraphQL transport. Not part of the public API. */
+    get _graphql(): GraphQLTransport;
+    on<K extends keyof TaphubEventMap & string>(event: K, handler: (payload: TaphubEventMap[K]) => void): void;
+    off<K extends keyof TaphubEventMap & string>(event: K, handler: (payload: TaphubEventMap[K]) => void): void;
+}
+
+declare class TaphubError extends Error {
+    readonly code: string;
+    readonly details?: unknown;
+    constructor(message: string, options: {
+        code: string;
+        details?: unknown;
+    });
+}
+declare class TaphubAuthError extends TaphubError {
+    constructor(message: string, options: {
+        code: string;
+        details?: unknown;
+    });
+}
+declare class TaphubNetworkError extends TaphubError {
+    constructor(message: string, options: {
+        code: string;
+        details?: unknown;
+    });
+}
+declare class TaphubValidationError extends TaphubError {
+    constructor(message: string, options: {
+        code: string;
+        details?: unknown;
+    });
+}
+declare class TaphubServerError extends TaphubError {
+    constructor(message: string, options: {
+        code: string;
+        details?: unknown;
+    });
+}
+/**
+ * Thrown when grid-api rejects a bid because the requested coefficient
+ * does not match the server-enforced value.
+ *
+ * Recommended catch pattern:
+ * ```ts
+ * try { await client.bid.placeBid(input); }
+ * catch (e) {
+ *   if (e instanceof TaphubSlippageError) {
+ *     showSlippageBanner(e.clientCoef, e.serverCoef);
+ *   } else if (e instanceof TaphubValidationError) {
+ *     showGenericError(e.code);
+ *   }
+ * }
+ * ```
+ */
+declare class TaphubSlippageError extends TaphubValidationError {
+    readonly clientCoef: number;
+    readonly serverCoef: number;
+    readonly slippage: number;
+    constructor(message: string, options: {
+        code: string;
+        clientCoef: number;
+        serverCoef: number;
+        slippage: number;
+        details?: unknown;
+    });
+}
+
+declare function errorFunction(x: number): number;
+declare function normalCDF(x: number): number;
+declare function normalPDF(x: number): number;
+declare function adaptiveSimpson(f: (x: number) => number, a: number, b: number, tolerance?: number, maxDepth?: number): number;
+declare function calculateProbWin(time1: number, time2: number, _price1: number, price2: number, creationTime: number, currentPrice: number, volatility: number): number;
+declare function calculateProbWin_v2(time1: number, time2: number, _price1: number, price2: number, creationTime: number, currentPrice: number, volatility: number): number;
+
+export { AuthModule, type BackendHealth, type Bid, BidModule, type BidStatus, type CancelBidResult, type Candle, type Constraints, type Currency, type Game, GameChannel, type GameConfig, GameModule, type GamePairInfo, type GridConfig, type LeaderboardEntry, LeaderboardModule, type LeaderboardPeriod, type LeaderboardSortBy, LocaleModule, type LocaleRefreshResult, type LocaleResponse, type LocaleTranslations, type LoginResult, type Me, type MqttAcceptedBid, type MqttBalanceEvent, type MqttBidAcceptedEvent, type MqttBidLostEvent, type MqttBidWonEvent, type MqttCandleEvent, type MqttConfigEvent, type MqttIdealConfigEvent, type NetworkLevel, type NetworkQuality, NetworkQualityMonitor, type PlaceBidInput, RealtimeModule, type Sample, type SampleReason, type SignalSource, TaphubAuthError, TaphubClient, type TaphubClientConfig, TaphubError, TaphubEventBus, type TaphubEventMap, TaphubNetworkError, TaphubServerError, TaphubSlippageError, TaphubStorage, type TaphubStorageAdapter, TaphubValidationError, type User, UserModule, type Wallet as UserWallet, type Wallet$1 as Wallet, adaptiveSimpson, autoDetectStorage, calculateProbWin, calculateProbWin_v2, errorFunction, isCancelled, isLoss, isPending, isTerminal, isWin, normalCDF, normalPDF };