@pegaroute/sdk 0.0.0-stage → 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,499 @@
+import { $ as KnownErrorCode, A as toExternalStatus, B as JsonSwapExecution, C as SwapInput, Ct as Token, D as InternalSwapStatus, E as SwapTimestamps, F as EvmSwapExecution, G as UtxoSwapExecution, H as OtherDepositSwapExecution, I as ExecutionFamily, J as GetQuoteParams, K as isExecutionFamily, L as ExecutionMode, M as CosmosMsgDepositSwapExecution, N as CosmosMsgExecuteSwapExecution, O as SwapStatus, P as EvmApproval, Q as ErrorCode, R as ExecutionOfFamily, S as SwapFailure, St as ProvidersResponse, T as SwapProviderInfo, U as SerializedSwapExecution, V as NamedDepositSwapExecution, W as SwapExecution, X as QuoteRoute, Y as QuoteResponse, Z as RouteWarning, _ as ProviderStatusInfo, _t as ProviderFeeStructure, a as WebhookEvent, at as QuoteFees, b as SwapEvent, bt as ProviderTakeStructure, c as ExpectedAffiliateEntry, ct as StreamingProgress, d as TransactionsResponse, dt as ChainsResponse, et as AffiliateFeeBreakdown, f as CreateSwapParams, ft as HealthResponse, g as InstaswapSwapLiteSnapshot, gt as ProviderAffiliateFeeStructure, h as InstaswapFeeLine, ht as PingResponse, i as TransactionWebhookEventType, it as Provider, j as CosmosBankSendSwapExecution, k as isTerminalStatus, l as ListTransactionsParams, lt as TokenAmount, m as GetSwapResponse, mt as ListProvidersParams, n as TransactionWebhookData, nt as OpenOceanRouteMeta, o as WebhookStreamingProgress, ot as RefundInfo, p as CreateSwapResponse, pt as KnownProviderType, q as isExecutionMode, r as TransactionWebhookEvent, rt as PrivateSwapMode, s as CursorPagination, st as RouteInfo, t as TestWebhookEvent, tt as KnownProvider, u as Transaction, ut as Chain, v as SubmitTxHashParams, vt as ProviderHealth, w as SwapOutput, wt as TokensResponse, x as SwapEventsResponse, xt as ProviderType, y as SubmitTxHashResponse, yt as ProviderInfo, z as ExecutionOfMode } from "./index-CeY_5Z4u.js";
+//#region src/core/http.d.ts
+/** Per-call options accepted by every SDK method. */
+interface RequestOptions {
+  /** Cancels the request (and any pending retry). Cancellation is never retried. */
+  signal?: AbortSignal;
+  /** Overrides the client's `timeoutMs` for this call. */
+  timeoutMs?: number;
+}
+/** Minimal `fetch` signature the SDK needs; any standard `fetch` satisfies it. */
+type Fetch = (url: string, init: RequestInit) => Promise<Response>;
+/** Resolved client settings the HTTP layer works with (defaults already applied). */
+interface HttpClientConfig {
+  /** Integration API key, sent as the `X-API-Key` header. */
+  apiKey: string;
+  /** Base URL without a trailing slash. */
+  baseUrl: string;
+  /** Default per-request timeout in milliseconds. */
+  timeoutMs: number;
+  /** How many times a GET may be retried after the first attempt. */
+  maxRetries: number;
+  /** The `fetch` implementation used to send requests. */
+  fetch: Fetch;
+}
+/** Query string values; `undefined` entries are left out of the URL. */
+type QueryParams = Record<string, string | number | boolean | undefined>;
+/** One API call, described independently of how it is sent. */
+interface HttpRequest {
+  /** HTTP method. Only GETs are retried. */
+  method: "GET" | "POST";
+  /** Endpoint path starting with `/`, e.g. `/quote`. */
+  path: string;
+  /** Query string parameters; `undefined` values are left out. */
+  query?: QueryParams;
+  /** JSON body; serialised with `JSON.stringify`. */
+  body?: unknown;
+  /**
+   * Non-2xx statuses that still carry a normal response body, e.g. `/health` answers 503 when degraded.
+   * That body is returned (never retried) unless it isn't JSON or is an error envelope, which are handled as usual.
+   */
+  successStatuses?: number[];
+}
+/** Sends requests to the Pegaroute API: auth, timeouts, retries and error mapping. */
+declare class HttpClient {
+  #private;
+  constructor(config: HttpClientConfig);
+  /** Sends a request, retrying GETs on connection errors and on errors marked `retryable` (see `errorFromResponse`). */
+  request<T>(request: HttpRequest, options?: RequestOptions): Promise<T>;
+}
+//#endregion
+//#region src/resources/chains.d.ts
+/** Chains Pegaroute supports. Available as `pr.chains`. */
+declare class Chains {
+  #private;
+  constructor(http: HttpClient);
+  /**
+   * Lists every supported chain.
+   *
+   * @example
+   * const { chains } = await pr.chains.list();
+   */
+  list(options?: RequestOptions): Promise<ChainsResponse>;
+}
+//#endregion
+//#region src/resources/providers.d.ts
+/** Swap providers behind Pegaroute and their live status. Available as `pr.providers`. */
+declare class Providers {
+  #private;
+  constructor(http: HttpClient);
+  /**
+   * Lists the providers that are switched on, or every provider with `includeDisabled: true`.
+   *
+   * @example
+   * const { providers } = await pr.providers.list({ includeDisabled: true });
+   */
+  list(params?: ListProvidersParams, options?: RequestOptions): Promise<ProvidersResponse>;
+}
+//#endregion
+//#region src/resources/quotes.d.ts
+/** Swap quotes. Available as `pr.quotes`. */
+declare class Quotes {
+  #private;
+  constructor(http: HttpClient);
+  /**
+   * Gets routes for a swap from every available provider.
+   *
+   * Throws `BadRequestError` for invalid input or an amount too low for every provider (`AMOUNT_TOO_LOW`),
+   * and `ServiceUnavailableError` when the chain is disabled (`CHAIN_DISABLED`).
+   *
+   * @example
+   * const quote = await pr.quotes.get({ fromChain: "ETH", fromToken: "ETH", toChain: "BTC", toToken: "BTC", amount: "0.5" });
+   * const best = quote.routes[0];
+   */
+  get(params: GetQuoteParams, options?: RequestOptions): Promise<QuoteResponse>;
+}
+//#endregion
+//#region src/resources/swaps.d.ts
+/** Options for {@link Swaps.waitForCompletion}. */
+interface WaitForCompletionOptions {
+  /** Wait between polls in milliseconds. Default 10 000; at least 1 000. */
+  intervalMs?: number;
+  /**
+   * Deadline for the whole wait in milliseconds, after which `WaitTimeoutError` is thrown. Default 3 600 000 (1 hour).
+   * Each poll still uses the client's own per-request `timeoutMs`.
+   */
+  timeoutMs?: number;
+  /** Stops waiting (and cancels the poll in flight); the signal's reason is thrown. */
+  signal?: AbortSignal;
+}
+/** Swap creation and tracking. Available as `pr.swaps`. */
+declare class Swaps {
+  #private;
+  constructor(http: HttpClient);
+  /**
+   * Creates a swap and returns what the user must sign.
+   *
+   * Never retried: the HTTP client only retries GET requests, so a timeout can't create a duplicate swap.
+   *
+   * Throws `ProviderChangedError` when the quoted route is gone: retry with its `newQuote`.
+   * Throws `QuoteExpiredError` when the quote expired, and `BadRequestError` for invalid input or
+   * parameters that don't match the quote (`QUOTE_MISMATCH`).
+   *
+   * @example
+   * const swap = await pr.swaps.create({
+   *   fromChain: "ETH", fromToken: "ETH", toChain: "BTC", toToken: "BTC", amount: "0.5",
+   *   senderAddress: "0xabc…", destinationAddress: "bc1q…",
+   *   quoteId: quote.quoteId, routeProvider: quote.routes[0].provider,
+   * });
+   * // send swap.execution to the frontend for signing
+   */
+  create(params: CreateSwapParams, options?: RequestOptions): Promise<CreateSwapResponse>;
+  /**
+   * Gets a swap's current state. Throws `NotFoundError` for an unknown ID.
+   *
+   * @example
+   * const swap = await pr.swaps.get(transactionId);
+   * if (swap.status === "fail") console.log(swap.error?.userMessage, swap.refund);
+   */
+  get(transactionId: string, options?: RequestOptions): Promise<GetSwapResponse>;
+  /**
+   * Polls `swaps.get` until the swap reaches a terminal status (`success` or `fail`), then returns it.
+   * Webhooks are the better fit for production; use this as a fallback or in scripts.
+   *
+   * Throws `WaitTimeoutError` (with the last swap seen) if `timeoutMs` passes first. A failing poll is thrown
+   * unchanged, after `swaps.get`'s own retries.
+   *
+   * @example
+   * const final = await pr.swaps.waitForCompletion(swap.transactionId);
+   * if (final.status === "fail") console.log(final.error?.userMessage, final.refund);
+   */
+  waitForCompletion(transactionId: string, options?: WaitForCompletionOptions): Promise<GetSwapResponse>;
+  /**
+   * Gets a swap's audit log: every internal status change, oldest first.
+   *
+   * @example
+   * const { events } = await pr.swaps.events(transactionId);
+   */
+  events(transactionId: string, options?: RequestOptions): Promise<SwapEventsResponse>;
+  /**
+   * Reports the hash of the source transaction the user broadcast, so Pegaroute starts tracking it.
+   * Returns the internal status `"submitted"`.
+   *
+   * @example
+   * await pr.swaps.submitTxHash(swap.transactionId, { txHash });
+   */
+  submitTxHash(transactionId: string, params: SubmitTxHashParams, options?: RequestOptions): Promise<SubmitTxHashResponse>;
+}
+//#endregion
+//#region src/resources/tokens.d.ts
+/** Tokens Pegaroute recognises on each chain. Available as `pr.tokens`. */
+declare class Tokens {
+  #private;
+  constructor(http: HttpClient);
+  /**
+   * Lists the tokens on one chain. Throws `BadRequestError` (`VALIDATION_ERROR`) for an unknown chain.
+   *
+   * @param chain A chain ID from `chains.list()`; case is ignored.
+   *
+   * @example
+   * const { tokens } = await pr.tokens.list("SOL");
+   */
+  list(chain: string, options?: RequestOptions): Promise<TokensResponse>;
+}
+//#endregion
+//#region src/core/pagination.d.ts
+/** How a {@link PagePromise} fetches pages and reads them. */
+interface PagePromiseConfig<Page, Item> {
+  /** Fetches the page that starts after `cursor`; `undefined` for the first page. */
+  fetchPage: (cursor: string | undefined) => Promise<Page>;
+  /** Cursor to start from, when the caller passed one. */
+  firstCursor?: string | undefined;
+  /** The items on a page. */
+  items: (page: Page) => Item[];
+  /** The cursor of the next page, or `null` when this is the last page. */
+  nextCursor: (page: Page) => string | null;
+}
+/**
+ * The result of a cursor-paginated list: await it for one page, or iterate it for every item.
+ *
+ * Nothing is requested until it is awaited or iterated. Awaiting and then iterating the same
+ * `PagePromise` fetches the first page only once.
+ *
+ * `.catch()` and `.finally()` only cover the first page. When iterating, later pages are fetched inside
+ * the loop, so wrap the loop in `try`/`catch` to handle a failure on any page.
+ *
+ * @example
+ * // One page, as the API returns it
+ * const page = await pr.transactions.list({ count: 50 });
+ *
+ * // Every item, fetching the next page as needed
+ * try {
+ *   for await (const tx of pr.transactions.list()) console.log(tx.id);
+ * } catch (e) {
+ *   // any page failed
+ * }
+ */
+declare class PagePromise<Page, Item> implements Promise<Page>, AsyncIterable<Item> {
+  #private;
+  /** Shown by `Object.prototype.toString`, like `[object Promise]` for a real promise. */
+  readonly [Symbol.toStringTag]: string;
+  constructor(config: PagePromiseConfig<Page, Item>);
+  /** Resolves to the first page, so `await` works. */
+  then<TResult1 = Page, TResult2 = never>(onfulfilled?: ((page: Page) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
+  /** Handles a failure to fetch the first page, like `Promise.prototype.catch`. */
+  catch<TResult = never>(onrejected?: ((reason: unknown) => TResult | PromiseLike<TResult>) | null): Promise<Page | TResult>;
+  /** Runs once the first page is fetched or has failed, like `Promise.prototype.finally`. */
+  finally(onfinally?: (() => void) | null): Promise<Page>;
+  /** Yields every item of every page, fetching each page when the previous one is used up. */
+  [Symbol.asyncIterator](): AsyncIterator<Item>;
+}
+//#endregion
+//#region src/resources/transactions.d.ts
+/** Swap history for your integration. Available as `pr.transactions`. */
+declare class Transactions {
+  #private;
+  constructor(http: HttpClient);
+  /**
+   * Lists your swaps, newest first. Await it for one page, or iterate it with `for await` to walk every page.
+   *
+   * @example
+   * // One page
+   * const { transactions, pagination } = await pr.transactions.list({ count: 50 });
+   *
+   * // Every failed swap, across pages
+   * for await (const tx of pr.transactions.list({ status: "failed" })) {
+   *   console.log(tx.id, tx.error?.userMessage);
+   * }
+   */
+  list(params?: ListTransactionsParams, options?: RequestOptions): PagePromise<TransactionsResponse, Transaction>;
+}
+//#endregion
+//#region src/client.d.ts
+/** Settings for a {@link Pegaroute} client. */
+interface PegarouteOptions {
+  /** Integration API key. Keep it server-side. */
+  apiKey: string;
+  /** Pegaroute API base URL, e.g. `https://api.pegaroute.com`. */
+  baseUrl: string;
+  /** Per-request timeout. Default 30 000 ms. */
+  timeoutMs?: number;
+  /** Retries for GET requests on connection errors and on errors marked `retryable` (e.g. 429, 503). Default 2. */
+  maxRetries?: number;
+  /** Custom `fetch` implementation (tests, proxies). Default `globalThis.fetch`. */
+  fetch?: Fetch;
+}
+/** Pegaroute API client. Server-side only: it holds your API key. */
+export declare class Pegaroute {
+  #private;
+  /** Supported chains. */
+  readonly chains: Chains;
+  /** Supported tokens per chain. */
+  readonly tokens: Tokens;
+  /** Swap providers and their status. */
+  readonly providers: Providers;
+  /** Swap quotes. */
+  readonly quotes: Quotes;
+  /** Swap creation and tracking. */
+  readonly swaps: Swaps;
+  /** Swap history for your integration. */
+  readonly transactions: Transactions;
+  constructor(options: PegarouteOptions);
+  /**
+   * Returns Pegaroute's health: database, write-ahead log and every provider.
+   *
+   * Unlike other methods, this does not throw when Pegaroute answers 503 because its database is down:
+   * it returns the body with `status: "degraded"` instead. Other failures (401, timeouts, …) still throw.
+   *
+   * @example
+   * const health = await pr.health();
+   * if (health.status === "degraded") alert(health);
+   */
+  health(options?: RequestOptions): Promise<HealthResponse>;
+  /**
+   * Checks that Pegaroute is reachable.
+   *
+   * @example
+   * await pr.ping(); // { response: "pong", timestamp: "…", service: "pegaroute" }
+   */
+  ping(options?: RequestOptions): Promise<PingResponse>;
+}
+//#endregion
+//#region src/core/errors.d.ts
+/**
+ * The data needed to create a {@link PegarouteError} ("Init" = initialisation).
+ *
+ * Passed as one object with named fields instead of many positional arguments, so fields can't be
+ * mixed up. Only the SDK creates these errors; integrators just read the same fields on the error they catch.
+ *
+ * @example
+ * new QuoteExpiredError({ code: "QUOTE_EXPIRED", status: 410, message: "…", userMessage: "…", retryable: false });
+ */
+interface PegarouteErrorInit {
+  /** Machine-readable error code, e.g. `QUOTE_EXPIRED`. */
+  code: ErrorCode;
+  /** HTTP status, or `null` when no response was received. */
+  status: number | null;
+  /** Technical message for developers and logs. */
+  message: string;
+  /** Message that is safe to show to end users. */
+  userMessage: string;
+  /** Whether the same request may succeed if tried again. */
+  retryable: boolean;
+  /** Seconds the server asked us to wait before retrying, if any. */
+  retryAfterSeconds?: number | null;
+  /** Provider that caused the error, when the failure is provider-specific. */
+  provider?: string;
+  /** Extra context from the server (or the SDK) about the failure. */
+  details?: Record<string, unknown>;
+  /** The underlying error, e.g. the network failure behind a `ConnectionError`. */
+  cause?: unknown;
+}
+/** Base class for every error the SDK throws after a request is made. */
+export declare class PegarouteError extends Error {
+  /** Machine-readable error code, e.g. `QUOTE_EXPIRED`. */
+  readonly code: ErrorCode;
+  /** HTTP status, or `null` when no response was received. */
+  readonly status: number | null;
+  /** Safe to show to end users. */
+  readonly userMessage: string;
+  /**
+   * Whether the same request may succeed if tried again.
+   * The SDK retries such GETs itself, up to `maxRetries` times, unless the server asks to wait more than 60 seconds.
+   * POSTs are never retried, so retrying one is up to you.
+   */
+  readonly retryable: boolean;
+  /** Seconds the server asked us to wait before retrying, or `null` when it didn't say. */
+  readonly retryAfterSeconds: number | null;
+  /** Provider that caused the error, when the failure is provider-specific. */
+  readonly provider?: string;
+  /** Extra context from the server (or the SDK) about the failure. */
+  readonly details?: Record<string, unknown>;
+  constructor(init: PegarouteErrorInit);
+}
+/** The request is invalid, e.g. a bad address, amount or unsupported pair (HTTP 400). */
+export declare class BadRequestError extends PegarouteError {}
+/** The API key is missing or invalid (HTTP 401). */
+export declare class AuthenticationError extends PegarouteError {}
+/** The API key isn't allowed to make this request (HTTP 403). */
+export declare class PermissionDeniedError extends PegarouteError {}
+/** The resource doesn't exist, e.g. an unknown swap ID (HTTP 404). */
+export declare class NotFoundError extends PegarouteError {}
+/** The request conflicts with the current state (HTTP 409). See {@link ProviderChangedError} for a changed provider. */
+export declare class ConflictError extends PegarouteError {}
+/** The data needed to create a {@link ProviderChangedError}: the base fields plus the refreshed quote. */
+interface ProviderChangedErrorInit extends PegarouteErrorInit {
+  /** The refreshed quote to review and retry with. */
+  newQuote: QuoteResponse;
+  /** The provider that was quoted (or requested with `routeProvider`). */
+  originalProvider: string;
+  /** The best provider under the refreshed quote. */
+  newProvider: string;
+}
+/**
+ * The quoted route is no longer available, so Pegaroute quoted again (HTTP 409, `PROVIDER_CHANGED`).
+ * The original `quoteId` is used up: show the user `newQuote` and call `swaps.create` again with its `quoteId`.
+ *
+ * @example
+ * catch (e) {
+ *   if (e instanceof ProviderChangedError) retryWith(e.newQuote);
+ * }
+ */
+export declare class ProviderChangedError extends ConflictError {
+  /** The refreshed quote to review and retry with. */
+  readonly newQuote: QuoteResponse;
+  /** The provider that was quoted (or requested with `routeProvider`). */
+  readonly originalProvider: string;
+  /** The best provider under the refreshed quote. */
+  readonly newProvider: string;
+  constructor(init: ProviderChangedErrorInit);
+}
+/** The quote is no longer valid; request a new one. */
+export declare class QuoteExpiredError extends PegarouteError {}
+/** The request is well-formed but can't be carried out, e.g. the memo is too long (HTTP 422). */
+export declare class UnprocessableEntityError extends PegarouteError {}
+/** Too many requests (HTTP 429). `retryAfterSeconds` says how long to wait, when the server sends it. */
+export declare class RateLimitError extends PegarouteError {}
+/** A chain is halted or disabled, or a provider is down. */
+export declare class ServiceUnavailableError extends PegarouteError {}
+/** Pegaroute, a provider or a gateway in front of it failed (HTTP 500, 502, 504 or another 5xx except 503). */
+export declare class InternalServerError extends PegarouteError {}
+/**
+ * No complete response was received: the connection failed (DNS, TCP, TLS, …) or dropped mid-response.
+ * `status` is `null` unless the failure happened while reading the body.
+ */
+export declare class ConnectionError extends PegarouteError {}
+/** The request did not complete within the configured timeout. */
+export declare class TimeoutError extends ConnectionError {}
+/** The data needed to create a {@link WaitTimeoutError}: the base fields plus the last swap seen. */
+interface WaitTimeoutErrorInit extends PegarouteErrorInit {
+  /** The most recent successful poll, or `null` if the deadline passed before the first one returned. */
+  lastSwap: GetSwapResponse | null;
+}
+/**
+ * `swaps.waitForCompletion` reached its `timeoutMs` before the swap reached a terminal status (code `WAIT_TIMEOUT`).
+ *
+ * The swap itself didn't fail: it may still finish, so check it again later (or wait for its webhook).
+ * Not a `TimeoutError`, which means a single HTTP request timed out.
+ *
+ * @example
+ * catch (e) {
+ *   if (e instanceof WaitTimeoutError) console.log("still", e.lastSwap?.status);
+ * }
+ */
+export declare class WaitTimeoutError extends PegarouteError {
+  /** The most recent successful poll, or `null` if the deadline passed before the first one returned. */
+  readonly lastSwap: GetSwapResponse | null;
+  constructor(init: WaitTimeoutErrorInit);
+}
+//#endregion
+//#region src/webhooks.d.ts
+/** Why {@link verifyWebhook} rejected a delivery. */
+type WebhookVerificationFailure = "missing_signature" | "invalid_signature" | "invalid_payload";
+/**
+ * A webhook delivery failed verification: don't trust its body. Answer with a 4xx (e.g. 401).
+ *
+ * Not a `PegarouteError`: no API request was made, so its HTTP fields wouldn't mean anything.
+ */
+export declare class WebhookVerificationError extends Error {
+  /**
+   * What was wrong:
+   * - `missing_signature`: no `X-Pegasus-Signature` header.
+   * - `invalid_signature`: the signature doesn't match the body and secret (wrong secret, altered body, or the
+   *   body was re-serialised instead of passed raw).
+   * - `invalid_payload`: the signature matched, but the body isn't a JSON object.
+   */
+  readonly reason: WebhookVerificationFailure;
+  constructor(reason: WebhookVerificationFailure, message: string, options?: ErrorOptions);
+}
+/** What {@link verifyWebhook} needs from a delivery. */
+interface VerifyWebhookParams {
+  /**
+   * The request body exactly as received: the signature covers these bytes, so parse it only afterwards.
+   * A Node `Buffer` is a `Uint8Array`, so it works as-is.
+   */
+  rawBody: string | Uint8Array;
+  /**
+   * The `X-Pegasus-Signature` header. Typed loosely so header values pass straight through:
+   * `req.headers["x-pegasus-signature"]` (Node/Express) or `request.headers.get("x-pegasus-signature")` (fetch).
+   */
+  signature: string | string[] | null | undefined;
+  /** Your integration's webhook secret: the full `whsec_…` value from the Pegaroute UI. */
+  secret: string;
+}
+/**
+ * Checks that a webhook came from Pegaroute and returns its typed event.
+ *
+ * The signature is an HMAC-SHA256 of the raw body, keyed with your webhook secret. Delivery is at-least-once, so
+ * the same event can arrive more than once: make handlers idempotent.
+ *
+ * The signature proves who sent the body, not when: it has no timestamp, and events carry no ID to deduplicate on,
+ * so anyone who obtains a delivery can send it again later and it still verifies. Treat an event as a hint and
+ * confirm with `swaps.get` before acting on funds.
+ *
+ * Throws `WebhookVerificationError` when the delivery can't be trusted, and `TypeError` for a coding mistake
+ * (`secret` missing, or `signature` neither a string nor an array).
+ *
+ * @example
+ * app.post("/webhooks/pegaroute", express.raw({ type: "application/json" }), async (req, res) => {
+ *   try {
+ *     const event = await verifyWebhook({
+ *       rawBody: req.body,
+ *       signature: req.headers["x-pegasus-signature"],
+ *       secret: process.env.PEGAROUTE_WEBHOOK_SECRET!,
+ *     });
+ *     if (event.event === "transaction.completed") {
+ *       // The event may be a replay: confirm the current state before acting on funds.
+ *       const swap = await pr.swaps.get(event.data.transactionId);
+ *       if (swap.status === "success") await markPaid(swap.transactionId); // idempotent
+ *     }
+ *     res.sendStatus(200);
+ *   } catch (e) {
+ *     if (e instanceof WebhookVerificationError) return res.sendStatus(401);
+ *     throw e;
+ *   }
+ * });
+ */
+export declare function verifyWebhook(params: VerifyWebhookParams): Promise<WebhookEvent>;
+//#endregion
+export { type AffiliateFeeBreakdown, type Chain, type ChainsResponse, type CosmosBankSendSwapExecution, type CosmosMsgDepositSwapExecution, type CosmosMsgExecuteSwapExecution, type CreateSwapParams, type CreateSwapResponse, type CursorPagination, type ErrorCode, type EvmApproval, type EvmSwapExecution, type ExecutionFamily, type ExecutionMode, type ExecutionOfFamily, type ExecutionOfMode, type ExpectedAffiliateEntry, type Fetch, type GetQuoteParams, type GetSwapResponse, type HealthResponse, type InstaswapFeeLine, type InstaswapSwapLiteSnapshot, type InternalSwapStatus, type JsonSwapExecution, type KnownErrorCode, type KnownProvider, type KnownProviderType, type ListProvidersParams, type ListTransactionsParams, type NamedDepositSwapExecution, type OpenOceanRouteMeta, type OtherDepositSwapExecution, type PagePromise, type PegarouteOptions, type PingResponse, type PrivateSwapMode, type Provider, type ProviderAffiliateFeeStructure, type ProviderFeeStructure, type ProviderHealth, type ProviderInfo, type ProviderStatusInfo, type ProviderTakeStructure, type ProviderType, type ProvidersResponse, type QuoteFees, type QuoteResponse, type QuoteRoute, type RefundInfo, type RequestOptions, type RouteInfo, type RouteWarning, type SerializedSwapExecution, type StreamingProgress, type SubmitTxHashParams, type SubmitTxHashResponse, type SwapEvent, type SwapEventsResponse, type SwapExecution, type SwapFailure, type SwapInput, type SwapOutput, type SwapProviderInfo, type SwapStatus, type SwapTimestamps, type TestWebhookEvent, type Token, type TokenAmount, type TokensResponse, type Transaction, type TransactionWebhookData, type TransactionWebhookEvent, type TransactionWebhookEventType, type TransactionsResponse, type UtxoSwapExecution, type VerifyWebhookParams, type WaitForCompletionOptions, type WebhookEvent, type WebhookStreamingProgress, type WebhookVerificationFailure, isExecutionFamily, isExecutionMode, isTerminalStatus, toExternalStatus };