@webhooks-cc/sdk 0.5.0 → 1.0.0

package/dist/diff-Dn4j4B_n.d.ts

@@ -0,0 +1,701 @@
+/**
+ * A webhook endpoint that captures incoming HTTP requests.
+ * Create endpoints via the dashboard or SDK to receive webhooks.
+ */
+interface Endpoint {
+    /** Unique identifier for this endpoint */
+    id: string;
+    /** URL-safe identifier used in webhook URLs (/w/{slug}) */
+    slug: string;
+    /** Display name for the endpoint */
+    name?: string;
+    /** Full URL where webhooks should be sent (undefined if server is misconfigured) */
+    url?: string;
+    /** Whether the endpoint auto-expires and may be cleaned up automatically */
+    isEphemeral?: boolean;
+    /** Unix timestamp (ms) when the endpoint expires, if ephemeral */
+    expiresAt?: number;
+    /** Unix timestamp (ms) when the endpoint was created */
+    createdAt: number;
+}
+/** Mock response returned by the receiver instead of the default 200 OK. */
+interface MockResponse {
+    /** HTTP status code (100-599) */
+    status: number;
+    /** Raw response body */
+    body: string;
+    /** Response headers */
+    headers: Record<string, string>;
+}
+/**
+ * A captured webhook request with full HTTP details.
+ * Stored when a webhook arrives at an endpoint.
+ */
+interface Request {
+    /** Unique identifier for this request */
+    id: string;
+    /** Endpoint that received this request */
+    endpointId: string;
+    /** HTTP method (GET, POST, PUT, etc.) */
+    method: string;
+    /** Request path after the endpoint slug */
+    path: string;
+    /** HTTP headers from the original request */
+    headers: Record<string, string>;
+    /** Request body, if present */
+    body?: string;
+    /** URL query parameters */
+    queryParams: Record<string, string>;
+    /** Content-Type header value, if present */
+    contentType?: string;
+    /** Client IP address */
+    ip: string;
+    /** Request body size in bytes */
+    size: number;
+    /** Unix timestamp (ms) when the request arrived */
+    receivedAt: number;
+}
+/**
+ * A retained request returned from ClickHouse-backed search.
+ * The id is synthetic and is not compatible with requests.get()/replay().
+ */
+interface SearchResult {
+    /** Synthetic identifier derived from retained request contents */
+    id: string;
+    /** Endpoint slug that received this request */
+    slug: string;
+    /** HTTP method (GET, POST, PUT, etc.) */
+    method: string;
+    /** Request path after the endpoint slug */
+    path: string;
+    /** HTTP headers from the original request */
+    headers: Record<string, string>;
+    /** Request body, if present */
+    body?: string;
+    /** URL query parameters */
+    queryParams: Record<string, string>;
+    /** Content-Type header value, if present */
+    contentType?: string;
+    /** Client IP address */
+    ip: string;
+    /** Request body size in bytes */
+    size: number;
+    /** Unix timestamp (ms) when the request arrived */
+    receivedAt: number;
+}
+/** User-level request usage and quota information. */
+interface UsageInfo {
+    /** Requests consumed in the current billing window */
+    used: number;
+    /** Total request quota for the current billing window */
+    limit: number;
+    /** Remaining requests before quota is exhausted */
+    remaining: number;
+    /** Current subscription plan */
+    plan: "free" | "pro";
+    /** End of the current billing window, if active */
+    periodEnd: number | null;
+}
+/**
+ * Options for creating a new endpoint.
+ */
+interface CreateEndpointOptions {
+    /** Display name for the endpoint */
+    name?: string;
+    /** Whether the endpoint should auto-expire */
+    ephemeral?: boolean;
+    /** Relative expiry duration like "12h" or "7d"; implies ephemeral */
+    expiresIn?: number | string;
+    /** Optional mock response to configure at creation time */
+    mockResponse?: MockResponse;
+}
+/**
+ * Options for updating an existing endpoint.
+ */
+interface UpdateEndpointOptions {
+    /** New display name */
+    name?: string;
+    /** Mock response config, or null to clear */
+    mockResponse?: MockResponse | null;
+}
+/**
+ * Options for sending a test webhook to an endpoint.
+ */
+interface SendOptions {
+    /** HTTP method (default: "POST") */
+    method?: string;
+    /** HTTP headers to include */
+    headers?: Record<string, string>;
+    /** Request body (will be JSON-serialized if not a string) */
+    body?: unknown;
+}
+type TemplateProvider = "stripe" | "github" | "shopify" | "twilio" | "slack" | "paddle" | "linear" | "standard-webhooks";
+/** Static metadata describing a supported template provider. */
+interface TemplateProviderInfo {
+    /** Provider identifier used by sendTemplate()/sendTo() */
+    provider: TemplateProvider;
+    /** Supported provider-specific template presets */
+    templates: readonly string[];
+    /** Default template preset used when template is omitted */
+    defaultTemplate?: string;
+    /** Whether this provider requires a shared secret for signing */
+    secretRequired: boolean;
+    /** Header that carries the provider signature */
+    signatureHeader?: string;
+    /** Signature algorithm used for request signing */
+    signatureAlgorithm?: string;
+}
+/**
+ * Options for sending a provider template webhook with signed headers.
+ */
+interface SendTemplateOptions {
+    /** Provider template to use */
+    provider: TemplateProvider;
+    /** Provider-specific template preset (uses provider default if omitted) */
+    template?: string;
+    /** Shared secret used for provider signature generation */
+    secret: string;
+    /** Provider event/topic name (provider default used if omitted) */
+    event?: string;
+    /** HTTP method override (default: "POST") */
+    method?: string;
+    /** Additional headers merged after template headers */
+    headers?: Record<string, string>;
+    /** Body override; if omitted a provider-specific template body is generated */
+    body?: unknown;
+    /** Unix timestamp (seconds) override for deterministic signatures in tests */
+    timestamp?: number;
+}
+/**
+ * Options for listing captured requests.
+ */
+interface ListRequestsOptions {
+    /** Maximum number of requests to return */
+    limit?: number;
+    /** Only return requests received after this timestamp (ms) */
+    since?: number;
+}
+/** Cursor-based paginated result. */
+interface PaginatedResult<T> {
+    /** Page items for this fetch */
+    items: T[];
+    /** Cursor to pass to the next page fetch */
+    cursor?: string;
+    /** Whether another page is available */
+    hasMore: boolean;
+}
+/** Options for cursor-based request pagination. */
+interface ListPaginatedRequestsOptions {
+    /** Maximum number of requests to return */
+    limit?: number;
+    /** Opaque cursor from a previous page */
+    cursor?: string;
+}
+/**
+ * Options for clearing captured requests from an endpoint.
+ */
+interface ClearRequestsOptions {
+    /** Only delete requests received before this timestamp (ms) or relative duration */
+    before?: number | string;
+}
+/**
+ * Filters for retained request search/count.
+ * String timestamps may be absolute milliseconds ("1700000000000") or relative durations ("1h", "7d").
+ */
+interface SearchFilters {
+    /** Restrict results to a single endpoint slug */
+    slug?: string;
+    /** Restrict results to a specific HTTP method */
+    method?: string;
+    /** Free-text substring search across path, body, and headers */
+    q?: string;
+    /** Lower bound for receivedAt (absolute ms or relative duration) */
+    from?: number | string;
+    /** Upper bound for receivedAt (absolute ms or relative duration) */
+    to?: number | string;
+    /** Maximum number of results to return */
+    limit?: number;
+    /** Result offset for pagination */
+    offset?: number;
+    /** Result ordering by receivedAt */
+    order?: "asc" | "desc";
+}
+/**
+ * Options for waitFor() polling behavior.
+ */
+interface WaitForOptions {
+    /** Maximum time to wait (ms or duration string like "30s", "5m") (default: 30000) */
+    timeout?: number | string;
+    /** Interval between polls (ms or duration string) (default: 500, min: 10, max: 60000) */
+    pollInterval?: number | string;
+    /** Filter function to match specific requests */
+    match?: (request: Request) => boolean;
+}
+/** Options for waitForAll() multi-request collection. */
+interface WaitForAllOptions extends WaitForOptions {
+    /** Number of matching requests to collect before returning */
+    count: number;
+}
+/**
+ * Options for subscribe() SSE streaming.
+ */
+interface SubscribeOptions {
+    /** AbortSignal to cancel the subscription */
+    signal?: AbortSignal;
+    /** Maximum time to stream (ms or duration string like "30m") */
+    timeout?: number | string;
+    /** Automatically reconnect when the SSE stream ends unexpectedly */
+    reconnect?: boolean;
+    /** Maximum reconnect attempts before giving up (default: 5) */
+    maxReconnectAttempts?: number;
+    /** Base backoff delay between reconnects */
+    reconnectBackoffMs?: number | string;
+    /** Callback invoked before each reconnect attempt */
+    onReconnect?: (attempt: number) => void;
+}
+/** Info passed to the onRequest hook before a request is sent. */
+interface RequestHookInfo {
+    method: string;
+    url: string;
+}
+/** Info passed to the onResponse hook after a successful response. */
+interface ResponseHookInfo {
+    method: string;
+    url: string;
+    status: number;
+    durationMs: number;
+}
+/** Info passed to the onError hook when a request fails. */
+interface ErrorHookInfo {
+    method: string;
+    url: string;
+    error: Error;
+    durationMs: number;
+}
+/**
+ * Lifecycle hooks for observability and telemetry integration.
+ * All hooks are optional and are called synchronously (fire-and-forget).
+ */
+interface ClientHooks {
+    onRequest?: (info: RequestHookInfo) => void;
+    onResponse?: (info: ResponseHookInfo) => void;
+    onError?: (info: ErrorHookInfo) => void;
+}
+/** Retry configuration for transient API failures. */
+interface RetryOptions {
+    /** Total attempts including the initial request */
+    maxAttempts?: number;
+    /** Base backoff delay in milliseconds */
+    backoffMs?: number;
+    /** HTTP status codes that should be retried */
+    retryOn?: number[];
+}
+/**
+ * Configuration options for the WebhooksCC client.
+ */
+interface ClientOptions {
+    /** API key for authentication (format: whcc_...) */
+    apiKey: string;
+    /** Base URL for the API (default: https://webhooks.cc) */
+    baseUrl?: string;
+    /** Base URL for sending webhooks (default: https://go.webhooks.cc) */
+    webhookUrl?: string;
+    /** Request timeout in milliseconds (default: 30000) */
+    timeout?: number;
+    /** Retry policy for transient API failures */
+    retry?: RetryOptions;
+    /** Lifecycle hooks for observability */
+    hooks?: ClientHooks;
+}
+/** Description of a single SDK operation. */
+interface OperationDescription {
+    description: string;
+    params: Record<string, string>;
+}
+/**
+ * Options for sending a webhook directly to an arbitrary URL.
+ * Supports optional provider signing (Standard Webhooks, Stripe, etc.).
+ */
+interface SendToOptions {
+    /** Provider template for signing (optional). When set, secret is required. */
+    provider?: TemplateProvider;
+    /** Provider-specific template preset (e.g. "checkout.session.completed" for Stripe) */
+    template?: string;
+    /** Secret for provider signature generation (required when provider is set) */
+    secret?: string;
+    /** Event name for provider headers */
+    event?: string;
+    /** HTTP method (default: "POST") */
+    method?: string;
+    /** HTTP headers to include */
+    headers?: Record<string, string>;
+    /** Request body (will be JSON-serialized if not a string) */
+    body?: unknown;
+    /** Unix timestamp (seconds) override for deterministic signatures in tests */
+    timestamp?: number;
+}
+/** Result returned by verifySignature(). */
+interface SignatureVerificationResult {
+    /** Whether the computed signature matched the provided signature header(s) */
+    valid: boolean;
+}
+/** Providers supported by verifySignature(). */
+type VerifyProvider = TemplateProvider | "discord";
+/**
+ * Options for verifying a captured webhook signature.
+ * For Twilio, `url` is required because the signature covers the full webhook URL.
+ */
+type VerifySignatureOptions = {
+    /** Provider whose signature format should be verified */
+    provider: Exclude<VerifyProvider, "discord">;
+    /** Shared secret used by the provider when signing the webhook */
+    secret: string;
+    /** Full signed URL (required for Twilio verification) */
+    url?: string;
+} | {
+    /** Discord interaction verification */
+    provider: "discord";
+    /** Discord application public key (hex) */
+    publicKey: string;
+};
+/** Value type returned when parsing form-encoded request bodies. */
+type FormBodyValue = string | string[];
+/** Parsed application/x-www-form-urlencoded body. */
+type ParsedFormBody = Record<string, FormBodyValue>;
+/** Result from parseBody() based on content-type detection. */
+type ParsedBody = unknown | ParsedFormBody | string | undefined;
+/** Options for bulk request export. */
+interface ExportRequestsOptions {
+    /** Output format */
+    format: "har" | "curl";
+    /** Maximum number of requests to export */
+    limit?: number;
+    /** Only include requests received after this timestamp (ms) */
+    since?: number;
+}
+/** HAR header entry. */
+interface HarHeader {
+    name: string;
+    value: string;
+}
+/** HAR query parameter entry. */
+interface HarQueryParam {
+    name: string;
+    value: string;
+}
+/** HAR request body metadata. */
+interface HarPostData {
+    mimeType: string;
+    text: string;
+}
+/** HAR request object. */
+interface HarRequest {
+    method: string;
+    url: string;
+    httpVersion: string;
+    headers: HarHeader[];
+    queryString: HarQueryParam[];
+    headersSize: number;
+    bodySize: number;
+    postData?: HarPostData;
+}
+/** HAR response object. */
+interface HarResponse {
+    status: number;
+    statusText: string;
+    httpVersion: string;
+    headers: HarHeader[];
+    cookies: [];
+    content: {
+        size: number;
+        mimeType: string;
+        text?: string;
+    };
+    redirectURL: string;
+    headersSize: number;
+    bodySize: number;
+}
+/** HAR entry for a captured request. */
+interface HarEntry {
+    startedDateTime: string;
+    time: number;
+    request: HarRequest;
+    response: HarResponse;
+    cache: Record<string, never>;
+    timings: {
+        send: number;
+        wait: number;
+        receive: number;
+    };
+}
+/** HAR export archive. */
+interface HarExport {
+    log: {
+        version: "1.2";
+        creator: {
+            name: string;
+            version: string;
+        };
+        entries: HarEntry[];
+    };
+}
+/** cURL export output. */
+type CurlExport = string[];
+/** Union returned by requests.export(). */
+type RequestsExport = HarExport | CurlExport;
+/** Self-describing schema returned by client.describe(). */
+interface SDKDescription {
+    version: string;
+    endpoints: Record<string, OperationDescription>;
+    templates: Record<string, OperationDescription>;
+    usage: OperationDescription;
+    sendTo: OperationDescription;
+    buildRequest: OperationDescription;
+    flow: OperationDescription;
+    requests: Record<string, OperationDescription>;
+}
+
+/**
+ * Base error class for all webhooks.cc SDK errors.
+ * Extends the standard Error with an HTTP status code.
+ */
+declare class WebhooksCCError extends Error {
+    readonly statusCode: number;
+    constructor(statusCode: number, message: string);
+}
+/** Thrown when the API key is invalid or missing (401). */
+declare class UnauthorizedError extends WebhooksCCError {
+    constructor(message?: string);
+}
+/** Thrown when the requested resource does not exist (404). */
+declare class NotFoundError extends WebhooksCCError {
+    constructor(message?: string);
+}
+/** Thrown when the request times out. */
+declare class TimeoutError extends WebhooksCCError {
+    constructor(timeoutMs: number);
+}
+/** Thrown when the API returns 429 Too Many Requests. */
+declare class RateLimitError extends WebhooksCCError {
+    /** Seconds until the rate limit resets, if provided by the server. */
+    readonly retryAfter?: number;
+    constructor(retryAfter?: number);
+}
+
+interface FlowClient {
+    endpoints: {
+        create(options?: CreateEndpointOptions): Promise<Endpoint>;
+        update(slug: string, options: {
+            name?: string;
+            mockResponse?: MockResponse | null;
+        }): Promise<Endpoint>;
+        delete(slug: string): Promise<void>;
+        send(slug: string, options?: SendOptions): Promise<Response>;
+        sendTemplate(slug: string, options: SendTemplateOptions): Promise<Response>;
+    };
+    requests: {
+        waitFor(slug: string, options?: WaitForOptions): Promise<Request>;
+        replay(requestId: string, targetUrl: string): Promise<Response>;
+    };
+}
+type WebhookFlowVerifyOptions = {
+    provider: Exclude<VerifySignatureOptions["provider"], "discord">;
+    secret: string;
+    /**
+     * Signed URL override.
+     * For Twilio, the endpoint URL is used automatically when omitted.
+     */
+    url?: string | ((endpoint: Endpoint, request: Request) => string);
+} | {
+    provider: "discord";
+    publicKey: string;
+    url?: string | ((endpoint: Endpoint, request: Request) => string);
+};
+interface WebhookFlowResult {
+    endpoint: Endpoint;
+    request?: Request;
+    verification?: SignatureVerificationResult;
+    replayResponse?: Response;
+    cleanedUp: boolean;
+}
+declare class WebhookFlowBuilder {
+    private readonly client;
+    private createOptions;
+    private mockResponse;
+    private sendStep;
+    private waitOptions;
+    private verificationOptions;
+    private replayTargetUrl;
+    private deleteAfterRun;
+    constructor(client: FlowClient);
+    createEndpoint(options?: CreateEndpointOptions): this;
+    setMock(mockResponse: MockResponse | null): this;
+    send(options?: SendOptions): this;
+    sendTemplate(options: SendTemplateOptions): this;
+    waitForCapture(options?: WaitForOptions): this;
+    verifySignature(options: WebhookFlowVerifyOptions): this;
+    replayTo(targetUrl: string): this;
+    cleanup(): this;
+    run(): Promise<WebhookFlowResult>;
+}
+
+/**
+ * @fileoverview webhooks.cc SDK client for programmatic webhook management.
+ *
+ * @example
+ * ```typescript
+ * import { WebhooksCC, matchMethod } from '@webhooks-cc/sdk';
+ *
+ * const client = new WebhooksCC({ apiKey: 'whcc_...' });
+ * const endpoint = await client.endpoints.create({ name: 'My Webhook' });
+ * const request = await client.requests.waitFor(endpoint.slug, {
+ *   timeout: '30s',
+ *   match: matchMethod('POST'),
+ * });
+ * ```
+ */
+
+/**
+ * @deprecated Use {@link WebhooksCCError} instead. Kept for backward compatibility.
+ */
+declare const ApiError: typeof WebhooksCCError;
+/**
+ * Client for the webhooks.cc API.
+ *
+ * Provides methods to create endpoints, list captured requests, and wait
+ * for incoming webhooks. Handles authentication, request signing, and
+ * response validation.
+ */
+declare class WebhooksCC {
+    private readonly apiKey;
+    private readonly baseUrl;
+    private readonly webhookUrl;
+    private readonly timeout;
+    private readonly retry;
+    private readonly hooks;
+    constructor(options: ClientOptions);
+    private request;
+    /** Returns a static description of all SDK operations (no API call). */
+    describe(): SDKDescription;
+    endpoints: {
+        create: (options?: CreateEndpointOptions) => Promise<Endpoint>;
+        list: () => Promise<Endpoint[]>;
+        get: (slug: string) => Promise<Endpoint>;
+        update: (slug: string, options: UpdateEndpointOptions) => Promise<Endpoint>;
+        delete: (slug: string) => Promise<void>;
+        send: (slug: string, options?: SendOptions) => Promise<Response>;
+        sendTemplate: (slug: string, options: SendTemplateOptions) => Promise<Response>;
+    };
+    templates: {
+        listProviders: () => TemplateProvider[];
+        get: (provider: TemplateProvider) => TemplateProviderInfo;
+    };
+    usage: () => Promise<UsageInfo>;
+    flow: () => WebhookFlowBuilder;
+    /**
+     * Build a request without sending it. Returns the computed method, URL,
+     * headers, and body — including any provider signatures. Useful for
+     * debugging what sendTo would actually send.
+     *
+     * @param url - Target URL (http or https)
+     * @param options - Same options as sendTo
+     * @returns The computed request details
+     */
+    buildRequest: (url: string, options?: SendToOptions) => Promise<{
+        url: string;
+        method: string;
+        headers: Record<string, string>;
+        body?: string;
+    }>;
+    /**
+     * Send a webhook directly to any URL with optional provider signing.
+     * Use this for local integration testing — send properly signed webhooks
+     * to localhost handlers without routing through webhooks.cc infrastructure.
+     *
+     * @param url - Target URL to send the webhook to (http or https)
+     * @param options - Method, headers, body, and optional provider signing
+     * @returns Raw fetch Response from the target
+     */
+    sendTo: (url: string, options?: SendToOptions) => Promise<Response>;
+    requests: {
+        list: (endpointSlug: string, options?: ListRequestsOptions) => Promise<Request[]>;
+        listPaginated: (endpointSlug: string, options?: ListPaginatedRequestsOptions) => Promise<PaginatedResult<Request>>;
+        get: (requestId: string) => Promise<Request>;
+        waitForAll: (endpointSlug: string, options: WaitForAllOptions) => Promise<Request[]>;
+        search: (filters?: SearchFilters) => Promise<SearchResult[]>;
+        count: (filters?: SearchFilters) => Promise<number>;
+        clear: (endpointSlug: string, options?: ClearRequestsOptions) => Promise<void>;
+        export: (endpointSlug: string, options: ExportRequestsOptions) => Promise<RequestsExport>;
+        /**
+         * Polls for incoming requests until one matches or timeout expires.
+         *
+         * Fetches requests that arrived since the last successful check. On API
+         * errors, continues polling without updating the timestamp to avoid
+         * missing requests during transient failures.
+         *
+         * @param endpointSlug - Endpoint to monitor
+         * @param options - Timeout, poll interval, and optional match filter
+         * @returns First matching request, or first request if no match filter
+         * @throws Error if timeout expires or max iterations (10000) reached
+         */
+        waitFor: (endpointSlug: string, options?: WaitForOptions) => Promise<Request>;
+        /**
+         * Replay a captured request to a target URL.
+         *
+         * Fetches the original request by ID and re-sends it to the specified URL
+         * with the original method, headers, and body. Hop-by-hop headers are stripped.
+         */
+        replay: (requestId: string, targetUrl: string) => Promise<Response>;
+        /**
+         * Stream incoming requests via SSE as an async iterator.
+         *
+         * Connects to the SSE endpoint and yields Request objects as they arrive.
+         * The connection is closed when the iterator is broken, the signal is aborted,
+         * or the timeout expires.
+         *
+         * Reconnection is opt-in and resumes from the last yielded request timestamp.
+         */
+        subscribe: (slug: string, options?: SubscribeOptions) => AsyncIterable<Request>;
+    };
+}
+
+interface ValueDifference<T> {
+    left: T;
+    right: T;
+}
+interface HeaderDiff {
+    added: string[];
+    removed: string[];
+    changed: Record<string, ValueDifference<string>>;
+}
+interface JsonBodyDiff {
+    type: "json";
+    changed: Record<string, ValueDifference<unknown>>;
+    diff: string;
+}
+interface TextBodyDiff {
+    type: "text";
+    diff: string;
+}
+type BodyDiff = JsonBodyDiff | TextBodyDiff;
+interface RequestDifferences {
+    method?: ValueDifference<string>;
+    path?: ValueDifference<string>;
+    headers?: HeaderDiff;
+    body?: BodyDiff;
+}
+interface DiffRequestsOptions {
+    /** Header names to exclude from comparison. Matched case-insensitively. */
+    ignoreHeaders?: string[];
+}
+interface DiffResult {
+    matches: boolean;
+    differences: RequestDifferences;
+}
+type ComparableRequest = Pick<Request, "method" | "path" | "headers" | "body"> & Partial<Pick<Request, "queryParams" | "contentType">>;
+/**
+ * Compare two requests and return a structured diff suitable for debugging or tooling.
+ */
+declare function diffRequests(left: ComparableRequest | SearchResult, right: ComparableRequest | SearchResult, options?: DiffRequestsOptions): DiffResult;
+
+export { type WebhookFlowVerifyOptions as $, ApiError as A, type BodyDiff as B, type ClearRequestsOptions as C, type DiffRequestsOptions as D, type Endpoint as E, type FormBodyValue as F, TimeoutError as G, type HarExport as H, type UpdateEndpointOptions as I, type JsonBodyDiff as J, type UsageInfo as K, type ListPaginatedRequestsOptions as L, type MockResponse as M, NotFoundError as N, type OperationDescription as O, type ParsedBody as P, type ValueDifference as Q, type Request as R, type SearchResult as S, type TemplateProvider as T, UnauthorizedError as U, type VerifySignatureOptions as V, type VerifyProvider as W, type WaitForAllOptions as X, type WaitForOptions as Y, WebhookFlowBuilder as Z, type WebhookFlowResult as _, type ParsedFormBody as a, WebhooksCC as a0, WebhooksCCError as a1, diffRequests as a2, type SignatureVerificationResult as b, type ClientHooks as c, type ClientOptions as d, type CreateEndpointOptions as e, type CurlExport as f, type DiffResult as g, type ErrorHookInfo as h, type ExportRequestsOptions as i, type HeaderDiff as j, type ListRequestsOptions as k, type PaginatedResult as l, RateLimitError as m, type RequestDifferences as n, type RequestHookInfo as o, type RequestsExport as p, type ResponseHookInfo as q, type RetryOptions as r, type SDKDescription as s, type SearchFilters as t, type SendOptions as u, type SendTemplateOptions as v, type SendToOptions as w, type SubscribeOptions as x, type TemplateProviderInfo as y, type TextBodyDiff as z };