@checkbox-site/node 0.0.0-stage → 0.1.0

package/dist/client.js

@@ -0,0 +1,337 @@
+// The Checkbox client: `const checkbox = new Checkbox(process.env.CHECKBOX_API_KEY)`.
+// Zero runtime dependencies: global fetch (Node 20+, Bun, Deno, edge runtimes).
+import { CheckboxAuthenticationError, CheckboxConnectionError, CheckboxError, CheckboxInvalidRequestError } from "./errors.js";
+import * as errors from "./errors.js";
+import { OPERATIONS, RESOURCES } from "./generated/operations.js";
+import { API_VERSION } from "./generated/types.js";
+import { listPromise } from "./resource.js";
+import { SDK_VERSION } from "./version.js";
+import { Webhooks, webhooks } from "./webhooks.js";
+export const DEFAULT_BASE_URL = 'https://app.checkbox.site';
+export const DEFAULT_TIMEOUT_MS = 80_000;
+export const DEFAULT_MAX_NETWORK_RETRIES = 2;
+const MAX_RETRY_DELAY_MS = 20_000;
+/** `ck_test_…` / `rk_test_…` / `pk_test_…` -> test; `ck_live_…` / `rk_live_…` / `sk_live_…` / `pk_live_…` -> live. */
+export function modeOfKey(key) {
+    const m = /^(?:ck|rk|sk|pk)_(test|live)_/.exec(key ?? '');
+    return m ? m[1] : undefined;
+}
+const env = (name) => {
+    const p = globalThis.process;
+    return p?.env?.[name] || undefined;
+};
+const sleep = (ms, signal) => new Promise((resolve, reject) => {
+    if (signal?.aborted)
+        return reject(signal.reason);
+    const t = setTimeout(resolve, ms);
+    signal?.addEventListener('abort', () => (clearTimeout(t), reject(signal.reason)), { once: true });
+});
+function newIdempotencyKey() {
+    const c = globalThis.crypto;
+    if (c?.randomUUID)
+        return `sdk_${c.randomUUID()}`;
+    return `sdk_${Date.now().toString(36)}_${Math.random().toString(36).slice(2)}${Math.random().toString(36).slice(2)}`;
+}
+function runtimeLabel() {
+    const g = globalThis;
+    if (g.process?.versions?.bun)
+        return `bun/${g.process.versions.bun}`;
+    if (g.Deno?.version?.deno)
+        return `deno/${g.Deno.version.deno}`;
+    if (g.process?.versions?.node)
+        return `node/${g.process.versions.node}`;
+    return 'js';
+}
+/**
+ * Checkbox API client.
+ *
+ * ```ts
+ * import Checkbox from '@checkbox-site/node';
+ * const checkbox = new Checkbox(process.env.CHECKBOX_API_KEY);
+ * const site = await checkbox.sites.create({ url: 'https://acme.example' });
+ * for await (const finding of checkbox.findings.list({ site: site.id })) console.log(finding.check_id, finding.status);
+ * ```
+ */
+export class Checkbox {
+    static VERSION = SDK_VERSION;
+    static API_VERSION = API_VERSION;
+    static errors = errors;
+    static webhooks = webhooks;
+    static OPERATIONS = OPERATIONS;
+    static Webhooks = Webhooks;
+    /** Webhook signature verification: `checkbox.webhooks.constructEvent(rawBody, header, secret)`. */
+    webhooks = webhooks;
+    /** The API version sent as Checkbox-Version. */
+    apiVersion;
+    baseUrl;
+    /** 'test' for ck_test_/rk_test_ keys, 'live' for live keys, undefined without a (recognised) key. */
+    mode;
+    #apiKey;
+    #config;
+    #userAgent;
+    /**
+     * @param apiKey secret (`ck_test_…`, `ck_live_…`), restricted (`rk_…`) or legacy (`sk_live_…`) key. Defaults to
+     *   the CHECKBOX_API_KEY environment variable, then CHECKBOX_SECRET_KEY (what `checkbox init` writes to .env.local).
+     */
+    constructor(apiKey, config = {}) {
+        this.#apiKey = (apiKey ?? env('CHECKBOX_API_KEY') ?? env('CHECKBOX_SECRET_KEY'))?.trim() || undefined;
+        this.#config = { maxNetworkRetries: DEFAULT_MAX_NETWORK_RETRIES, timeout: DEFAULT_TIMEOUT_MS, ...config };
+        this.apiVersion = config.apiVersion ?? API_VERSION;
+        this.baseUrl = (config.baseUrl ?? env('CHECKBOX_API_BASE') ?? DEFAULT_BASE_URL).replace(/\/+$/, '');
+        this.mode = modeOfKey(this.#apiKey);
+        const app = config.appInfo ? ` ${config.appInfo.name}${config.appInfo.version ? `/${config.appInfo.version}` : ''}${config.appInfo.url ? ` (${config.appInfo.url})` : ''}` : '';
+        this.#userAgent = `checkbox-node/${SDK_VERSION} ${runtimeLabel()}${app}`;
+        for (const [ns, Cls] of Object.entries(RESOURCES)) {
+            Object.defineProperty(this, ns, { value: new Cls(this), enumerable: true });
+        }
+    }
+    /** True for live keys, false for test keys, undefined when unknown. */
+    get livemode() {
+        return this.mode === undefined ? undefined : this.mode === 'live';
+    }
+    /** Whether an API key is configured. */
+    get hasApiKey() {
+        return this.#apiKey !== undefined;
+    }
+    /**
+     * Calls any operation by its operationId with flat arguments (path parameters and params together). This is the
+     * shape MCP tools and agents use: `checkbox.call('retrieveSite', { site: 'site_…' })`.
+     */
+    call(operationId, args, options) {
+        const op = OPERATIONS[operationId];
+        if (!op) {
+            return Promise.reject(new CheckboxInvalidRequestError({ message: `Unknown operation "${String(operationId)}".`, type: 'invalid_request_error', code: 'route_not_found', param: 'operationId' }));
+        }
+        const rest = { ...(args ?? {}) };
+        const pathArgs = op.pathParams.map((name) => {
+            const v = rest[name];
+            delete rest[name];
+            return v;
+        });
+        return this._send(op, pathArgs, rest, options);
+    }
+    /** Like `call` for a paginated list operation, returning the auto-paginating list promise. */
+    callList(operationId, args, options) {
+        const op = OPERATIONS[operationId];
+        const rest = { ...(args ?? {}) };
+        const pathArgs = op.pathParams.map((name) => {
+            const v = rest[name];
+            delete rest[name];
+            return v;
+        });
+        return listPromise(this, op, pathArgs, rest, options);
+    }
+    /**
+     * Request to any API path with an explicit query and JSON body (escape hatch for endpoints newer than this SDK):
+     * `checkbox.request('POST', '/v1/new_thing', { query: { wait: 5 }, body: { a: 1 } })`. Retries, idempotency keys,
+     * versioning and typed errors apply as for the generated methods.
+     */
+    request(method, path, opts = {}) {
+        const { query, body, ...options } = opts;
+        return this.#raw(method, path, query ?? {}, body, options);
+    }
+    /**
+     * Stripe-style raw request: `params` go to the query string for GET/DELETE and to the JSON body for POST.
+     * `checkbox.rawRequest('GET', '/v1/sites', { limit: 3 })`.
+     */
+    rawRequest(method, path, params, options = {}) {
+        return (method === 'POST' ? this.#raw(method, path, {}, params ?? {}, options) : this.#raw(method, path, params ?? {}, undefined, options));
+    }
+    #raw(method, path, query, body, options) {
+        const op = {
+            operationId: 'request',
+            namespace: 'request',
+            method: 'request',
+            httpMethod: method,
+            path: path.startsWith('/') ? path : `/${path}`,
+            pathParams: [],
+            queryParams: Object.keys(query),
+            body: method === 'POST',
+            idempotent: method === 'POST',
+            auth: true,
+            scope: 'none',
+            response: 'json',
+            list: false,
+            paginated: false,
+            summary: '',
+        };
+        const overlap = Object.keys(query).filter((k) => body && k in body);
+        if (overlap.length) {
+            return Promise.reject(new CheckboxInvalidRequestError({ message: `"${overlap[0]}" is given both in query and body.`, type: 'invalid_request_error', code: 'parameter_invalid', param: overlap[0] }));
+        }
+        return this._send(op, [], { ...query, ...(body ?? {}) }, options);
+    }
+    /** @internal Used by the generated resources. */
+    async _send(op, pathArgs, params, options = {}) {
+        const apiKey = options.apiKey ?? this.#apiKey;
+        if (op.auth && !apiKey) {
+            throw new CheckboxAuthenticationError({
+                message: 'No API key provided. Pass it to new Checkbox(key) or set CHECKBOX_API_KEY (or CHECKBOX_SECRET_KEY, which `checkbox init` writes).',
+                type: 'authentication_error',
+                code: 'api_key_missing',
+                nextAction: {
+                    type: 'get_api_key',
+                    message: 'Get a free test key: POST /v1/device/authorize (one browser approval creates an account and test keys), the remote MCP server https://app.checkbox.site/mcp (setup_checkbox), or https://app.checkbox.site/settings/api-keys.',
+                    url: 'https://app.checkbox.site/settings/api-keys',
+                },
+            });
+        }
+        let path = op.path;
+        op.pathParams.forEach((name, i) => {
+            const v = pathArgs[i];
+            if (typeof v !== 'string' || !v.trim()) {
+                throw new CheckboxInvalidRequestError({
+                    message: `Missing required path parameter "${name}" for ${op.operationId}.`,
+                    type: 'invalid_request_error',
+                    code: 'parameter_missing',
+                    param: name,
+                });
+            }
+            path = path.replace(`{${name}}`, encodeURIComponent(v));
+        });
+        const url = new URL(this.baseUrl + path);
+        const queryNames = new Set(op.queryParams);
+        const body = {};
+        for (const [k, v] of Object.entries(params ?? {})) {
+            if (v === undefined)
+                continue;
+            const inQuery = op.httpMethod !== 'POST' || queryNames.has(k) || (k === 'expand' && queryNames.has('expand[]'));
+            if (!inQuery) {
+                body[k] = v;
+                continue;
+            }
+            if (k === 'expand' || k === 'expand[]') {
+                for (const e of Array.isArray(v) ? v : [v])
+                    url.searchParams.append('expand[]', String(e));
+            }
+            else if (Array.isArray(v)) {
+                for (const e of v)
+                    url.searchParams.append(`${k}[]`, String(e));
+            }
+            else if (v !== null && typeof v === 'object') {
+                url.searchParams.set(k, JSON.stringify(v));
+            }
+            else {
+                url.searchParams.set(k, String(v));
+            }
+        }
+        const headers = {
+            accept: op.response === 'json' ? 'application/json' : '*/*',
+            'checkbox-version': options.apiVersion ?? this.apiVersion,
+            'user-agent': this.#userAgent,
+            ...(this.#config.headers ?? {}),
+            ...(options.headers ?? {}),
+        };
+        if (apiKey)
+            headers.authorization = `Bearer ${apiKey}`;
+        let payload;
+        if (op.httpMethod === 'POST') {
+            payload = JSON.stringify(body);
+            headers['content-type'] = 'application/json';
+            if (op.idempotent || options.idempotencyKey)
+                headers['idempotency-key'] = options.idempotencyKey ?? newIdempotencyKey();
+        }
+        const maxRetries = Math.max(0, options.maxNetworkRetries ?? this.#config.maxNetworkRetries);
+        const timeout = options.timeout ?? this.#config.timeout;
+        const f = this.#config.fetch ?? globalThis.fetch;
+        if (typeof f !== 'function')
+            throw new Error('No fetch implementation: use Node 20+ or pass { fetch } to new Checkbox().');
+        for (let attempt = 0;; attempt++) {
+            let res;
+            const signals = [AbortSignal.timeout(timeout), ...(options.signal ? [options.signal] : [])];
+            try {
+                res = await f(url, {
+                    method: op.httpMethod,
+                    headers,
+                    ...(payload !== undefined ? { body: payload } : {}),
+                    signal: signals.length > 1 ? AbortSignal.any(signals) : signals[0],
+                });
+            }
+            catch (err) {
+                if (options.signal?.aborted)
+                    throw err;
+                if (attempt < maxRetries) {
+                    await sleep(backoff(attempt), options.signal);
+                    continue;
+                }
+                const timedOut = err?.name === 'TimeoutError';
+                throw new CheckboxConnectionError({
+                    message: timedOut
+                        ? `Request to ${url.origin} timed out after ${timeout} ms (${attempt + 1} attempt${attempt ? 's' : ''}).`
+                        : `Could not reach ${url.origin}: ${err?.message ?? String(err)} (${attempt + 1} attempt${attempt ? 's' : ''}).`,
+                    type: 'connection_error',
+                    code: timedOut ? 'timeout' : 'connection_failed',
+                    nextAction: { type: 'retry', message: 'Check the network and CHECKBOX_API_BASE, then retry; POSTs are safe to retry with the same idempotencyKey.' },
+                    cause: err,
+                });
+            }
+            const resHeaders = {};
+            res.headers.forEach((v, k) => (resHeaders[k.toLowerCase()] = v));
+            if (!res.ok) {
+                const text = await res.text().catch(() => '');
+                let json;
+                try {
+                    json = text ? JSON.parse(text) : undefined;
+                }
+                catch {
+                    json = undefined;
+                }
+                const error = CheckboxError.generate(res.status, json ?? (text ? { error: text.slice(0, 300) } : undefined), resHeaders);
+                if (attempt < maxRetries && shouldRetry(res.status, error.code)) {
+                    await sleep(retryDelay(attempt, resHeaders['retry-after']), options.signal);
+                    continue;
+                }
+                throw error;
+            }
+            const meta = {
+                statusCode: res.status,
+                requestId: resHeaders['request-id'],
+                apiVersion: resHeaders['checkbox-version'],
+                idempotencyKey: headers['idempotency-key'],
+                idempotentReplayed: resHeaders['idempotent-replayed'] === 'true',
+                headers: resHeaders,
+            };
+            if (op.response === 'binary') {
+                const data = new Uint8Array(await res.arrayBuffer());
+                const disposition = resHeaders['content-disposition'] ?? '';
+                const file = { data, contentType: resHeaders['content-type'] ?? null, filename: /filename="?([^";]+)"?/i.exec(disposition)?.[1] ?? null };
+                return withMeta(file, meta);
+            }
+            const text = await res.text();
+            if (op.response === 'text')
+                return text;
+            let json;
+            try {
+                json = text ? JSON.parse(text) : {};
+            }
+            catch {
+                throw new CheckboxError({ message: `Invalid JSON from the API (HTTP ${res.status}).`, type: 'api_error', code: 'invalid_response', statusCode: res.status, requestId: meta.requestId, headers: resHeaders });
+            }
+            return withMeta(json, meta);
+        }
+    }
+}
+function withMeta(value, meta) {
+    if (value && typeof value === 'object' && Object.isExtensible(value)) {
+        Object.defineProperty(value, 'lastResponse', { value: meta, enumerable: false, configurable: true });
+    }
+    return value;
+}
+/** Response metadata of an object returned by the SDK (status, request id, idempotency replay, headers). */
+export function getLastResponse(obj) {
+    return obj && typeof obj === 'object' ? (obj.lastResponse ?? undefined) : undefined;
+}
+function shouldRetry(status, code) {
+    return status === 429 || status >= 500 || (status === 409 && code === 'idempotency_key_in_use');
+}
+/** 0.5 s, 1 s, 2 s, ... capped at 20 s, with jitter (75-100 %). */
+export function backoff(attempt) {
+    const base = Math.min(500 * 2 ** attempt, MAX_RETRY_DELAY_MS);
+    return Math.round(base * (0.75 + Math.random() * 0.25));
+}
+function retryDelay(attempt, retryAfter) {
+    const s = Number(retryAfter);
+    if (Number.isFinite(s) && s > 0)
+        return Math.min(s * 1000, MAX_RETRY_DELAY_MS);
+    return backoff(attempt);
+}

package/dist/errors.d.ts

@@ -0,0 +1,89 @@
+/** `next_action` of an error or object: what an agent should do next. */
+export interface NextAction {
+    /** Stable machine-readable action type, e.g. "verify_domain", "create_site", "wait". */
+    type: string;
+    /** One or two sentences for the agent or human. */
+    message: string;
+    /** API operation to call next (also the SDK method's operationId; `mcp_tool` names the MCP tool). */
+    operation_id?: string;
+    /** Page or document to open. */
+    url?: string;
+    [key: string]: unknown;
+}
+export type CheckboxErrorType = 'invalid_request_error' | 'authentication_error' | 'permission_error' | 'rate_limit_error' | 'idempotency_error' | 'api_error' | 'connection_error' | 'signature_verification_error';
+export interface CheckboxErrorRaw {
+    type?: string;
+    code?: string;
+    message?: string;
+    param?: string;
+    doc_url?: string;
+    request_id?: string;
+    next_action?: NextAction;
+    [key: string]: unknown;
+}
+export interface CheckboxErrorInit {
+    message: string;
+    type: CheckboxErrorType;
+    code?: string | undefined;
+    param?: string | undefined;
+    statusCode?: number | undefined;
+    requestId?: string | undefined;
+    docUrl?: string | undefined;
+    nextAction?: NextAction | undefined;
+    headers?: Record<string, string> | undefined;
+    raw?: CheckboxErrorRaw | undefined;
+    cause?: unknown;
+}
+/** Base class of every error the SDK throws. Branch on `code` (stable) rather than on `message`. */
+export declare class CheckboxError extends Error {
+    /** Error category (`invalid_request_error`, `authentication_error`, ...). */
+    readonly type: CheckboxErrorType;
+    /** Stable machine-readable code (`resource_missing`, `parameter_invalid`, ...); see ERROR_CODES. */
+    readonly code: string | undefined;
+    /** The parameter the error is about, when there is one. */
+    readonly param: string | undefined;
+    /** HTTP status (undefined for connection and signature errors). */
+    readonly statusCode: number | undefined;
+    /** `req_…` id; quote it to support. */
+    readonly requestId: string | undefined;
+    /** Documentation of the error code. */
+    readonly docUrl: string | undefined;
+    /** What an agent should do next (call an operation, open a URL, ask the human). */
+    readonly nextAction: NextAction | undefined;
+    /** Response headers (lower-case names). */
+    readonly headers: Record<string, string>;
+    /** The `error` object of the response body. */
+    readonly raw: CheckboxErrorRaw | undefined;
+    constructor(init: CheckboxErrorInit);
+    /** A JSON-friendly view (what an agent should log or show). */
+    toJSON(): Record<string, unknown>;
+    /** Builds the right subclass from an HTTP status and the response body's `error` object. */
+    static generate(statusCode: number, body: unknown, headers?: Record<string, string>): CheckboxError;
+}
+/** Bad parameters, unknown object (`resource_missing`), wrong state (`resource_conflict`), ... (HTTP 400/404/409/410). */
+export declare class CheckboxInvalidRequestError extends CheckboxError {
+}
+/** Missing, unknown or revoked API key (HTTP 401). */
+export declare class CheckboxAuthenticationError extends CheckboxError {
+}
+/** The key may not do this: publishable key, missing scope or role, live mode not activated (HTTP 403). */
+export declare class CheckboxPermissionError extends CheckboxError {
+}
+/** Too many requests (HTTP 429); retried automatically, thrown when retries are exhausted. */
+export declare class CheckboxRateLimitError extends CheckboxError {
+}
+/** An Idempotency-Key was reused with a different body, or is still in use. */
+export declare class CheckboxIdempotencyError extends CheckboxError {
+}
+/** Something went wrong on Checkbox's side (HTTP 5xx); retrying with the same Idempotency-Key is safe. */
+export declare class CheckboxAPIError extends CheckboxError {
+}
+/** The API could not be reached (DNS, TLS, timeout, connection reset) after the retries. */
+export declare class CheckboxConnectionError extends CheckboxError {
+}
+/** A webhook's Checkbox-Signature did not match the payload and secret, or was too old. */
+export declare class CheckboxSignatureVerificationError extends CheckboxError {
+    readonly header: string | undefined;
+    readonly payload: string;
+    constructor(message: string, header: string | undefined, payload: string);
+}

package/dist/errors.js

@@ -0,0 +1,125 @@
+// Typed errors (Stripe-style). Every API error carries the stable `code`, the `type`, the HTTP status, the request id and,
+// for agents, `nextAction`: what to call or change next.
+/** Base class of every error the SDK throws. Branch on `code` (stable) rather than on `message`. */
+export class CheckboxError extends Error {
+    /** Error category (`invalid_request_error`, `authentication_error`, ...). */
+    type;
+    /** Stable machine-readable code (`resource_missing`, `parameter_invalid`, ...); see ERROR_CODES. */
+    code;
+    /** The parameter the error is about, when there is one. */
+    param;
+    /** HTTP status (undefined for connection and signature errors). */
+    statusCode;
+    /** `req_…` id; quote it to support. */
+    requestId;
+    /** Documentation of the error code. */
+    docUrl;
+    /** What an agent should do next (call an operation, open a URL, ask the human). */
+    nextAction;
+    /** Response headers (lower-case names). */
+    headers;
+    /** The `error` object of the response body. */
+    raw;
+    constructor(init) {
+        super(init.message, init.cause !== undefined ? { cause: init.cause } : undefined);
+        this.name = new.target.name;
+        this.type = init.type;
+        this.code = init.code;
+        this.param = init.param;
+        this.statusCode = init.statusCode;
+        this.requestId = init.requestId;
+        this.docUrl = init.docUrl;
+        this.nextAction = init.nextAction;
+        this.headers = init.headers ?? {};
+        this.raw = init.raw;
+    }
+    /** A JSON-friendly view (what an agent should log or show). */
+    toJSON() {
+        return {
+            name: this.name,
+            type: this.type,
+            code: this.code,
+            message: this.message,
+            param: this.param,
+            status: this.statusCode,
+            request_id: this.requestId,
+            doc_url: this.docUrl,
+            next_action: this.nextAction,
+        };
+    }
+    /** Builds the right subclass from an HTTP status and the response body's `error` object. */
+    static generate(statusCode, body, headers = {}) {
+        const e = body && typeof body === 'object' ? body.error : undefined;
+        const raw = e && typeof e === 'object' ? e : undefined;
+        const message = raw?.message ?? (typeof e === 'string' ? e : `Checkbox API returned HTTP ${statusCode}${statusCode === 404 ? ' (no such endpoint)' : ''}.`);
+        const type = raw?.type ?? typeForStatus(statusCode);
+        const init = {
+            message,
+            type,
+            code: raw?.code,
+            param: raw?.param,
+            statusCode,
+            requestId: raw?.request_id ?? headers['request-id'],
+            docUrl: raw?.doc_url,
+            nextAction: raw?.next_action && typeof raw.next_action === 'object' ? raw.next_action : undefined,
+            headers,
+            raw,
+        };
+        switch (type) {
+            case 'authentication_error':
+                return new CheckboxAuthenticationError(init);
+            case 'permission_error':
+                return new CheckboxPermissionError(init);
+            case 'rate_limit_error':
+                return new CheckboxRateLimitError(init);
+            case 'idempotency_error':
+                return new CheckboxIdempotencyError(init);
+            case 'invalid_request_error':
+                return new CheckboxInvalidRequestError(init);
+            default:
+                return new CheckboxAPIError(init);
+        }
+    }
+}
+function typeForStatus(status) {
+    if (status === 401)
+        return 'authentication_error';
+    if (status === 403)
+        return 'permission_error';
+    if (status === 429)
+        return 'rate_limit_error';
+    if (status >= 400 && status < 500)
+        return 'invalid_request_error';
+    return 'api_error';
+}
+/** Bad parameters, unknown object (`resource_missing`), wrong state (`resource_conflict`), ... (HTTP 400/404/409/410). */
+export class CheckboxInvalidRequestError extends CheckboxError {
+}
+/** Missing, unknown or revoked API key (HTTP 401). */
+export class CheckboxAuthenticationError extends CheckboxError {
+}
+/** The key may not do this: publishable key, missing scope or role, live mode not activated (HTTP 403). */
+export class CheckboxPermissionError extends CheckboxError {
+}
+/** Too many requests (HTTP 429); retried automatically, thrown when retries are exhausted. */
+export class CheckboxRateLimitError extends CheckboxError {
+}
+/** An Idempotency-Key was reused with a different body, or is still in use. */
+export class CheckboxIdempotencyError extends CheckboxError {
+}
+/** Something went wrong on Checkbox's side (HTTP 5xx); retrying with the same Idempotency-Key is safe. */
+export class CheckboxAPIError extends CheckboxError {
+}
+/** The API could not be reached (DNS, TLS, timeout, connection reset) after the retries. */
+export class CheckboxConnectionError extends CheckboxError {
+}
+/** A webhook's Checkbox-Signature did not match the payload and secret, or was too old. */
+export class CheckboxSignatureVerificationError extends CheckboxError {
+    header;
+    payload;
+    constructor(message, header, payload) {
+        super({ message, type: 'signature_verification_error', code: 'signature_verification_failed' });
+        this.header = header;
+        this.payload = payload;
+    }
+}