@zeroxyz/sdk 0.1.0

package/dist/client-B50UYxPr.d.cts

@@ -0,0 +1,836 @@
+import { LocalAccount, SignableMessage, Hex, TypedDataDefinition } from 'viem';
+import { z } from 'zod';
+
+type OnSessionRefreshed = (next: {
+    accessToken: string;
+    refreshToken: string;
+}) => void | Promise<void>;
+type SessionCredentialsInput = {
+    accessToken: string;
+    refreshToken: string;
+    onRefreshed?: OnSessionRefreshed;
+};
+type SessionCredentials = {
+    kind: "session";
+    accessToken: string;
+    refreshToken: string;
+    onRefreshed: OnSessionRefreshed;
+};
+type AccountCredentials = {
+    kind: "account";
+    account: LocalAccount;
+};
+type NoCredentials = {
+    kind: "none";
+};
+type Credentials = SessionCredentials | AccountCredentials | NoCredentials;
+
+type PaymentProtocol = "x402" | "mpp";
+type PaymentChain = "base" | "base-sepolia" | "tempo" | "tempo-testnet" | "unknown";
+type PaymentSessionMeta = {
+    channelId: `0x${string}`;
+    escrowContract: `0x${string}`;
+    chainId: number;
+    recipient: `0x${string}` | null;
+    cumulativeAmount: string;
+};
+type PaymentResult = {
+    protocol: PaymentProtocol;
+    chain: PaymentChain;
+    txHash: string | null;
+    amount: string;
+    asset: "USDC";
+    session?: PaymentSessionMeta;
+};
+type PayInput = {
+    url: string;
+    method?: string;
+    headers?: Record<string, string>;
+    body?: string | Uint8Array;
+    maxPay?: string;
+    account?: LocalAccount;
+    signal?: AbortSignal;
+    timeoutMs?: number;
+    displayCostAmount?: string;
+};
+type PayResult = {
+    response: Response;
+    payment: PaymentResult;
+    warnings?: string[];
+};
+declare const TEMPO_CHAIN_ID = 4217;
+declare const TEMPO_TESTNET_CHAIN_ID = 42431;
+type SessionReceiptPayload = {
+    channelId: string;
+    challengeId: string;
+    acceptedCumulative: string;
+    spent: string;
+    txHash?: string;
+    metered?: boolean;
+};
+declare const coerceTempoChainId: (raw: unknown) => {
+    id: number;
+    chain: "tempo" | "tempo-testnet";
+} | null;
+declare const tempoChainLabelFromId: (chainId: unknown) => PaymentChain;
+declare const paymentHasAnchor: (payment: PaymentResult | null) => boolean;
+declare const FETCH_WARNINGS: Readonly<{
+    readonly paidButStill402NotRecorded: "paid_but_still_402_not_recorded";
+    readonly paymentSettlementUnconfirmed: "payment_settlement_unconfirmed";
+    readonly paymentAmountUnknown: "payment_amount_unknown";
+    readonly mppSessionCloseFailed: "mpp_session_close_failed";
+    readonly sessionOpenUnobserved: "session_open_unobserved";
+    readonly bodyTruncated: "body_truncated";
+}>;
+declare const FETCH_SKIP_REASONS: Readonly<{
+    readonly bodyReadFailed: "body_read_failed";
+    readonly mppSessionCloseFailedNotRecorded: "mpp_session_close_failed_not_recorded";
+    readonly paidButStill402NotRecorded: "paid_but_still_402_not_recorded";
+    readonly paymentSettlementUnconfirmed: "payment_settlement_unconfirmed";
+}>;
+declare class Payments {
+    private readonly client;
+    private relayInitialized;
+    constructor(client: ZeroClient);
+    /**
+     * Settle an x402 payment for a single request.
+     *
+     * Routes through `@x402/fetch`, which handles the full 402 → sign →
+     * retry round-trip. The settlement transaction hash (when present in
+     * the `payment-response` header AND the facilitator reports success)
+     * is extracted into the returned `payment` metadata.
+     *
+     * Aborts before signing if the server's challenge amount exceeds
+     * `maxPay`. The cap is denominated in USDC (the asset of every Zero
+     * payment today); the API will gain a `maxPayAsset` field if other
+     * assets are added.
+     *
+     * MPP capabilities use `payMpp()` instead — `client.fetch` routes based
+     * on the detected 402 protocol.
+     */
+    pay: (input: PayInput) => Promise<PayResult>;
+    /**
+     * @internal — called by `client.fetch` after MPP protocol detection.
+     *
+     * Runs a single `mppx.fetch` against the Tempo payment-channel protocol.
+     * In-band balance/bridge logic runs from mppx's `onChallenge` callback so
+     * the lifecycle is a single HTTP round-trip from the SDK consumer's view
+     * (no pre-probe — session facilitators that re-run inference per request
+     * can't reconcile the extra state).
+     *
+     * Session-intent capabilities (long-lived channels) close their voucher
+     * after the seller's 200; close failures throw `ZeroSessionCloseFailedError`
+     * carrying the orphaned channel for out-of-band reconciliation.
+     */
+    payMpp: (input: PayInput) => Promise<PayResult>;
+    private buildOrphanError;
+    private prepareTempoFunds;
+    private bridgeBaseToTempo;
+    private ensureRelayClient;
+    private readUsdcBalance;
+    private tempoChainLabel;
+    private completeMppSession;
+}
+
+type FetchOptions = {
+    method?: string;
+    headers?: Record<string, string>;
+    body?: string | Uint8Array;
+    maxPay?: string;
+    capabilityId?: string;
+    searchId?: string;
+    account?: LocalAccount;
+    signal?: AbortSignal;
+    timeoutMs?: number;
+    requestSchema?: Record<string, unknown>;
+    maxResponseBytes?: number;
+    displayCostAmount?: string;
+    deriveRunMetadata?: (response: {
+        status: number;
+        ok: boolean;
+        bodyRaw: string | null;
+        bodyEncoding?: "base64";
+    }) => {
+        responseSchema?: Record<string, unknown>;
+    };
+};
+type FetchOutcome = "success" | "payment_failed" | "payment_rejected" | "payment_close_failed" | "server_error" | "network_error";
+type UpstreamError = {
+    status: number;
+    message?: string;
+    snippetHash: string;
+    snippetLength: number;
+};
+type FetchResult = {
+    runId: string | null;
+    ok: boolean;
+    status: number | null;
+    latencyMs: number;
+    payment: PaymentResult | null;
+    outcome: FetchOutcome;
+    body: unknown;
+    bodyRaw: string | null;
+    bodyEncoding?: "base64";
+    error?: string;
+    upstreamError?: UpstreamError;
+    runTrackingSkipped?: string[];
+    warnings?: string[];
+};
+
+declare const userWalletDtoSchema: z.ZodObject<{
+    walletAddress: z.ZodString;
+    source: z.ZodEnum<{
+        self_custody: "self_custody";
+        privy_embedded: "privy_embedded";
+    }>;
+    isPrimary: z.ZodBoolean;
+    linkedAt: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodDate]>>>;
+    delegationGranted: z.ZodBoolean;
+    signerQuorumId: z.ZodNullable<z.ZodString>;
+    maxTransactionUsdcBaseUnits: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strip>;
+declare const welcomeBonusSummarySchema: z.ZodObject<{
+    status: z.ZodString;
+    amountUsd: z.ZodNumber;
+}, z.core.$strip>;
+declare const internalUserDtoSchema: z.ZodObject<{
+    id: z.ZodString;
+    email: z.ZodNullable<z.ZodString>;
+    createdAt: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodDate]>>;
+    lastLoginAt: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodDate]>>>;
+    onboardingCompleted: z.ZodOptional<z.ZodBoolean>;
+    delegationGranted: z.ZodOptional<z.ZodBoolean>;
+    wallets: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        walletAddress: z.ZodString;
+        source: z.ZodEnum<{
+            self_custody: "self_custody";
+            privy_embedded: "privy_embedded";
+        }>;
+        isPrimary: z.ZodBoolean;
+        linkedAt: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodDate]>>>;
+        delegationGranted: z.ZodBoolean;
+        signerQuorumId: z.ZodNullable<z.ZodString>;
+        maxTransactionUsdcBaseUnits: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    balance: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        amount: z.ZodString;
+        asset: z.ZodString;
+    }, z.core.$strip>>>;
+    welcomeBonus: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        status: z.ZodString;
+        amountUsd: z.ZodNumber;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+declare const publicUserDtoSchema: z.ZodObject<{
+    user: z.ZodObject<{
+        id: z.ZodString;
+        email: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+    walletAddress: z.ZodNullable<z.ZodString>;
+    balance: z.ZodNullable<z.ZodObject<{
+        amount: z.ZodString;
+        asset: z.ZodString;
+    }, z.core.$strip>>;
+    welcomeBonus: z.ZodNullable<z.ZodObject<{
+        status: z.ZodString;
+        amountUsd: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type InternalUserDto = z.infer<typeof internalUserDtoSchema>;
+type PublicUserDto = z.infer<typeof publicUserDtoSchema>;
+type UserWalletDto = z.infer<typeof userWalletDtoSchema>;
+type WelcomeBonusSummary = z.infer<typeof welcomeBonusSummarySchema>;
+
+declare const deviceStartResponseSchema: z.ZodObject<{
+    deviceCode: z.ZodString;
+    userCode: z.ZodString;
+    verificationUri: z.ZodString;
+    pollInterval: z.ZodNumber;
+    expiresAt: z.ZodNumber;
+}, z.core.$strip>;
+type DeviceStartResponse = z.infer<typeof deviceStartResponseSchema>;
+type DevicePollResult = {
+    status: "pending";
+} | {
+    status: "expired";
+} | {
+    status: "ok";
+    accessToken: string;
+    refreshToken: string;
+    expiresIn: number;
+    user: z.infer<typeof internalUserDtoSchema>;
+};
+declare const sessionExchangeResponseSchema: z.ZodObject<{
+    token: z.ZodString;
+    expiresAt: z.ZodNumber;
+}, z.core.$strip>;
+type SessionExchangeResponse = z.infer<typeof sessionExchangeResponseSchema>;
+
+declare class AuthDevice {
+    private readonly client;
+    constructor(client: ZeroClient);
+    start: (opts?: {
+        signal?: AbortSignal;
+    }) => Promise<DeviceStartResponse>;
+    poll: (deviceCode: string, opts?: {
+        signal?: AbortSignal;
+    }) => Promise<DevicePollResult>;
+}
+
+type SignMessageInput = {
+    message: SignableMessage;
+};
+type SignTypedDataInput = TypedDataDefinition;
+type SignTransactionInput = {
+    unsignedTransaction: Hex;
+};
+type SignOptions = {
+    expectedAddress?: string;
+};
+declare class Auth {
+    private readonly client;
+    readonly device: AuthDevice;
+    constructor(client: ZeroClient);
+    me: (opts?: {
+        signal?: AbortSignal;
+    }) => Promise<InternalUserDto>;
+    profile: (opts?: {
+        signal?: AbortSignal;
+    }) => Promise<PublicUserDto>;
+    wallets: (opts?: {
+        signal?: AbortSignal;
+    }) => Promise<UserWalletDto[]>;
+    exchangeSessionCode: (code: string, opts?: {
+        signal?: AbortSignal;
+    }) => Promise<SessionExchangeResponse>;
+    logout: (refreshToken: string, opts?: {
+        signal?: AbortSignal;
+    }) => Promise<void>;
+    refresh: () => Promise<void>;
+    signMessage: (input: SignMessageInput, opts?: SignOptions) => Promise<Hex>;
+    signTransaction: (input: SignTransactionInput, opts?: SignOptions) => Promise<Hex>;
+    signTypedData: (input: SignTypedDataInput, opts?: SignOptions) => Promise<Hex>;
+    private assertSignerMatches;
+}
+
+declare const BUG_REPORT_CATEGORIES: readonly ["search_relevance", "ranking_issue", "missing_capability", "wrong_schema", "misleading_description", "broken_execution", "payment_failure", "billing_anomaly", "cli_bug", "security", "other"];
+type BugReportCategory = (typeof BUG_REPORT_CATEGORIES)[number];
+declare const createBugReportResponseSchema: z.ZodObject<{
+    bugReportId: z.ZodString;
+    status: z.ZodString;
+    deduped: z.ZodBoolean;
+    category: z.ZodNullable<z.ZodEnum<{
+        search_relevance: "search_relevance";
+        ranking_issue: "ranking_issue";
+        missing_capability: "missing_capability";
+        wrong_schema: "wrong_schema";
+        misleading_description: "misleading_description";
+        broken_execution: "broken_execution";
+        payment_failure: "payment_failure";
+        billing_anomaly: "billing_anomaly";
+        cli_bug: "cli_bug";
+        security: "security";
+        other: "other";
+    }>>;
+    title: z.ZodNullable<z.ZodString>;
+    attached: z.ZodObject<{
+        capabilityId: z.ZodNullable<z.ZodNumber>;
+        runId: z.ZodNullable<z.ZodNumber>;
+        searchId: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+type CreateBugReportInput = {
+    description: string;
+    category?: BugReportCategory;
+    title?: string;
+    severity?: number;
+    reproduction?: string;
+    capabilityId?: string;
+    runId?: string;
+    searchId?: string;
+    cliContext?: Record<string, unknown>;
+    idempotencyKey?: string;
+};
+type CreateBugReportResponse = z.infer<typeof createBugReportResponseSchema>;
+
+declare class BugReports {
+    private readonly client;
+    constructor(client: ZeroClient);
+    create: (input: CreateBugReportInput, opts?: {
+        signal?: AbortSignal;
+    }) => Promise<CreateBugReportResponse>;
+}
+
+declare const capabilityResponseSchema: z.ZodObject<{
+    uid: z.ZodString;
+    slug: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodString;
+    url: z.ZodString;
+    urlTemplate: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    method: z.ZodString;
+    headers: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodString>>;
+    bodySchema: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    responseSchema: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    example: z.ZodNullable<z.ZodObject<{
+        request: z.ZodUnknown;
+        response: z.ZodUnknown;
+    }, z.core.$strip>>;
+    tags: z.ZodNullable<z.ZodArray<z.ZodString>>;
+    exampleAgentPrompt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    displayCostAmount: z.ZodString;
+    displayCostAsset: z.ZodString;
+    reviewCount: z.ZodNumber;
+    rating: z.ZodObject<{
+        score: z.ZodString;
+        successRate: z.ZodString;
+        reviews: z.ZodNumber;
+        stars: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        state: z.ZodOptional<z.ZodEnum<{
+            unrated: "unrated";
+            rated: "rated";
+        }>>;
+    }, z.core.$strip>;
+    priceObserved: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        minCents: z.ZodNullable<z.ZodString>;
+        medianCents: z.ZodNullable<z.ZodString>;
+        maxCents: z.ZodNullable<z.ZodString>;
+        p95Cents: z.ZodNullable<z.ZodString>;
+        sampleCount: z.ZodNumber;
+        varies: z.ZodBoolean;
+        failureChargeRate: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    paymentMethods: z.ZodNullable<z.ZodArray<z.ZodObject<{
+        uid: z.ZodString;
+        protocol: z.ZodString;
+        methodType: z.ZodString;
+        chain: z.ZodNullable<z.ZodString>;
+        mode: z.ZodString;
+        costAmount: z.ZodString;
+        costPer: z.ZodString;
+        priority: z.ZodNumber;
+    }, z.core.$strip>>>;
+    availabilityStatus: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        unknown: "unknown";
+        healthy: "healthy";
+        down: "down";
+    }>>>;
+    displayStatus: z.ZodOptional<z.ZodEnum<{
+        unknown: "unknown";
+        healthy: "healthy";
+        stable: "stable";
+        degraded: "degraded";
+        unhealthy: "unhealthy";
+    }>>;
+    activationCount: z.ZodOptional<z.ZodNumber>;
+    lastUsedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    lastSuccessfullyRanAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+type CapabilityResponse = z.infer<typeof capabilityResponseSchema>;
+type GetCapabilityOptions = {
+    searchId?: string;
+    signal?: AbortSignal;
+};
+
+declare class Capabilities {
+    private readonly client;
+    constructor(client: ZeroClient);
+    get: (id: string, opts?: GetCapabilityOptions) => Promise<CapabilityResponse>;
+}
+
+declare const createRunResponseSchema: z.ZodObject<{
+    runId: z.ZodString;
+}, z.core.$strip>;
+declare const runListItemSchema: z.ZodObject<{
+    uid: z.ZodString;
+    capabilityUid: z.ZodString;
+    capabilitySlug: z.ZodString;
+    capabilityName: z.ZodString;
+    status: z.ZodNullable<z.ZodNumber>;
+    latencyMs: z.ZodNullable<z.ZodNumber>;
+    cost: z.ZodNullable<z.ZodObject<{
+        amount: z.ZodString;
+        asset: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    payment: z.ZodNullable<z.ZodObject<{
+        protocol: z.ZodString;
+        chain: z.ZodNullable<z.ZodString>;
+        txHash: z.ZodNullable<z.ZodString>;
+        mode: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    createdAt: z.ZodCoercedDate<unknown>;
+    reviewed: z.ZodBoolean;
+}, z.core.$strip>;
+declare const listRunsResponseSchema: z.ZodObject<{
+    runs: z.ZodArray<z.ZodObject<{
+        uid: z.ZodString;
+        capabilityUid: z.ZodString;
+        capabilitySlug: z.ZodString;
+        capabilityName: z.ZodString;
+        status: z.ZodNullable<z.ZodNumber>;
+        latencyMs: z.ZodNullable<z.ZodNumber>;
+        cost: z.ZodNullable<z.ZodObject<{
+            amount: z.ZodString;
+            asset: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>;
+        payment: z.ZodNullable<z.ZodObject<{
+            protocol: z.ZodString;
+            chain: z.ZodNullable<z.ZodString>;
+            txHash: z.ZodNullable<z.ZodString>;
+            mode: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>;
+        createdAt: z.ZodCoercedDate<unknown>;
+        reviewed: z.ZodBoolean;
+    }, z.core.$strip>>;
+    nextCursor: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+declare const createReviewResponseSchema: z.ZodObject<{
+    reviewId: z.ZodString;
+    recorded: z.ZodBoolean;
+    updated: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+declare const batchReviewResponseSchema: z.ZodObject<{
+    results: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        runId: z.ZodString;
+        ok: z.ZodLiteral<true>;
+        reviewId: z.ZodString;
+        updated: z.ZodBoolean;
+    }, z.core.$strip>, z.ZodObject<{
+        runId: z.ZodString;
+        ok: z.ZodLiteral<false>;
+        status: z.ZodNumber;
+        error: z.ZodString;
+    }, z.core.$strip>]>>;
+    summary: z.ZodObject<{
+        total: z.ZodNumber;
+        ok: z.ZodNumber;
+        failed: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+type RunListItem = z.infer<typeof runListItemSchema>;
+type ListRunsResponse = z.infer<typeof listRunsResponseSchema>;
+type CreateRunResponse = z.infer<typeof createRunResponseSchema>;
+type CreateReviewResponse = z.infer<typeof createReviewResponseSchema>;
+type BatchReviewResponse = z.infer<typeof batchReviewResponseSchema>;
+type CreateRunInput = {
+    capabilityId: string;
+    paymentMethodId?: string;
+    searchId?: string;
+    status?: number;
+    latencyMs?: number;
+    costAmount?: string;
+    costAsset?: string;
+    paymentProtocol?: string;
+    paymentChain?: string;
+    paymentTxHash?: string;
+    paymentMode?: string;
+    errorSnippetHash?: string;
+    errorSnippetLength?: number;
+    requestSchema?: Record<string, unknown>;
+    responseSchema?: Record<string, unknown>;
+};
+type CreateReviewInput = {
+    runId: string;
+    success: boolean;
+    accuracy: number;
+    value: number;
+    reliability: number;
+    content?: string;
+};
+type ListRunsParams = {
+    capabilityId?: string;
+    unreviewed?: boolean;
+    limit?: number;
+    cursor?: string;
+};
+
+declare class Runs {
+    private readonly client;
+    constructor(client: ZeroClient);
+    create: (input: CreateRunInput, opts?: {
+        signal?: AbortSignal;
+    }) => Promise<CreateRunResponse>;
+    list: (params?: ListRunsParams, opts?: {
+        signal?: AbortSignal;
+    }) => Promise<ListRunsResponse>;
+    review: (input: CreateReviewInput, opts?: {
+        signal?: AbortSignal;
+    }) => Promise<CreateReviewResponse>;
+    createReviewsBatch: (reviews: CreateReviewInput[], opts?: {
+        signal?: AbortSignal;
+    }) => Promise<BatchReviewResponse>;
+}
+
+type BalanceChainId = "base" | "tempo";
+
+declare const migrateAuthorizationResponseSchema: z.ZodObject<{
+    transactionHash: z.ZodString;
+}, z.core.$strip>;
+type MigrateAuthorization = {
+    from: string;
+    to: string;
+    value: string;
+    validAfter: string;
+    validBefore: string;
+    nonce: string;
+    signature: string;
+};
+type MigrateAuthorizationResponse = z.infer<typeof migrateAuthorizationResponseSchema>;
+type BalanceReadError = {
+    chain: BalanceChainId;
+    message: string;
+};
+type WalletBalance = {
+    amount: string;
+    asset: "USDC";
+    errors?: BalanceReadError[];
+};
+type BalanceOptions = {
+    chain?: BalanceChainId | "total";
+    address?: `0x${string}`;
+    signal?: AbortSignal;
+};
+type FundingUrlOptions = {
+    amount?: string;
+    provider?: "stripe" | "coinbase";
+    signal?: AbortSignal;
+};
+declare class Wallet {
+    private readonly client;
+    private readonly clients;
+    constructor(client: ZeroClient);
+    get address(): `0x${string}` | null;
+    balance: (opts?: BalanceOptions) => Promise<WalletBalance>;
+    list: (opts?: {
+        signal?: AbortSignal;
+    }) => Promise<UserWalletDto[]>;
+    provision: (opts?: {
+        signal?: AbortSignal;
+    }) => Promise<UserWalletDto>;
+    migrateAuthorization: (authorization: MigrateAuthorization, opts?: {
+        signal?: AbortSignal;
+    }) => Promise<MigrateAuthorizationResponse>;
+    fundingUrl: (opts?: FundingUrlOptions) => Promise<string>;
+    private getPublicClient;
+    /**
+     * @internal
+     *
+     * Per-chain USDC balance read. Exposed (rather than private) so unit
+     * tests can stub it without standing up a real viem public client —
+     * viem's `http()` transport doesn't go through `client.fetchImpl`, so
+     * the standard mock-fetch trick doesn't cover this path.
+     */
+    readChainBalance: (chain: BalanceChainId, address: `0x${string}`) => Promise<bigint>;
+}
+
+type ZeroClientLike = any;
+type LogLevel = "debug" | "info" | "warn" | "error";
+type LogEvent = {
+    level: LogLevel;
+    message: string;
+    meta?: Record<string, unknown>;
+};
+type Logger = (event: LogEvent) => void;
+type RefreshSessionFn = (signal?: AbortSignal) => Promise<{
+    accessToken: string;
+    refreshToken: string;
+} | null>;
+type ClientOptions = {
+    session?: SessionCredentialsInput;
+    account?: LocalAccount;
+    refresh?: RefreshSessionFn;
+    baseUrl?: string;
+    timeout?: number;
+    maxRetries?: number;
+    fetch?: typeof fetch;
+    fetchOptions?: Omit<RequestInit, "method" | "body" | "headers">;
+    defaultHeaders?: Record<string, string>;
+    apiVersion?: string;
+    logger?: Logger;
+    /**
+     * @internal
+     *
+     * Wiring slot used by `withAccount` to share the parent client's
+     * account cache. Never set from public construction.
+     */
+    _sharedAccountCache?: Map<string, ZeroClientLike>;
+};
+declare const DEFAULT_BASE_URL = "https://api.zero.xyz";
+declare const DEFAULT_TIMEOUT_MS = 60000;
+declare const DEFAULT_MAX_RETRIES = 2;
+
+declare const searchResultSchema: z.ZodObject<{
+    id: z.ZodString;
+    position: z.ZodNumber;
+    slug: z.ZodString;
+    name: z.ZodString;
+    canonicalName: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    description: z.ZodString;
+    whatItDoes: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    url: z.ZodString;
+    urlTemplate: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    cost: z.ZodObject<{
+        amount: z.ZodString;
+        asset: z.ZodString;
+    }, z.core.$strip>;
+    reviewCount: z.ZodOptional<z.ZodNumber>;
+    rating: z.ZodObject<{
+        score: z.ZodString;
+        successRate: z.ZodString;
+        reviews: z.ZodNumber;
+        stars: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        state: z.ZodOptional<z.ZodEnum<{
+            unrated: "unrated";
+            rated: "rated";
+        }>>;
+    }, z.core.$strip>;
+    availabilityStatus: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        unknown: "unknown";
+        healthy: "healthy";
+        down: "down";
+    }>>>;
+    displayStatus: z.ZodOptional<z.ZodEnum<{
+        unknown: "unknown";
+        healthy: "healthy";
+        stable: "stable";
+        degraded: "degraded";
+        unhealthy: "unhealthy";
+    }>>;
+}, z.core.$strip>;
+declare const searchResponseSchema: z.ZodObject<{
+    searchId: z.ZodString;
+    total: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    offset: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    hasMore: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    capabilities: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        position: z.ZodNumber;
+        slug: z.ZodString;
+        name: z.ZodString;
+        canonicalName: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        description: z.ZodString;
+        whatItDoes: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        url: z.ZodString;
+        urlTemplate: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        cost: z.ZodObject<{
+            amount: z.ZodString;
+            asset: z.ZodString;
+        }, z.core.$strip>;
+        reviewCount: z.ZodOptional<z.ZodNumber>;
+        rating: z.ZodObject<{
+            score: z.ZodString;
+            successRate: z.ZodString;
+            reviews: z.ZodNumber;
+            stars: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            state: z.ZodOptional<z.ZodEnum<{
+                unrated: "unrated";
+                rated: "rated";
+            }>>;
+        }, z.core.$strip>;
+        availabilityStatus: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+            unknown: "unknown";
+            healthy: "healthy";
+            down: "down";
+        }>>>;
+        displayStatus: z.ZodOptional<z.ZodEnum<{
+            unknown: "unknown";
+            healthy: "healthy";
+            stable: "stable";
+            degraded: "degraded";
+            unhealthy: "unhealthy";
+        }>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type SearchResult = z.infer<typeof searchResultSchema>;
+type SearchResponse = z.infer<typeof searchResponseSchema>;
+type SearchOptions = {
+    offset?: number;
+    limit?: number;
+    maxCost?: string;
+    protocol?: "x402" | "mpp";
+    freeOnly?: boolean;
+    availabilityStatus?: "healthy" | "unknown" | "degraded" | "down";
+    includeAll?: boolean;
+    source?: string;
+    excludeSource?: string;
+    signal?: AbortSignal;
+};
+
+declare class ZeroClient {
+    readonly baseUrl: string;
+    readonly timeout: number;
+    readonly maxRetries: number;
+    readonly apiVersion: string | undefined;
+    readonly defaultHeaders: Record<string, string>;
+    readonly fetchImpl: typeof fetch;
+    readonly fetchOptions: ClientOptions["fetchOptions"];
+    readonly logger: Logger | undefined;
+    private credentials;
+    private refreshInFlight;
+    private managedAccount;
+    private managedAccountInFlight;
+    private managedAccountAC;
+    private managedAccountGen;
+    private withAccountCache;
+    readonly auth: Auth;
+    readonly bugReports: BugReports;
+    readonly capabilities: Capabilities;
+    readonly payments: Payments;
+    readonly runs: Runs;
+    readonly wallet: Wallet;
+    private readonly refreshOverride;
+    constructor(options?: ClientOptions);
+    static fromPrivateKey: (privateKey: Hex, opts?: Omit<ClientOptions, "session" | "account">) => ZeroClient;
+    static fromMnemonic: (mnemonic: string, opts?: Omit<ClientOptions, "session" | "account">) => ZeroClient;
+    /**
+     * @internal
+     *
+     * Live credential accessor for transport + auth modules. Returns the
+     * discriminated union (not a snapshot) so auth-dispatch always sees the
+     * freshest access token after rotation. Exposed publicly only to bridge
+     * the SDK's module boundary — consumers should not call this directly,
+     * and the shape is not part of the stable surface.
+     */
+    getCredentials: () => Credentials;
+    /**
+     * @internal
+     *
+     * Single in-flight refresh helper. Concurrent callers share one
+     * invocation. Used by the transport's 401 path; consumers should call
+     * `client.auth.refresh()` for explicit rotation.
+     *
+     * Only the FIRST caller's signal participates in the in-flight
+     * refresh — combining signals retroactively isn't possible.
+     */
+    refreshSessionOnce: (signal?: AbortSignal) => Promise<boolean>;
+    private runRefreshOverride;
+    applyRefreshedTokens: (next: {
+        accessToken: string;
+        refreshToken: string;
+    }) => Promise<void>;
+    setSessionTokens: (tokens: {
+        accessToken: string;
+        refreshToken: string;
+    }) => void;
+    withSession: (session: SessionCredentialsInput) => ZeroClient;
+    withAccount: (account: LocalAccount) => ZeroClient;
+    /**
+     * Evict cached `withAccount` sub-clients. Pass an account to drop a
+     * single tenant's entry; omit the argument to clear the entire cache.
+     * Call on tenant churn (session expiry, deprovisioning) — without
+     * eviction the cache grows for the base client's lifetime.
+     */
+    clearAccountCache: (account?: LocalAccount) => void;
+    /** @internal — used by payments.pay() in session mode. Cached, dedupes concurrent lookups. */
+    resolveManagedAccount: (signal?: AbortSignal) => Promise<LocalAccount>;
+    private raceWithSignal;
+    /** Drop the cached managed-signing account and abort any in-flight /me lookup. */
+    clearManagedAccount: () => void;
+    /** @internal — Read cached managed account without triggering resolution. */
+    peekManagedAccount: () => LocalAccount | null;
+    search: (query: string, opts?: SearchOptions) => Promise<SearchResponse>;
+    fetch: (url: string, opts?: FetchOptions) => Promise<FetchResult>;
+    close: () => Promise<void>;
+}
+
+export { type BugReportCategory as $, type AccountCredentials as A, BugReports as B, type Credentials as C, Wallet as D, type ClientOptions as E, type FetchOptions as F, DEFAULT_BASE_URL as G, DEFAULT_MAX_RETRIES as H, DEFAULT_TIMEOUT_MS as I, type Logger as J, type LogLevel as K, type LogEvent as L, type MigrateAuthorization as M, type NoCredentials as N, type OnSessionRefreshed as O, type PaymentSessionMeta as P, type InternalUserDto as Q, Runs as R, type SessionCredentials as S, TEMPO_CHAIN_ID as T, type UpstreamError as U, type PublicUserDto as V, type WalletBalance as W, type UserWalletDto as X, type WelcomeBonusSummary as Y, ZeroClient as Z, BUG_REPORT_CATEGORIES as _, type SessionCredentialsInput as a, type CreateBugReportInput as a0, type CreateBugReportResponse as a1, type CapabilityResponse as a2, type GetCapabilityOptions as a3, type DevicePollResult as a4, type DeviceStartResponse as a5, type SessionExchangeResponse as a6, type BatchReviewResponse as a7, type CreateReviewInput as a8, type CreateReviewResponse as a9, type CreateRunInput as aa, type CreateRunResponse as ab, type ListRunsParams as ac, type ListRunsResponse as ad, type RunListItem as ae, type SearchOptions as af, type SearchResponse as ag, type SearchResult as ah, type FetchOutcome as b, type FetchResult as c, type SignMessageInput as d, type SignTransactionInput as e, type SignTypedDataInput as f, Auth as g, AuthDevice as h, Capabilities as i, type PayInput as j, type PaymentChain as k, type PaymentProtocol as l, type PaymentResult as m, type PayResult as n, type SessionReceiptPayload as o, coerceTempoChainId as p, FETCH_SKIP_REASONS as q, FETCH_WARNINGS as r, Payments as s, paymentHasAnchor as t, TEMPO_TESTNET_CHAIN_ID as u, tempoChainLabelFromId as v, type BalanceOptions as w, type BalanceReadError as x, type FundingUrlOptions as y, type MigrateAuthorizationResponse as z };