@txnod/sdk 1.0.1

package/dist/errors.d.ts

@@ -0,0 +1,1887 @@
+import type { Chain, ErrorCode, ProblemDetails } from './_shared/index.js';
+/**
+ * Base error thrown by every `TxnodClient` method when the server returns a
+ * non-2xx response. Carries the RFC 7807 problem-details envelope so partners
+ * can branch on `error_code` or log `request_id` for support.
+ *
+ * @example
+ * ```ts
+ * import { TxnodClient, TxnodError } from '@txnod/sdk';
+ *
+ * const client = new TxnodClient({
+ *   projectId: process.env.TXNOD_PROJECT_ID!,
+ *   apiSecret: process.env.TXNOD_API_SECRET!,
+ * });
+ *
+ * try {
+ *   const invoice = await client.createInvoice({
+ *     amount_usd: 10.0,
+ *     coin: 'btc',
+ *     external_id: 'order-123',
+ *     callback_url: 'https://my-site.com/webhooks/txnod',
+ *   });
+ *   console.log(invoice.id);
+ * } catch (err) {
+ *   if (err instanceof TxnodError) {
+ *     console.error(err.error_code, err.status, err.request_id);
+ *   } else {
+ *     throw err;
+ *   }
+ * }
+ * ```
+ */
+export declare class TxnodError extends Error {
+    readonly kind: string;
+    readonly error_code: ErrorCode;
+    readonly status: number;
+    readonly request_id: string;
+    readonly raw: ProblemDetails;
+    constructor(details: ProblemDetails);
+}
+/**
+ * Thrown by `verifyWebhookSignature` when the `X-Txnod-Signature` header is
+ * missing or does not match the expected `t=<unix>,v1=<hex>` shape.
+ *
+ * @example
+ * ```ts
+ * import { verifyWebhookSignature, TxnodSignatureFormatError } from '@txnod/sdk';
+ *
+ * try {
+ *   verifyWebhookSignature(req.headers, rawBody, process.env.TXNOD_WEBHOOK_SECRET!);
+ * } catch (err) {
+ *   if (err instanceof TxnodSignatureFormatError) {
+ *     return new Response('bad header', { status: 401 });
+ *   }
+ *   throw err;
+ * }
+ * ```
+ */
+export declare class TxnodSignatureFormatError extends TxnodError {
+    readonly kind: "signature_format";
+    constructor();
+}
+/**
+ * Thrown by `verifyWebhookSignature` when the computed HMAC-SHA256 does not
+ * match the signature carried in the `X-Txnod-Signature` header.
+ *
+ * @example
+ * ```ts
+ * import { verifyWebhookSignature, TxnodHmacError } from '@txnod/sdk';
+ *
+ * try {
+ *   verifyWebhookSignature(req.headers, rawBody, process.env.TXNOD_WEBHOOK_SECRET!);
+ * } catch (err) {
+ *   if (err instanceof TxnodHmacError) {
+ *     return new Response('bad sig', { status: 401 });
+ *   }
+ *   throw err;
+ * }
+ * ```
+ */
+export declare class TxnodHmacError extends TxnodError {
+    readonly kind: "hmac";
+    constructor();
+}
+/**
+ * Thrown by `verifyWebhookSignature` when the timestamp in the
+ * `X-Txnod-Signature` header is outside the ±300-second window. The signed
+ * `skew_seconds` field reports `now - timestamp` so callers can alert on
+ * clock drift.
+ *
+ * @example
+ * ```ts
+ * import { verifyWebhookSignature, TxnodTimestampError } from '@txnod/sdk';
+ *
+ * try {
+ *   verifyWebhookSignature(req.headers, rawBody, process.env.TXNOD_WEBHOOK_SECRET!);
+ * } catch (err) {
+ *   if (err instanceof TxnodTimestampError) {
+ *     console.warn('clock skew', err.skew_seconds);
+ *     return new Response('stale', { status: 401 });
+ *   }
+ *   throw err;
+ * }
+ * ```
+ */
+export declare class TxnodTimestampError extends TxnodError {
+    readonly kind: "timestamp";
+    readonly skew_seconds: number;
+    constructor(skewSeconds: number);
+}
+/**
+ * Thrown by `verifyWebhookSignature` when the body bytes pass HMAC verification
+ * but cannot be parsed as JSON. In a non-compromised setup this never fires;
+ * a real occurrence indicates a misbehaving server release that emitted a
+ * non-JSON body alongside a valid signature. The `cause` field carries the
+ * underlying `SyntaxError` so the partner can log it. Treat it as a 401-class
+ * failure (do not parse, do not act) — same handling as `TxnodHmacError`.
+ *
+ * @example
+ * ```ts
+ * import { verifyWebhookSignature, TxnodWebhookPayloadParseError } from '@txnod/sdk';
+ *
+ * try {
+ *   verifyWebhookSignature(req.headers, rawBody, secret);
+ * } catch (err) {
+ *   if (err instanceof TxnodWebhookPayloadParseError) {
+ *     return new Response('bad payload', { status: 401 });
+ *   }
+ *   throw err;
+ * }
+ * ```
+ */
+export declare class TxnodWebhookPayloadParseError extends TxnodError {
+    readonly kind: "webhook_payload_parse";
+    readonly cause: unknown;
+    constructor(cause: unknown);
+}
+/**
+ * Thrown when the server responds with `error_code: 'validation_error'` —
+ * request payload failed validation (Zod on the server). Inspect
+ * `err.raw.errors` for the structured per-field issues.
+ *
+ * @example
+ * ```ts
+ * import { TxnodClient, TxnodValidationError } from '@txnod/sdk';
+ *
+ * const client = new TxnodClient({
+ *   projectId: process.env.TXNOD_PROJECT_ID!,
+ *   apiSecret: process.env.TXNOD_API_SECRET!,
+ * });
+ *
+ * try {
+ *   const invoice = await client.createInvoice({
+ *     amount_usd: 10,
+ *     coin: 'btc',
+ *     external_id: 'order-1',
+ *   });
+ *   console.log(invoice.id);
+ * } catch (err) {
+ *   if (err instanceof TxnodValidationError) {
+ *     console.error('validation failed:', err.raw.errors);
+ *     return;
+ *   }
+ *   throw err;
+ * }
+ * ```
+ */
+export declare class TxnodValidationError extends TxnodError {
+    readonly kind: "validation_error";
+    constructor(details: ProblemDetails);
+}
+/**
+ * Thrown when the server responds with `error_code: 'invalid_coin'` — the
+ * requested `coin` is not in the supported coins enum.
+ *
+ * @example
+ * ```ts
+ * import { TxnodClient, TxnodInvalidCoinError } from '@txnod/sdk';
+ *
+ * const client = new TxnodClient({
+ *   projectId: process.env.TXNOD_PROJECT_ID!,
+ *   apiSecret: process.env.TXNOD_API_SECRET!,
+ * });
+ *
+ * try {
+ *   const invoice = await client.createInvoice({
+ *     amount_usd: 10,
+ *     coin: 'btc',
+ *     external_id: 'order-1',
+ *   });
+ *   console.log(invoice.id);
+ * } catch (err) {
+ *   if (err instanceof TxnodInvalidCoinError) {
+ *     console.error(err.error_code, err.request_id);
+ *     return;
+ *   }
+ *   throw err;
+ * }
+ * ```
+ */
+export declare class TxnodInvalidCoinError extends TxnodError {
+    readonly kind: "invalid_coin";
+    constructor(details: ProblemDetails);
+}
+/**
+ * Thrown when the server responds with `error_code: 'invalid_xpub_format'` —
+ * the supplied xpub string is structurally invalid for the chain.
+ *
+ * @example
+ * ```ts
+ * import { TxnodClient, TxnodInvalidXpubFormatError } from '@txnod/sdk';
+ *
+ * const client = new TxnodClient({
+ *   projectId: process.env.TXNOD_PROJECT_ID!,
+ *   apiSecret: process.env.TXNOD_API_SECRET!,
+ * });
+ *
+ * try {
+ *   const invoice = await client.getInvoice('01HK8MAR2QEXAMPLE000000000');
+ *   console.log(invoice.status);
+ * } catch (err) {
+ *   if (err instanceof TxnodInvalidXpubFormatError) {
+ *     console.error(err.error_code, err.request_id);
+ *     return;
+ *   }
+ *   throw err;
+ * }
+ * ```
+ */
+export declare class TxnodInvalidXpubFormatError extends TxnodError {
+    readonly kind: "invalid_xpub_format";
+    constructor(details: ProblemDetails);
+}
+/**
+ * Thrown when the server responds with `error_code: 'invalid_webhook_url'` —
+ * the configured webhook URL is not a valid https URL.
+ *
+ * @example
+ * ```ts
+ * import { TxnodClient, TxnodInvalidWebhookUrlError } from '@txnod/sdk';
+ *
+ * const client = new TxnodClient({
+ *   projectId: process.env.TXNOD_PROJECT_ID!,
+ *   apiSecret: process.env.TXNOD_API_SECRET!,
+ * });
+ *
+ * try {
+ *   const invoice = await client.getInvoice('01HK8MAR2QEXAMPLE000000000');
+ *   console.log(invoice.status);
+ * } catch (err) {
+ *   if (err instanceof TxnodInvalidWebhookUrlError) {
+ *     console.error(err.error_code, err.request_id);
+ *     return;
+ *   }
+ *   throw err;
+ * }
+ * ```
+ */
+export declare class TxnodInvalidWebhookUrlError extends TxnodError {
+    readonly kind: "invalid_webhook_url";
+    constructor(details: ProblemDetails);
+}
+/**
+ * Thrown when the server responds with `error_code: 'auth_invalid'` on an API
+ * call — the `X-Project-Id` / `X-Signature` headers are missing, malformed,
+ * or do not identify a known project. Distinct from the webhook-local
+ * `TxnodSignatureFormatError`: this one is thrown by `TxnodClient` methods
+ * on an API 401 response.
+ *
+ * @example
+ * ```ts
+ * import { TxnodClient, TxnodAuthInvalidError } from '@txnod/sdk';
+ *
+ * const client = new TxnodClient({
+ *   projectId: process.env.TXNOD_PROJECT_ID!,
+ *   apiSecret: process.env.TXNOD_API_SECRET!,
+ * });
+ *
+ * try {
+ *   const invoice = await client.getInvoice('01HK8MAR2QEXAMPLE000000000');
+ *   console.log(invoice.status);
+ * } catch (err) {
+ *   if (err instanceof TxnodAuthInvalidError) {
+ *     console.error(err.error_code, err.request_id);
+ *     return;
+ *   }
+ *   throw err;
+ * }
+ * ```
+ */
+export declare class TxnodAuthInvalidError extends TxnodError {
+    readonly kind: "auth_invalid";
+    constructor(details: ProblemDetails);
+}
+/**
+ * Thrown when the server responds with `error_code: 'signature_invalid'` on
+ * an API call — the computed HMAC for the outbound request did not match.
+ * Distinct from the webhook-local `TxnodHmacError`.
+ *
+ * @example
+ * ```ts
+ * import { TxnodClient, TxnodSignatureInvalidError } from '@txnod/sdk';
+ *
+ * const client = new TxnodClient({
+ *   projectId: process.env.TXNOD_PROJECT_ID!,
+ *   apiSecret: process.env.TXNOD_API_SECRET!,
+ * });
+ *
+ * try {
+ *   const invoice = await client.getInvoice('01HK8MAR2QEXAMPLE000000000');
+ *   console.log(invoice.status);
+ * } catch (err) {
+ *   if (err instanceof TxnodSignatureInvalidError) {
+ *     console.error(err.error_code, err.request_id);
+ *     return;
+ *   }
+ *   throw err;
+ * }
+ * ```
+ */
+export declare class TxnodSignatureInvalidError extends TxnodError {
+    readonly kind: "signature_invalid";
+    constructor(details: ProblemDetails);
+}
+/**
+ * Thrown when the server responds with `error_code: 'signature_replayed'` —
+ * the same signed `(timestamp, signature)` triple has already been processed
+ * within the freshness window. Re-sign the request (fresh timestamp) and try
+ * again. Persistent occurrence indicates a stuck retry loop on the caller
+ * side or, rarer, replay of a captured request.
+ *
+ * @example
+ * ```ts
+ * import { TxnodClient, TxnodSignatureReplayedError } from '@txnod/sdk';
+ *
+ * const client = new TxnodClient({
+ *   projectId: process.env.TXNOD_PROJECT_ID!,
+ *   apiSecret: process.env.TXNOD_API_SECRET!,
+ * });
+ *
+ * try {
+ *   const invoice = await client.createInvoice({
+ *     amount_usd: 10,
+ *     coin: 'btc',
+ *     external_id: 'order-1',
+ *   });
+ *   console.log(invoice.id);
+ * } catch (err) {
+ *   if (err instanceof TxnodSignatureReplayedError) {
+ *     // The previous attempt's signature was already accepted. The SDK
+ *     // signs every request with a fresh timestamp, so this normally only
+ *     // surfaces when something else (a proxy, a retry loop) sends the
+ *     // exact same signed bytes a second time.
+ *     console.error('signed request already processed', err.request_id);
+ *     return;
+ *   }
+ *   throw err;
+ * }
+ * ```
+ */
+export declare class TxnodSignatureReplayedError extends TxnodError {
+    readonly kind: "signature_replayed";
+    constructor(details: ProblemDetails);
+}
+/**
+ * Thrown when the server responds with `error_code: 'timestamp_out_of_window'`
+ * on an API call — the `X-Timestamp` header is outside the ±300-second
+ * window. Distinct from the webhook-local `TxnodTimestampError`, which
+ * exposes a `skew_seconds` field.
+ *
+ * @example
+ * ```ts
+ * import { TxnodClient, TxnodTimestampOutOfWindowError } from '@txnod/sdk';
+ *
+ * const client = new TxnodClient({
+ *   projectId: process.env.TXNOD_PROJECT_ID!,
+ *   apiSecret: process.env.TXNOD_API_SECRET!,
+ * });
+ *
+ * try {
+ *   const invoice = await client.getInvoice('01HK8MAR2QEXAMPLE000000000');
+ *   console.log(invoice.status);
+ * } catch (err) {
+ *   if (err instanceof TxnodTimestampOutOfWindowError) {
+ *     console.error(err.error_code, err.request_id);
+ *     return;
+ *   }
+ *   throw err;
+ * }
+ * ```
+ */
+export declare class TxnodTimestampOutOfWindowError extends TxnodError {
+    readonly kind: "timestamp_out_of_window";
+    constructor(details: ProblemDetails);
+}
+/**
+ * Thrown when the server responds with `error_code: 'key_suspended'` — the
+ * owner of the API key has been suspended.
+ *
+ * @example
+ * ```ts
+ * import { TxnodClient, TxnodKeySuspendedError } from '@txnod/sdk';
+ *
+ * const client = new TxnodClient({
+ *   projectId: process.env.TXNOD_PROJECT_ID!,
+ *   apiSecret: process.env.TXNOD_API_SECRET!,
+ * });
+ *
+ * try {
+ *   const invoice = await client.getInvoice('01HK8MAR2QEXAMPLE000000000');
+ *   console.log(invoice.status);
+ * } catch (err) {
+ *   if (err instanceof TxnodKeySuspendedError) {
+ *     console.error(err.error_code, err.request_id);
+ *     return;
+ *   }
+ *   throw err;
+ * }
+ * ```
+ */
+export declare class TxnodKeySuspendedError extends TxnodError {
+    readonly kind: "key_suspended";
+    constructor(details: ProblemDetails);
+}
+/**
+ * Thrown when the server responds with `error_code: 'project_suspended'` —
+ * the target project has been suspended.
+ *
+ * @example
+ * ```ts
+ * import { TxnodClient, TxnodProjectSuspendedError } from '@txnod/sdk';
+ *
+ * const client = new TxnodClient({
+ *   projectId: process.env.TXNOD_PROJECT_ID!,
+ *   apiSecret: process.env.TXNOD_API_SECRET!,
+ * });
+ *
+ * try {
+ *   const invoice = await client.getInvoice('01HK8MAR2QEXAMPLE000000000');
+ *   console.log(invoice.status);
+ * } catch (err) {
+ *   if (err instanceof TxnodProjectSuspendedError) {
+ *     console.error(err.error_code, err.request_id);
+ *     return;
+ *   }
+ *   throw err;
+ * }
+ * ```
+ */
+export declare class TxnodProjectSuspendedError extends TxnodError {
+    readonly kind: "project_suspended";
+    constructor(details: ProblemDetails);
+}
+/**
+ * Thrown when the server responds with `error_code: 'permission_denied'` —
+ * the authenticated key does not hold the capability required by the route.
+ *
+ * @example
+ * ```ts
+ * import { TxnodClient, TxnodPermissionDeniedError } from '@txnod/sdk';
+ *
+ * const client = new TxnodClient({
+ *   projectId: process.env.TXNOD_PROJECT_ID!,
+ *   apiSecret: process.env.TXNOD_API_SECRET!,
+ * });
+ *
+ * try {
+ *   const invoice = await client.getInvoice('01HK8MAR2QEXAMPLE000000000');
+ *   console.log(invoice.status);
+ * } catch (err) {
+ *   if (err instanceof TxnodPermissionDeniedError) {
+ *     console.error(err.error_code, err.request_id);
+ *     return;
+ *   }
+ *   throw err;
+ * }
+ * ```
+ */
+export declare class TxnodPermissionDeniedError extends TxnodError {
+    readonly kind: "permission_denied";
+    constructor(details: ProblemDetails);
+}
+/**
+ * Thrown when the server responds with `error_code: 'key_revoked'` — the
+ * API key has been rotated or revoked and is no longer valid.
+ *
+ * @example
+ * ```ts
+ * import { TxnodClient, TxnodKeyRevokedError } from '@txnod/sdk';
+ *
+ * const client = new TxnodClient({
+ *   projectId: process.env.TXNOD_PROJECT_ID!,
+ *   apiSecret: process.env.TXNOD_API_SECRET!,
+ * });
+ *
+ * try {
+ *   const invoice = await client.getInvoice('01HK8MAR2QEXAMPLE000000000');
+ *   console.log(invoice.status);
+ * } catch (err) {
+ *   if (err instanceof TxnodKeyRevokedError) {
+ *     console.error(err.error_code, err.request_id);
+ *     return;
+ *   }
+ *   throw err;
+ * }
+ * ```
+ */
+export declare class TxnodKeyRevokedError extends TxnodError {
+    readonly kind: "key_revoked";
+    constructor(details: ProblemDetails);
+}
+/**
+ * Thrown when the server responds with `error_code: 'invoice_not_found'` —
+ * no invoice exists with the given id for this project.
+ *
+ * @example
+ * ```ts
+ * import { TxnodClient, TxnodInvoiceNotFoundError } from '@txnod/sdk';
+ *
+ * const client = new TxnodClient({
+ *   projectId: process.env.TXNOD_PROJECT_ID!,
+ *   apiSecret: process.env.TXNOD_API_SECRET!,
+ * });
+ *
+ * try {
+ *   const invoice = await client.getInvoice('01HK8MAR2QEXAMPLE000000000');
+ *   return Response.json(invoice);
+ * } catch (err) {
+ *   if (err instanceof TxnodInvoiceNotFoundError) {
+ *     return new Response('Not found', { status: 404 });
+ *   }
+ *   throw err;
+ * }
+ * ```
+ */
+export declare class TxnodInvoiceNotFoundError extends TxnodError {
+    readonly kind: "invoice_not_found";
+    constructor(details: ProblemDetails);
+}
+/**
+ * Thrown when the server responds with `error_code: 'project_not_found'` —
+ * no project exists with the given id (or the key does not have access).
+ *
+ * @example
+ * ```ts
+ * import { TxnodClient, TxnodProjectNotFoundError } from '@txnod/sdk';
+ *
+ * const client = new TxnodClient({
+ *   projectId: process.env.TXNOD_PROJECT_ID!,
+ *   apiSecret: process.env.TXNOD_API_SECRET!,
+ * });
+ *
+ * try {
+ *   const invoice = await client.getInvoice('01HK8MAR2QEXAMPLE000000000');
+ *   console.log(invoice.status);
+ * } catch (err) {
+ *   if (err instanceof TxnodProjectNotFoundError) {
+ *     console.error(err.error_code, err.request_id);
+ *     return;
+ *   }
+ *   throw err;
+ * }
+ * ```
+ */
+export declare class TxnodProjectNotFoundError extends TxnodError {
+    readonly kind: "project_not_found";
+    constructor(details: ProblemDetails);
+}
+/**
+ * Thrown when the server responds with `error_code: 'wallet_not_found'` —
+ * no wallet record exists for the requested chain + project.
+ *
+ * @example
+ * ```ts
+ * import { TxnodClient, TxnodWalletNotFoundError } from '@txnod/sdk';
+ *
+ * const client = new TxnodClient({
+ *   projectId: process.env.TXNOD_PROJECT_ID!,
+ *   apiSecret: process.env.TXNOD_API_SECRET!,
+ * });
+ *
+ * try {
+ *   const invoice = await client.getInvoice('01HK8MAR2QEXAMPLE000000000');
+ *   console.log(invoice.status);
+ * } catch (err) {
+ *   if (err instanceof TxnodWalletNotFoundError) {
+ *     console.error(err.error_code, err.request_id);
+ *     return;
+ *   }
+ *   throw err;
+ * }
+ * ```
+ */
+export declare class TxnodWalletNotFoundError extends TxnodError {
+    readonly kind: "wallet_not_found";
+    constructor(details: ProblemDetails);
+}
+/**
+ * Thrown when the server responds with `error_code: 'external_id_conflict'` —
+ * an invoice with the requested `external_id` already exists for this
+ * project. Treat as idempotent success and fetch the existing invoice.
+ *
+ * @example
+ * ```ts
+ * import { TxnodClient, TxnodExternalIdConflictError } from '@txnod/sdk';
+ *
+ * const client = new TxnodClient({
+ *   projectId: process.env.TXNOD_PROJECT_ID!,
+ *   apiSecret: process.env.TXNOD_API_SECRET!,
+ * });
+ *
+ * try {
+ *   const invoice = await client.createInvoice({
+ *     amount_usd: 10,
+ *     coin: 'btc',
+ *     external_id: 'order-1',
+ *   });
+ *   console.log(invoice.id);
+ * } catch (err) {
+ *   if (err instanceof TxnodExternalIdConflictError) {
+ *     const page = await client.searchInvoices({ external_id: 'order-1', limit: 1 });
+ *     const existing = page.items[0];
+ *     if (existing !== undefined) console.log(existing.status);
+ *     return;
+ *   }
+ *   throw err;
+ * }
+ * ```
+ */
+export declare class TxnodExternalIdConflictError extends TxnodError {
+    readonly kind: "external_id_conflict";
+    constructor(details: ProblemDetails);
+}
+/**
+ * Thrown when the server responds with `error_code: 'xpub_not_verified'` —
+ * the xpub for the chain has not completed its verification challenge yet.
+ *
+ * @example
+ * ```ts
+ * import { TxnodClient, TxnodXpubNotVerifiedError } from '@txnod/sdk';
+ *
+ * const client = new TxnodClient({
+ *   projectId: process.env.TXNOD_PROJECT_ID!,
+ *   apiSecret: process.env.TXNOD_API_SECRET!,
+ * });
+ *
+ * try {
+ *   const invoice = await client.createInvoice({
+ *     amount_usd: 10,
+ *     coin: 'btc',
+ *     external_id: 'order-1',
+ *   });
+ *   console.log(invoice.id);
+ * } catch (err) {
+ *   if (err instanceof TxnodXpubNotVerifiedError) {
+ *     console.error(err.error_code, err.request_id);
+ *     return;
+ *   }
+ *   throw err;
+ * }
+ * ```
+ */
+export declare class TxnodXpubNotVerifiedError extends TxnodError {
+    readonly kind: "xpub_not_verified";
+    constructor(details: ProblemDetails);
+}
+/**
+ * Thrown when the server responds with `error_code: 'coin_not_enabled'` —
+ * the requested coin is not enabled for this project. Point the user at a
+ * coin from `client.getRates()`.
+ *
+ * @example
+ * ```ts
+ * import { TxnodClient, TxnodCoinNotEnabledError } from '@txnod/sdk';
+ *
+ * const client = new TxnodClient({
+ *   projectId: process.env.TXNOD_PROJECT_ID!,
+ *   apiSecret: process.env.TXNOD_API_SECRET!,
+ * });
+ *
+ * try {
+ *   const invoice = await client.createInvoice({
+ *     amount_usd: 10,
+ *     coin: 'btc',
+ *     external_id: 'order-1',
+ *   });
+ *   console.log(invoice.id);
+ * } catch (err) {
+ *   if (err instanceof TxnodCoinNotEnabledError) {
+ *     const rates = await client.getRates({});
+ *     console.log('enabled coins:', Object.keys(rates.rates));
+ *     return;
+ *   }
+ *   throw err;
+ * }
+ * ```
+ */
+export declare class TxnodCoinNotEnabledError extends TxnodError {
+    readonly kind: "coin_not_enabled";
+    constructor(details: ProblemDetails);
+}
+/**
+ * Thrown when the server responds with `error_code: 'amount_out_of_range'` —
+ * the requested amount is outside the project's accepted range.
+ *
+ * @example
+ * ```ts
+ * import { TxnodClient, TxnodAmountOutOfRangeError } from '@txnod/sdk';
+ *
+ * const client = new TxnodClient({
+ *   projectId: process.env.TXNOD_PROJECT_ID!,
+ *   apiSecret: process.env.TXNOD_API_SECRET!,
+ * });
+ *
+ * try {
+ *   const invoice = await client.createInvoice({
+ *     amount_usd: 10,
+ *     coin: 'btc',
+ *     external_id: 'order-1',
+ *   });
+ *   console.log(invoice.id);
+ * } catch (err) {
+ *   if (err instanceof TxnodAmountOutOfRangeError) {
+ *     console.error(err.error_code, err.request_id);
+ *     return;
+ *   }
+ *   throw err;
+ * }
+ * ```
+ */
+export declare class TxnodAmountOutOfRangeError extends TxnodError {
+    readonly kind: "amount_out_of_range";
+    constructor(details: ProblemDetails);
+}
+/**
+ * Thrown when the server responds with `error_code: 'rate_limit_exceeded'` —
+ * the per-key rate limit has been exceeded. The `retry_after_seconds` field
+ * carries the value of the HTTP `Retry-After` header (0 when absent).
+ *
+ * @example
+ * ```ts
+ * import { TxnodClient, TxnodRateLimitError } from '@txnod/sdk';
+ *
+ * const client = new TxnodClient({
+ *   projectId: process.env.TXNOD_PROJECT_ID!,
+ *   apiSecret: process.env.TXNOD_API_SECRET!,
+ * });
+ *
+ * try {
+ *   const invoice = await client.getInvoice('01HK8MAR2QEXAMPLE000000000');
+ *   console.log(invoice.status);
+ * } catch (err) {
+ *   if (err instanceof TxnodRateLimitError) {
+ *     await new Promise((r) => setTimeout(r, err.retry_after_seconds * 1000));
+ *     const retry = await client.getInvoice('01HK8MAR2QEXAMPLE000000000');
+ *     console.log(retry.status);
+ *     return;
+ *   }
+ *   throw err;
+ * }
+ * ```
+ */
+export declare class TxnodRateLimitError extends TxnodError {
+    readonly kind: "rate_limit_exceeded";
+    readonly retry_after_seconds: number;
+    constructor(details: ProblemDetails, retryAfterSeconds: number);
+}
+/**
+ * Thrown when the server responds with `error_code: 'pool_exhausted'` — the
+ * per-chain derivation-address pool has hit its hard cap
+ * (`poolSizePerChain[chain]`) and no slot is currently `available`. The
+ * `retry_after_seconds` field carries the value of the HTTP `Retry-After`
+ * header (0 when absent) — the server derives it from the soonest
+ * `locked_until` across locked rows, falling back to the project's
+ * `cooldownSeconds`. Wait the indicated interval before retrying, or raise
+ * the per-chain pool cap if this fires under normal load.
+ *
+ * @example
+ * ```ts
+ * import { TxnodClient, TxnodPoolExhaustedError } from '@txnod/sdk';
+ *
+ * const client = new TxnodClient({
+ *   projectId: process.env.TXNOD_PROJECT_ID!,
+ *   apiSecret: process.env.TXNOD_API_SECRET!,
+ * });
+ *
+ * try {
+ *   const invoice = await client.createInvoice({
+ *     amount_usd: 10,
+ *     coin: 'btc',
+ *     external_id: 'order-1',
+ *   });
+ *   console.log(invoice.id);
+ * } catch (err) {
+ *   if (err instanceof TxnodPoolExhaustedError) {
+ *     await new Promise((r) => setTimeout(r, err.retry_after_seconds * 1000));
+ *     const retry = await client.createInvoice({
+ *       amount_usd: 10,
+ *       coin: 'btc',
+ *       external_id: 'order-1',
+ *     });
+ *     console.log(retry.id);
+ *     return;
+ *   }
+ *   throw err;
+ * }
+ * ```
+ */
+export declare class TxnodPoolExhaustedError extends TxnodError {
+    readonly kind: "pool_exhausted";
+    readonly retry_after_seconds: number;
+    constructor(details: ProblemDetails, retryAfterSeconds: number);
+}
+/**
+ * Thrown when the server responds with `error_code: 'webhook_capacity_exhausted'`
+ * — the chain's webhook fleet has no spare slots, so the server can't bind a
+ * new pool address to a webhook. `retry_after_seconds` is `0` because partner
+ * retry alone will not free capacity. Treat as a transient outage; queue the
+ * invoice and retry later.
+ *
+ * @example
+ * ```ts
+ * import { TxnodClient, TxnodWebhookCapacityExhaustedError } from '@txnod/sdk';
+ *
+ * const client = new TxnodClient({
+ *   projectId: process.env.TXNOD_PROJECT_ID!,
+ *   apiSecret: process.env.TXNOD_API_SECRET!,
+ * });
+ *
+ * try {
+ *   await client.createInvoice({
+ *     external_id: 'order-1',
+ *     amount_usd: 100,
+ *     coin: 'eth',
+ *   });
+ * } catch (err) {
+ *   if (err instanceof TxnodWebhookCapacityExhaustedError) {
+ *     console.error('webhook fleet at capacity for chain:', err.kind);
+ *     // Transient outage — queue invoice and retry later.
+ *     return;
+ *   }
+ *   throw err;
+ * }
+ * ```
+ */
+export declare class TxnodWebhookCapacityExhaustedError extends TxnodError {
+    readonly kind: "webhook_capacity_exhausted";
+    readonly retry_after_seconds: number;
+    constructor(details: ProblemDetails, retryAfterSeconds: number);
+}
+/**
+ * Thrown when the server responds with `error_code: 'internal_error'` — the
+ * server failed for a reason it could not categorize. Log `err.request_id`
+ * for support and treat as a retryable 5xx.
+ *
+ * @example
+ * ```ts
+ * import { TxnodClient, TxnodServerError } from '@txnod/sdk';
+ *
+ * const client = new TxnodClient({
+ *   projectId: process.env.TXNOD_PROJECT_ID!,
+ *   apiSecret: process.env.TXNOD_API_SECRET!,
+ * });
+ *
+ * try {
+ *   const invoice = await client.getInvoice('01HK8MAR2QEXAMPLE000000000');
+ *   console.log(invoice.status);
+ * } catch (err) {
+ *   if (err instanceof TxnodServerError) {
+ *     console.error('TxNod server error — report request_id to support:', err.request_id);
+ *     return;
+ *   }
+ *   throw err;
+ * }
+ * ```
+ */
+export declare class TxnodServerError extends TxnodError {
+    readonly kind: "internal_error";
+    constructor(details: ProblemDetails);
+}
+/**
+ * Thrown when the server responds with `error_code: 'invoice_not_cancellable'`
+ * — the invoice is in a state that does not permit cancellation.
+ *
+ * @example
+ * ```ts
+ * import { TxnodClient, TxnodInvoiceNotCancellableError } from '@txnod/sdk';
+ *
+ * const client = new TxnodClient({
+ *   projectId: process.env.TXNOD_PROJECT_ID!,
+ *   apiSecret: process.env.TXNOD_API_SECRET!,
+ * });
+ *
+ * try {
+ *   const invoice = await client.cancelInvoice('01HK8MAR2QEXAMPLE000000000');
+ *   console.log(invoice.status);
+ * } catch (err) {
+ *   if (err instanceof TxnodInvoiceNotCancellableError) {
+ *     console.error(err.error_code, err.request_id);
+ *     return;
+ *   }
+ *   throw err;
+ * }
+ * ```
+ */
+export declare class TxnodInvoiceNotCancellableError extends TxnodError {
+    readonly kind: "invoice_not_cancellable";
+    constructor(details: ProblemDetails);
+}
+/**
+ * Thrown when the server responds with `error_code: 'invalid_state_transition'`
+ * — the requested operation would produce an illegal invoice state
+ * transition.
+ *
+ * @example
+ * ```ts
+ * import { TxnodClient, TxnodInvalidStateTransitionError } from '@txnod/sdk';
+ *
+ * const client = new TxnodClient({
+ *   projectId: process.env.TXNOD_PROJECT_ID!,
+ *   apiSecret: process.env.TXNOD_API_SECRET!,
+ * });
+ *
+ * try {
+ *   const invoice = await client.cancelInvoice('01HK8MAR2QEXAMPLE000000000');
+ *   console.log(invoice.status);
+ * } catch (err) {
+ *   if (err instanceof TxnodInvalidStateTransitionError) {
+ *     console.error(err.error_code, err.request_id);
+ *     return;
+ *   }
+ *   throw err;
+ * }
+ * ```
+ */
+export declare class TxnodInvalidStateTransitionError extends TxnodError {
+    readonly kind: "invalid_state_transition";
+    constructor(details: ProblemDetails);
+}
+/**
+ * Thrown when the server responds with `error_code: 'orphan_not_found'` —
+ * no orphan payment exists with the given tx hash.
+ *
+ * @example
+ * ```ts
+ * import { TxnodClient, TxnodOrphanNotFoundError } from '@txnod/sdk';
+ *
+ * const client = new TxnodClient({
+ *   projectId: process.env.TXNOD_PROJECT_ID!,
+ *   apiSecret: process.env.TXNOD_API_SECRET!,
+ * });
+ *
+ * try {
+ *   await client.attributeOrphanPayment('0xabc', { external_id: 'order-1' });
+ * } catch (err) {
+ *   if (err instanceof TxnodOrphanNotFoundError) {
+ *     console.error(err.error_code, err.request_id);
+ *     return;
+ *   }
+ *   throw err;
+ * }
+ * ```
+ */
+export declare class TxnodOrphanNotFoundError extends TxnodError {
+    readonly kind: "orphan_not_found";
+    constructor(details: ProblemDetails);
+}
+/**
+ * Thrown when the server responds with `error_code: 'orphan_already_attributed'`
+ * — the orphan payment has already been attributed to an invoice.
+ *
+ * @example
+ * ```ts
+ * import { TxnodClient, TxnodOrphanAlreadyAttributedError } from '@txnod/sdk';
+ *
+ * const client = new TxnodClient({
+ *   projectId: process.env.TXNOD_PROJECT_ID!,
+ *   apiSecret: process.env.TXNOD_API_SECRET!,
+ * });
+ *
+ * try {
+ *   await client.attributeOrphanPayment('0xabc', { external_id: 'order-1' });
+ * } catch (err) {
+ *   if (err instanceof TxnodOrphanAlreadyAttributedError) {
+ *     console.error(err.error_code, err.request_id);
+ *     return;
+ *   }
+ *   throw err;
+ * }
+ * ```
+ */
+export declare class TxnodOrphanAlreadyAttributedError extends TxnodError {
+    readonly kind: "orphan_already_attributed";
+    constructor(details: ProblemDetails);
+}
+/**
+ * Thrown when the server responds with `error_code: 'event_not_found'` — no
+ * webhook event exists with the given id for this project.
+ *
+ * @example
+ * ```ts
+ * import { TxnodClient, TxnodEventNotFoundError } from '@txnod/sdk';
+ *
+ * const client = new TxnodClient({
+ *   projectId: process.env.TXNOD_PROJECT_ID!,
+ *   apiSecret: process.env.TXNOD_API_SECRET!,
+ * });
+ *
+ * try {
+ *   await client.resendWebhookEvent('01HK8MAR2QEXAMPLE000000000');
+ * } catch (err) {
+ *   if (err instanceof TxnodEventNotFoundError) {
+ *     console.error(err.error_code, err.request_id);
+ *     return;
+ *   }
+ *   throw err;
+ * }
+ * ```
+ */
+export declare class TxnodEventNotFoundError extends TxnodError {
+    readonly kind: "event_not_found";
+    constructor(details: ProblemDetails);
+}
+/**
+ * Thrown when the server responds with `error_code: 'wallet_not_bound'` —
+ * the target project has no verified wallet bound for the requested chain.
+ * The chain is implied by the invoice's `coin` and the project's `kind`
+ * (production / testnet) is fixed at project create time. Bind a wallet of
+ * matching kind via the dashboard or the binding API before retrying invoice
+ * creation.
+ *
+ * Status: 422 (was 409 in pre-`testnet`-kind builds).
+ *
+ * @example
+ * ```ts
+ * import { TxnodClient, TxnodWalletNotBoundError } from '@txnod/sdk';
+ *
+ * const client = new TxnodClient({
+ *   projectId: process.env.TXNOD_PROJECT_ID!,
+ *   apiSecret: process.env.TXNOD_API_SECRET!,
+ * });
+ *
+ * try {
+ *   const invoice = await client.createInvoice({
+ *     amount_usd: 10,
+ *     coin: 'btc',
+ *     external_id: 'order-1',
+ *   });
+ *   console.log(invoice.id);
+ * } catch (err) {
+ *   if (err instanceof TxnodWalletNotBoundError) {
+ *     console.error('bind a wallet before retrying', err.request_id);
+ *     return;
+ *   }
+ *   throw err;
+ * }
+ * ```
+ */
+export declare class TxnodWalletNotBoundError extends TxnodError {
+    readonly kind: "wallet_not_bound";
+    constructor(details: ProblemDetails);
+}
+/**
+ * Thrown when the server responds with `error_code: 'wallet_kind_mismatch'`
+ * (HTTP 422) — the operator attempted to bind an `operator_wallet` of one
+ * `kind` (e.g. `'testnet'`) to a project of a different `kind` (e.g.
+ * `'production'`). Project kind is fixed at create time and cross-kind
+ * binding is forbidden — production projects accept only production wallets,
+ * testnet projects accept only testnet wallets, sandbox projects auto-derive
+ * their own simulated wallets and never reach the operator-binding surface.
+ *
+ * Recover by either creating a wallet of the matching kind, or creating a
+ * fresh project of the wallet's kind.
+ *
+ * @example
+ * ```ts
+ * import { TxnodWalletKindMismatchError } from '@txnod/sdk';
+ *
+ * try {
+ *   // ...attempt a cross-kind wallet binding via a server action / internal API...
+ * } catch (err) {
+ *   if (err instanceof TxnodWalletKindMismatchError) {
+ *     console.error('cannot bind across kinds', err.request_id);
+ *     return;
+ *   }
+ *   throw err;
+ * }
+ * ```
+ */
+export declare class TxnodWalletKindMismatchError extends TxnodError {
+    readonly kind: "wallet_kind_mismatch";
+    constructor(details: ProblemDetails);
+}
+/**
+ * Thrown when the server responds with `error_code: 'wallet_not_owned'` — the
+ * authenticated operator does not own the wallet targeted by the request.
+ * Dashboard-only: the partner HMAC surface never exposes other-operator wallets,
+ * so this error is limited to internal Server Actions.
+ *
+ * @example
+ * ```ts
+ * import { TxnodClient, TxnodWalletNotOwnedError } from '@txnod/sdk';
+ *
+ * const client = new TxnodClient({
+ *   projectId: process.env.TXNOD_PROJECT_ID!,
+ *   apiSecret: process.env.TXNOD_API_SECRET!,
+ * });
+ *
+ * try {
+ *   const invoice = await client.getInvoice('01HK8MAR2QEXAMPLE000000000');
+ *   console.log(invoice.status);
+ * } catch (err) {
+ *   if (err instanceof TxnodWalletNotOwnedError) {
+ *     console.error(err.error_code, err.request_id);
+ *     return;
+ *   }
+ *   throw err;
+ * }
+ * ```
+ */
+export declare class TxnodWalletNotOwnedError extends TxnodError {
+    readonly kind: "wallet_not_owned";
+    constructor(details: ProblemDetails);
+}
+/**
+ * Thrown when the server responds with `error_code: 'wallet_has_active_bindings'`
+ * — the authenticated operator attempted to archive an `operator_wallet` while
+ * at least one `project_chain_wallet_bindings` row still references it. The
+ * RFC-7807 response carries an `extensions.affected_projects` list of
+ * `(project_id, project_name, chain)` tuples; future SDK methods will expose
+ * them via a dedicated field on this class.
+ *
+ * @example
+ * ```ts
+ * import { TxnodWalletHasActiveBindingsError } from '@txnod/sdk';
+ *
+ * try {
+ *   // ...attempt to archive an operator wallet that still has active bindings...
+ * } catch (err) {
+ *   if (err instanceof TxnodWalletHasActiveBindingsError) {
+ *     console.error('rebind affected projects first', err.request_id);
+ *     return;
+ *   }
+ *   throw err;
+ * }
+ * ```
+ */
+export declare class TxnodWalletHasActiveBindingsError extends TxnodError {
+    readonly kind: "wallet_has_active_bindings";
+    constructor(details: ProblemDetails);
+}
+/**
+ * Thrown when the server responds with `error_code: 'subscription_expired'`
+ * (HTTP 402) — the authenticated operator's subscription is not `active`
+ * and write operations are blocked. Reads remain available. The operator
+ * must renew via `/billing` before writes will succeed again.
+ *
+ * @example
+ * ```ts
+ * import { TxnodClient, TxnodSubscriptionExpiredError } from '@txnod/sdk';
+ *
+ * const client = new TxnodClient({
+ *   projectId: process.env.TXNOD_PROJECT_ID!,
+ *   apiSecret: process.env.TXNOD_API_SECRET!,
+ * });
+ *
+ * try {
+ *   await client.createInvoice({ external_id: 'o-1', amount_usd: 50, coin: 'btc' });
+ * } catch (err) {
+ *   if (err instanceof TxnodSubscriptionExpiredError) {
+ *     console.error('renew subscription at /billing', err.request_id);
+ *     return;
+ *   }
+ *   throw err;
+ * }
+ * ```
+ */
+export declare class TxnodSubscriptionExpiredError extends TxnodError {
+    readonly kind: "subscription_expired";
+    constructor(details: ProblemDetails);
+}
+/**
+ * Thrown when the server responds with `error_code: 'tron_no_activated_addresses_available'`
+ * (HTTP 422) — the operator's TRON pool has zero activated addresses and the
+ * invoice cannot be issued. The `wallet_id` field carries the operator wallet
+ * id; deep-link the operator into `/wallets/{wallet_id}` where they can
+ * activate addresses via a third-party multisend service or an in-dashboard
+ * Ledger tool.
+ *
+ * @example
+ * ```ts
+ * import { TxnodClient, TxnodTronNoActivatedAddressesError } from '@txnod/sdk';
+ *
+ * const client = new TxnodClient({
+ *   projectId: process.env.TXNOD_PROJECT_ID!,
+ *   apiSecret: process.env.TXNOD_API_SECRET!,
+ * });
+ *
+ * try {
+ *   const invoice = await client.createInvoice({
+ *     amount_usd: 10,
+ *     coin: 'usdt_trc20',
+ *     external_id: 'order-1',
+ *   });
+ *   console.log(invoice.id);
+ * } catch (err) {
+ *   if (err instanceof TxnodTronNoActivatedAddressesError) {
+ *     console.error('activate addresses for wallet', err.walletId);
+ *     return;
+ *   }
+ *   throw err;
+ * }
+ * ```
+ */
+export declare class TxnodTronNoActivatedAddressesError extends TxnodError {
+    readonly kind: "tron_no_activated_addresses_available";
+    readonly walletId: string;
+    constructor(details: ProblemDetails);
+}
+/**
+ * Thrown when the server responds with `error_code: 'ton_operator_wallet_not_deployed'`
+ * (HTTP 422) — the operator's TON wallet has not yet been deployed on-chain,
+ * so a deposit cannot be issued. Trigger the wallet's first outbound message
+ * (or send a no-op transaction) to deploy the contract, then retry.
+ *
+ * @example
+ * ```ts
+ * import { TxnodClient, TxnodTonOperatorWalletNotDeployedError } from '@txnod/sdk';
+ *
+ * const client = new TxnodClient({
+ *   projectId: process.env.TXNOD_PROJECT_ID!,
+ *   apiSecret: process.env.TXNOD_API_SECRET!,
+ * });
+ *
+ * try {
+ *   const invoice = await client.createInvoice({
+ *     amount_usd: 10,
+ *     coin: 'ton',
+ *     external_id: 'order-1',
+ *   });
+ *   console.log(invoice.id);
+ * } catch (err) {
+ *   if (err instanceof TxnodTonOperatorWalletNotDeployedError) {
+ *     console.error('deploy operator wallet before issuing TON invoices', err.request_id);
+ *     return;
+ *   }
+ *   throw err;
+ * }
+ * ```
+ */
+export declare class TxnodTonOperatorWalletNotDeployedError extends TxnodError {
+    readonly kind: "ton_operator_wallet_not_deployed";
+    constructor(details: ProblemDetails);
+}
+/**
+ * Thrown when the server responds with `error_code: 'ton_invalid_wallet_version'`
+ * (HTTP 422) — the TON wallet version supplied is not one of the supported
+ * versions (`v3R2`, `v4R2`, `v5R1`).
+ *
+ * @example
+ * ```ts
+ * import { TxnodClient, TxnodTonInvalidWalletVersionError } from '@txnod/sdk';
+ *
+ * const client = new TxnodClient({
+ *   projectId: process.env.TXNOD_PROJECT_ID!,
+ *   apiSecret: process.env.TXNOD_API_SECRET!,
+ * });
+ *
+ * try {
+ *   const invoice = await client.createInvoice({
+ *     amount_usd: 10,
+ *     coin: 'ton',
+ *     external_id: 'order-1',
+ *   });
+ *   console.log(invoice.id);
+ * } catch (err) {
+ *   if (err instanceof TxnodTonInvalidWalletVersionError) {
+ *     console.error('register a v3R2/v4R2/v5R1 wallet', err.request_id);
+ *     return;
+ *   }
+ *   throw err;
+ * }
+ * ```
+ */
+export declare class TxnodTonInvalidWalletVersionError extends TxnodError {
+    readonly kind: "ton_invalid_wallet_version";
+    constructor(details: ProblemDetails);
+}
+/**
+ * Thrown when the server responds with `error_code: 'ton_jetton_resolve_failed'`
+ * (HTTP 503) — the TON jetton-wallet address could not be resolved because
+ * the upstream provider is temporarily unavailable. The error is retryable.
+ *
+ * @example
+ * ```ts
+ * import { TxnodClient, TxnodTonJettonResolveFailedError } from '@txnod/sdk';
+ *
+ * const client = new TxnodClient({
+ *   projectId: process.env.TXNOD_PROJECT_ID!,
+ *   apiSecret: process.env.TXNOD_API_SECRET!,
+ * });
+ *
+ * try {
+ *   const invoice = await client.createInvoice({
+ *     amount_usd: 10,
+ *     coin: 'usdt_ton',
+ *     external_id: 'order-1',
+ *   });
+ *   console.log(invoice.id);
+ * } catch (err) {
+ *   if (err instanceof TxnodTonJettonResolveFailedError) {
+ *     console.error('jetton resolver unavailable; retrying soon', err.request_id);
+ *     return;
+ *   }
+ *   throw err;
+ * }
+ * ```
+ */
+export declare class TxnodTonJettonResolveFailedError extends TxnodError {
+    readonly kind: "ton_jetton_resolve_failed";
+    constructor(details: ProblemDetails);
+}
+/**
+ * Thrown when the server responds with `error_code: 'ton_comment_parse_failed'`
+ * (HTTP 422) — a TON deposit comment could not be parsed as a payment token.
+ * Surfaces through the orphan / unattributed-deposit flow rather than the
+ * partner integration API, but is included here for SDK error mapping
+ * completeness.
+ *
+ * @example
+ * ```ts
+ * import { TxnodClient, TxnodTonCommentParseFailedError } from '@txnod/sdk';
+ *
+ * const client = new TxnodClient({
+ *   projectId: process.env.TXNOD_PROJECT_ID!,
+ *   apiSecret: process.env.TXNOD_API_SECRET!,
+ * });
+ *
+ * try {
+ *   await client.attributeOrphanPayment('0xabc', { external_id: 'order-1' });
+ * } catch (err) {
+ *   if (err instanceof TxnodTonCommentParseFailedError) {
+ *     console.error('TON deposit comment was unparseable', err.request_id);
+ *     return;
+ *   }
+ *   throw err;
+ * }
+ * ```
+ */
+export declare class TxnodTonCommentParseFailedError extends TxnodError {
+    readonly kind: "ton_comment_parse_failed";
+    constructor(details: ProblemDetails);
+}
+/**
+ * Thrown when the dashboard responds with `error_code: 'tonconnect_payload_expired'`.
+ * The TON Connect handshake nonce expired (5-minute TTL); restart the wizard.
+ *
+ * @example
+ * ```ts
+ * import { TxnodTonConnectPayloadExpiredError } from '@txnod/sdk';
+ *
+ * try {
+ *   // SDK call that bubbles a /tonconnect/verify problem+json
+ * } catch (err) {
+ *   if (err instanceof TxnodTonConnectPayloadExpiredError) {
+ *     console.error('TON Connect nonce expired', err.request_id);
+ *   }
+ * }
+ * ```
+ */
+export declare class TxnodTonConnectPayloadExpiredError extends TxnodError {
+    readonly kind: "tonconnect_payload_expired";
+    constructor(details: ProblemDetails);
+}
+/**
+ * Thrown when the dashboard responds with `error_code: 'tonconnect_payload_unknown'`.
+ * The proof's payload field does not match any nonce on file for this operator.
+ *
+ * @example
+ * ```ts
+ * import { TxnodTonConnectPayloadUnknownError } from '@txnod/sdk';
+ *
+ * try {
+ *   // SDK call that bubbles a /tonconnect/verify problem+json
+ * } catch (err) {
+ *   if (err instanceof TxnodTonConnectPayloadUnknownError) {
+ *     console.error('TON Connect nonce unknown', err.request_id);
+ *   }
+ * }
+ * ```
+ */
+export declare class TxnodTonConnectPayloadUnknownError extends TxnodError {
+    readonly kind: "tonconnect_payload_unknown";
+    constructor(details: ProblemDetails);
+}
+/**
+ * Thrown when the dashboard responds with `error_code: 'tonconnect_domain_mismatch'`.
+ * The wallet attested to a different domain than the server's TXNOD_TONCONNECT_DOMAIN.
+ *
+ * @example
+ * ```ts
+ * import { TxnodTonConnectDomainMismatchError } from '@txnod/sdk';
+ *
+ * try {
+ *   // SDK call that bubbles a /tonconnect/verify problem+json
+ * } catch (err) {
+ *   if (err instanceof TxnodTonConnectDomainMismatchError) {
+ *     console.error('TON Connect domain mismatch', err.request_id);
+ *   }
+ * }
+ * ```
+ */
+export declare class TxnodTonConnectDomainMismatchError extends TxnodError {
+    readonly kind: "tonconnect_domain_mismatch";
+    constructor(details: ProblemDetails);
+}
+/**
+ * Thrown when the dashboard responds with `error_code: 'tonconnect_timestamp_skew'`.
+ * The proof timestamp is outside the 5-minute / +60s acceptance window.
+ *
+ * @example
+ * ```ts
+ * import { TxnodTonConnectTimestampSkewError } from '@txnod/sdk';
+ *
+ * try {
+ *   // SDK call that bubbles a /tonconnect/verify problem+json
+ * } catch (err) {
+ *   if (err instanceof TxnodTonConnectTimestampSkewError) {
+ *     console.error('TON Connect timestamp skew', err.request_id);
+ *   }
+ * }
+ * ```
+ */
+export declare class TxnodTonConnectTimestampSkewError extends TxnodError {
+    readonly kind: "tonconnect_timestamp_skew";
+    constructor(details: ProblemDetails);
+}
+/**
+ * Thrown when the dashboard responds with `error_code: 'tonconnect_unknown_wallet_version'`.
+ * The wallet's `walletStateInit` does not match any known TON wallet version.
+ *
+ * @example
+ * ```ts
+ * import { TxnodTonConnectUnknownWalletVersionError } from '@txnod/sdk';
+ *
+ * try {
+ *   // SDK call that bubbles a /tonconnect/verify problem+json
+ * } catch (err) {
+ *   if (err instanceof TxnodTonConnectUnknownWalletVersionError) {
+ *     console.error('TON Connect unknown wallet version', err.request_id);
+ *   }
+ * }
+ * ```
+ */
+export declare class TxnodTonConnectUnknownWalletVersionError extends TxnodError {
+    readonly kind: "tonconnect_unknown_wallet_version";
+    constructor(details: ProblemDetails);
+}
+/**
+ * Thrown when the dashboard responds with `error_code: 'tonconnect_signature_invalid'`.
+ * The Ed25519 verification of the ton_proof signature failed.
+ *
+ * @example
+ * ```ts
+ * import { TxnodTonConnectSignatureInvalidError } from '@txnod/sdk';
+ *
+ * try {
+ *   // SDK call that bubbles a /tonconnect/verify problem+json
+ * } catch (err) {
+ *   if (err instanceof TxnodTonConnectSignatureInvalidError) {
+ *     console.error('TON Connect proof rejected', err.request_id);
+ *   }
+ * }
+ * ```
+ */
+export declare class TxnodTonConnectSignatureInvalidError extends TxnodError {
+    readonly kind: "tonconnect_signature_invalid";
+    constructor(details: ProblemDetails);
+}
+/**
+ * Thrown when the dashboard responds with `error_code: 'tonconnect_network_mismatch'`.
+ * The wallet reported a chain id (`-239`/`-3`) that disagrees with the wizard's network.
+ *
+ * @example
+ * ```ts
+ * import { TxnodTonConnectNetworkMismatchError } from '@txnod/sdk';
+ *
+ * try {
+ *   // SDK call that bubbles a /tonconnect/verify problem+json
+ * } catch (err) {
+ *   if (err instanceof TxnodTonConnectNetworkMismatchError) {
+ *     console.error('TON Connect network mismatch', err.request_id);
+ *   }
+ * }
+ * ```
+ */
+export declare class TxnodTonConnectNetworkMismatchError extends TxnodError {
+    readonly kind: "tonconnect_network_mismatch";
+    constructor(details: ProblemDetails);
+}
+/**
+ * Thrown when the server responds with `error_code: 'sandbox_project_required'`.
+ * The endpoint accepts only sandbox projects and the targeted project's `kind`
+ * is `production`. Story 37.3 will surface a richer SDK surface.
+ *
+ * @example
+ * ```ts
+ * import { TxnodSandboxProjectRequiredError } from '@txnod/sdk';
+ *
+ * try {
+ *   // SDK call that targets a sandbox-only endpoint
+ * } catch (err) {
+ *   if (err instanceof TxnodSandboxProjectRequiredError) {
+ *     console.error('Sandbox-only endpoint', err.request_id);
+ *   }
+ * }
+ * ```
+ */
+export declare class TxnodSandboxProjectRequiredError extends TxnodError {
+    readonly kind: "sandbox_project_required";
+    constructor(details: ProblemDetails);
+}
+/**
+ * Thrown when the server responds with `error_code: 'production_project_required'`.
+ * The endpoint accepts only production projects and the targeted project's
+ * `kind` is `sandbox` or `testnet`.
+ *
+ * @example
+ * ```ts
+ * import { TxnodProductionProjectRequiredError } from '@txnod/sdk';
+ *
+ * try {
+ *   // SDK call that targets a production-only endpoint
+ * } catch (err) {
+ *   if (err instanceof TxnodProductionProjectRequiredError) {
+ *     console.error('Production-only endpoint', err.request_id);
+ *   }
+ * }
+ * ```
+ */
+export declare class TxnodProductionProjectRequiredError extends TxnodError {
+    readonly kind: "production_project_required";
+    constructor(details: ProblemDetails);
+}
+/**
+ * Thrown when the server responds with `error_code: 'sandbox_per_operator_cap_reached'`.
+ * The operator already has the maximum number of active sandbox projects.
+ *
+ * @example
+ * ```ts
+ * import { TxnodSandboxPerOperatorCapReachedError } from '@txnod/sdk';
+ *
+ * try {
+ *   // SDK call that creates a new sandbox project
+ * } catch (err) {
+ *   if (err instanceof TxnodSandboxPerOperatorCapReachedError) {
+ *     console.error('sandbox cap reached', err.request_id);
+ *   }
+ * }
+ * ```
+ */
+export declare class TxnodSandboxPerOperatorCapReachedError extends TxnodError {
+    readonly kind: "sandbox_per_operator_cap_reached";
+    constructor(details: ProblemDetails);
+}
+/**
+ * Thrown when the server responds with `error_code: 'sandbox_key_against_production_project'`.
+ * A sandbox API key (prefix `sk_sandbox_`) was used against a production project.
+ *
+ * @example
+ * ```ts
+ * import { TxnodSandboxKeyAgainstProductionProjectError } from '@txnod/sdk';
+ *
+ * try {
+ *   // SDK call with mixed-mode credentials
+ * } catch (err) {
+ *   if (err instanceof TxnodSandboxKeyAgainstProductionProjectError) {
+ *     console.error('cross-mode rejected', err.request_id);
+ *   }
+ * }
+ * ```
+ */
+export declare class TxnodSandboxKeyAgainstProductionProjectError extends TxnodError {
+    readonly kind: "sandbox_key_against_production_project";
+    constructor(details: ProblemDetails);
+}
+/**
+ * Thrown when the server responds with `error_code: 'production_key_against_sandbox_project'`.
+ * A production API key was used against a sandbox project.
+ *
+ * @example
+ * ```ts
+ * import { TxnodProductionKeyAgainstSandboxProjectError } from '@txnod/sdk';
+ *
+ * try {
+ *   // SDK call with mixed-mode credentials
+ * } catch (err) {
+ *   if (err instanceof TxnodProductionKeyAgainstSandboxProjectError) {
+ *     console.error('cross-mode rejected', err.request_id);
+ *   }
+ * }
+ * ```
+ */
+export declare class TxnodProductionKeyAgainstSandboxProjectError extends TxnodError {
+    readonly kind: "production_key_against_sandbox_project";
+    constructor(details: ProblemDetails);
+}
+/**
+ * Thrown when the server responds with `error_code: 'sandbox_provisioning_failed'`.
+ * The sandbox project could not be provisioned (transient or internal error).
+ *
+ * @example
+ * ```ts
+ * import { TxnodSandboxProvisioningFailedError } from '@txnod/sdk';
+ *
+ * try {
+ *   // SDK call that creates a new sandbox project
+ * } catch (err) {
+ *   if (err instanceof TxnodSandboxProvisioningFailedError) {
+ *     console.error('sandbox provisioning failed', err.request_id);
+ *   }
+ * }
+ * ```
+ */
+export declare class TxnodSandboxProvisioningFailedError extends TxnodError {
+    readonly kind: "sandbox_provisioning_failed";
+    constructor(details: ProblemDetails);
+}
+/**
+ * Thrown when the server responds with `error_code: 'sandbox_invoice_transition_invalid'`.
+ * A simulate-* call requested a state-machine transition forbidden by the
+ * invoice's current status. Story 37.3 will surface a richer SDK surface.
+ *
+ * @example
+ * ```ts
+ * import { TxnodSandboxInvoiceTransitionInvalidError } from '@txnod/sdk';
+ *
+ * try {
+ *   // SDK call into a sandbox simulate-* endpoint
+ * } catch (err) {
+ *   if (err instanceof TxnodSandboxInvoiceTransitionInvalidError) {
+ *     console.error('forbidden transition', err.request_id);
+ *   }
+ * }
+ * ```
+ */
+export declare class TxnodSandboxInvoiceTransitionInvalidError extends TxnodError {
+    readonly kind: "sandbox_invoice_transition_invalid";
+    constructor(details: ProblemDetails);
+}
+/**
+ * Thrown when the server responds with `error_code: 'sandbox_invoice_not_found'`.
+ *
+ * @example
+ * ```ts
+ * import { TxnodSandboxInvoiceNotFoundError } from '@txnod/sdk';
+ *
+ * try {
+ *   // SDK call into a sandbox simulate-* endpoint
+ * } catch (err) {
+ *   if (err instanceof TxnodSandboxInvoiceNotFoundError) {
+ *     console.error('sandbox invoice missing', err.request_id);
+ *   }
+ * }
+ * ```
+ */
+export declare class TxnodSandboxInvoiceNotFoundError extends TxnodError {
+    readonly kind: "sandbox_invoice_not_found";
+    constructor(details: ProblemDetails);
+}
+/**
+ * Thrown when the server responds with `error_code: 'sandbox_invoice_terminal'`.
+ *
+ * @example
+ * ```ts
+ * import { TxnodSandboxInvoiceTerminalError } from '@txnod/sdk';
+ *
+ * try {
+ *   // SDK call into a sandbox simulate-* endpoint
+ * } catch (err) {
+ *   if (err instanceof TxnodSandboxInvoiceTerminalError) {
+ *     console.error('invoice already terminal', err.request_id);
+ *   }
+ * }
+ * ```
+ */
+export declare class TxnodSandboxInvoiceTerminalError extends TxnodError {
+    readonly kind: "sandbox_invoice_terminal";
+    constructor(details: ProblemDetails);
+}
+/**
+ * Thrown when the server responds with `error_code: 'sandbox_rate_limit_exceeded'`.
+ *
+ * @example
+ * ```ts
+ * import { TxnodSandboxRateLimitExceededError } from '@txnod/sdk';
+ *
+ * try {
+ *   // SDK call into a sandbox simulate-* endpoint
+ * } catch (err) {
+ *   if (err instanceof TxnodSandboxRateLimitExceededError) {
+ *     console.error('sandbox rate limited', err.request_id);
+ *   }
+ * }
+ * ```
+ */
+export declare class TxnodSandboxRateLimitExceededError extends TxnodError {
+    readonly kind: "sandbox_rate_limit_exceeded";
+    constructor(details: ProblemDetails);
+}
+/**
+ * Thrown when the server responds with `error_code: 'sandbox_reset_failed'`.
+ *
+ * @example
+ * ```ts
+ * import { TxnodSandboxResetFailedError } from '@txnod/sdk';
+ *
+ * try {
+ *   // SDK call to /api/v1/sandbox/{projectId}/reset
+ * } catch (err) {
+ *   if (err instanceof TxnodSandboxResetFailedError) {
+ *     console.error('sandbox reset failed', err.request_id);
+ *   }
+ * }
+ * ```
+ */
+export declare class TxnodSandboxResetFailedError extends TxnodError {
+    readonly kind: "sandbox_reset_failed";
+    constructor(details: ProblemDetails);
+}
+/**
+ * Thrown when the server responds with `error_code: 'sandbox_delete_failed'`.
+ *
+ * @example
+ * ```ts
+ * import { TxnodSandboxDeleteFailedError } from '@txnod/sdk';
+ *
+ * try {
+ *   // SDK call to DELETE /api/v1/sandbox/{projectId}
+ * } catch (err) {
+ *   if (err instanceof TxnodSandboxDeleteFailedError) {
+ *     console.error('sandbox delete failed', err.request_id);
+ *   }
+ * }
+ * ```
+ */
+export declare class TxnodSandboxDeleteFailedError extends TxnodError {
+    readonly kind: "sandbox_delete_failed";
+    constructor(details: ProblemDetails);
+}
+/**
+ * Thrown when the server responds with `error_code: 'sandbox_active_invoice_cap_reached'`.
+ *
+ * @example
+ * ```ts
+ * import { TxnodSandboxActiveInvoiceCapReachedError } from '@txnod/sdk';
+ *
+ * try {
+ *   // SDK call into POST /api/v1/invoices for a sandbox project
+ * } catch (err) {
+ *   if (err instanceof TxnodSandboxActiveInvoiceCapReachedError) {
+ *     console.error('sandbox active-invoice cap reached', err.request_id);
+ *   }
+ * }
+ * ```
+ */
+export declare class TxnodSandboxActiveInvoiceCapReachedError extends TxnodError {
+    readonly kind: "sandbox_active_invoice_cap_reached";
+    constructor(details: ProblemDetails);
+}
+/**
+ * Thrown synchronously by the `TxnodClient` constructor when the configured
+ * `apiSecret` carries the `sk_sandbox_` prefix AND `getSdkEnv()` resolves to
+ * `'production'` AND the `iAcknowledgeRoutingRealCustomerFundsToSandboxAddresses`
+ * override is not set or `false`.
+ *
+ * The error names which signal triggered the production detection so the
+ * operator can fix the configuration source. Boot fails — no client instance
+ * is returned.
+ *
+ * @example
+ * ```ts
+ * import { TxnodClient, TxnodSandboxKeyInProductionError } from '@txnod/sdk';
+ *
+ * try {
+ *   const client = new TxnodClient({
+ *     projectId: process.env.TXNOD_PROJECT_ID!,
+ *     apiSecret: process.env.TXNOD_API_SECRET!,
+ *   });
+ *   void client;
+ * } catch (err) {
+ *   if (err instanceof TxnodSandboxKeyInProductionError) {
+ *     console.error(
+ *       'sandbox secret in production environment',
+ *       err.signal,
+ *       err.secretPrefix,
+ *     );
+ *     process.exit(1);
+ *   }
+ *   throw err;
+ * }
+ * ```
+ */
+export declare class TxnodSandboxKeyInProductionError extends TxnodError {
+    readonly kind: "sandbox_key_in_production";
+    readonly secretPrefix: 'sk_sandbox_';
+    readonly detectedEnvironment: 'production';
+    readonly signal: 'environment_option' | 'TXNOD_ENVIRONMENT' | 'NODE_ENV';
+    constructor(signal: 'environment_option' | 'TXNOD_ENVIRONMENT' | 'NODE_ENV');
+}
+/**
+ * Thrown synchronously by the `TxnodClient` constructor when the configured
+ * `apiSecret` carries the `sk_sandbox_` prefix AND `getSdkEnv()` returns
+ * `'unknown'` (no signal indicates whether the runtime is production).
+ *
+ * The fix: set the `environment` constructor option, the
+ * `TXNOD_ENVIRONMENT` env var, or `NODE_ENV` to a recognised value.
+ *
+ * @example
+ * ```ts
+ * import { TxnodClient, TxnodEnvironmentUnknownError } from '@txnod/sdk';
+ *
+ * try {
+ *   const client = new TxnodClient({
+ *     projectId: process.env.TXNOD_PROJECT_ID!,
+ *     apiSecret: process.env.TXNOD_API_SECRET!,
+ *     environment: 'non-production',
+ *   });
+ *   void client;
+ * } catch (err) {
+ *   if (err instanceof TxnodEnvironmentUnknownError) {
+ *     console.error('environment unknown for sandbox secret', err.message);
+ *     process.exit(1);
+ *   }
+ *   throw err;
+ * }
+ * ```
+ */
+export declare class TxnodEnvironmentUnknownError extends TxnodError {
+    readonly kind: "environment_unknown";
+    constructor();
+}
+/**
+ * Thrown synchronously by the `TxnodClient` constructor (and at
+ * `refreshXpubConfig()` time) when one of the configured xpubs has a
+ * testnet-shape prefix (`tpub`/`vpub`/`upub`) AND `getSdkEnv()` returns
+ * `'production'`.
+ *
+ * Carve-outs documented on `assertNoTestnetXpubsInProduction`:
+ *  - Cardano (CIP-5 hrp does not distinguish testnet at account-pubkey level —
+ *    safety lives at the address-level NetworkId byte; guard is a no-op).
+ *  - TON (no xpub concept; guard is a no-op).
+ *  - EVM mainnet/testnet `xpub` ambiguity — testnet differentiation lives in
+ *    the address checksum, not the xpub itself; only `tpub`/`vpub`/`upub`
+ *    prefixes are reliably classified as testnet.
+ *
+ * @example
+ * ```ts
+ * import { TxnodClient, TxnodSandboxXpubInProductionError } from '@txnod/sdk';
+ *
+ * try {
+ *   const client = new TxnodClient({
+ *     projectId: process.env.TXNOD_PROJECT_ID!,
+ *     apiSecret: process.env.TXNOD_API_SECRET!,
+ *   });
+ *   void client;
+ * } catch (err) {
+ *   if (err instanceof TxnodSandboxXpubInProductionError) {
+ *     console.error(
+ *       'testnet xpub in production',
+ *       err.chain,
+ *       err.xpubPrefix,
+ *     );
+ *     process.exit(1);
+ *   }
+ *   throw err;
+ * }
+ * ```
+ */
+export declare class TxnodSandboxXpubInProductionError extends TxnodError {
+    readonly kind: "sandbox_xpub_in_production";
+    readonly chain: Chain;
+    readonly xpubPrefix: string;
+    readonly detectedEnvironment: 'production';
+    constructor(chain: Chain, xpubPrefix: string);
+}
+//# sourceMappingURL=errors.d.ts.map