@checkbox-site/node 0.0.0-stage → 0.1.0

package/dist/generated/operations.d.ts

@@ -0,0 +1,3341 @@
+import type * as T from './types.ts';
+import { Resource, type ApiListPromise, type RequestOptions } from '../resource.ts';
+/** How to call each operation. Keys are the OpenAPI operationIds (also the MCP tool names). */
+export declare const OPERATIONS: {
+    readonly createDeviceAuthorization: {
+        readonly operationId: "createDeviceAuthorization";
+        readonly namespace: "device";
+        readonly method: "authorize";
+        readonly httpMethod: "POST";
+        readonly path: "/v1/device/authorize";
+        readonly pathParams: readonly [];
+        readonly queryParams: readonly [];
+        readonly body: true;
+        readonly idempotent: false;
+        readonly auth: false;
+        readonly scope: "none";
+        readonly response: "json";
+        readonly list: false;
+        readonly paginated: false;
+        readonly summary: "Start a device login (setup_checkbox)";
+    };
+    readonly createDeviceToken: {
+        readonly operationId: "createDeviceToken";
+        readonly namespace: "device";
+        readonly method: "token";
+        readonly httpMethod: "POST";
+        readonly path: "/v1/device/token";
+        readonly pathParams: readonly [];
+        readonly queryParams: readonly [];
+        readonly body: true;
+        readonly idempotent: false;
+        readonly auth: false;
+        readonly scope: "none";
+        readonly response: "json";
+        readonly list: false;
+        readonly paginated: false;
+        readonly summary: "Poll a device login for its keys";
+    };
+    readonly createSetupSession: {
+        readonly operationId: "createSetupSession";
+        readonly namespace: "setupSessions";
+        readonly method: "create";
+        readonly httpMethod: "POST";
+        readonly path: "/v1/setup_sessions";
+        readonly pathParams: readonly [];
+        readonly queryParams: readonly [];
+        readonly body: true;
+        readonly idempotent: true;
+        readonly auth: true;
+        readonly scope: "setup_sessions:write";
+        readonly response: "json";
+        readonly list: false;
+        readonly paginated: false;
+        readonly summary: "Start a setup session (agents that already have a key)";
+    };
+    readonly listSetupSessions: {
+        readonly operationId: "listSetupSessions";
+        readonly namespace: "setupSessions";
+        readonly method: "list";
+        readonly httpMethod: "GET";
+        readonly path: "/v1/setup_sessions";
+        readonly pathParams: readonly [];
+        readonly queryParams: readonly ["limit", "starting_after", "ending_before"];
+        readonly body: false;
+        readonly idempotent: false;
+        readonly auth: true;
+        readonly scope: "setup_sessions:read";
+        readonly response: "json";
+        readonly list: true;
+        readonly paginated: true;
+        readonly summary: "List setup sessions";
+    };
+    readonly retrieveSetupSession: {
+        readonly operationId: "retrieveSetupSession";
+        readonly namespace: "setupSessions";
+        readonly method: "retrieve";
+        readonly httpMethod: "GET";
+        readonly path: "/v1/setup_sessions/{setup_session}";
+        readonly pathParams: readonly ["setup_session"];
+        readonly queryParams: readonly [];
+        readonly body: false;
+        readonly idempotent: false;
+        readonly auth: true;
+        readonly scope: "setup_sessions:read";
+        readonly response: "json";
+        readonly list: false;
+        readonly paginated: false;
+        readonly summary: "Retrieve a setup session";
+    };
+    readonly updateSetupSession: {
+        readonly operationId: "updateSetupSession";
+        readonly namespace: "setupSessions";
+        readonly method: "update";
+        readonly httpMethod: "POST";
+        readonly path: "/v1/setup_sessions/{setup_session}";
+        readonly pathParams: readonly ["setup_session"];
+        readonly queryParams: readonly [];
+        readonly body: true;
+        readonly idempotent: true;
+        readonly auth: true;
+        readonly scope: "setup_sessions:write";
+        readonly response: "json";
+        readonly list: false;
+        readonly paginated: false;
+        readonly summary: "Report what the agent learned or changed";
+    };
+    readonly verifySetupSession: {
+        readonly operationId: "verifySetupSession";
+        readonly namespace: "setupSessions";
+        readonly method: "verify";
+        readonly httpMethod: "POST";
+        readonly path: "/v1/setup_sessions/{setup_session}/verify";
+        readonly pathParams: readonly ["setup_session"];
+        readonly queryParams: readonly [];
+        readonly body: false;
+        readonly idempotent: true;
+        readonly auth: true;
+        readonly scope: "setup_sessions:write";
+        readonly response: "json";
+        readonly list: false;
+        readonly paginated: false;
+        readonly summary: "Re-check the site now";
+    };
+    readonly completeSetupSession: {
+        readonly operationId: "completeSetupSession";
+        readonly namespace: "setupSessions";
+        readonly method: "complete";
+        readonly httpMethod: "POST";
+        readonly path: "/v1/setup_sessions/{setup_session}/complete";
+        readonly pathParams: readonly ["setup_session"];
+        readonly queryParams: readonly [];
+        readonly body: false;
+        readonly idempotent: true;
+        readonly auth: true;
+        readonly scope: "setup_sessions:write";
+        readonly response: "json";
+        readonly list: false;
+        readonly paginated: false;
+        readonly summary: "Finish the setup and notify the human";
+    };
+    readonly retrieveAccount: {
+        readonly operationId: "retrieveAccount";
+        readonly namespace: "account";
+        readonly method: "retrieve";
+        readonly httpMethod: "GET";
+        readonly path: "/v1/account";
+        readonly pathParams: readonly [];
+        readonly queryParams: readonly [];
+        readonly body: false;
+        readonly idempotent: false;
+        readonly auth: true;
+        readonly scope: "account:read";
+        readonly response: "json";
+        readonly list: false;
+        readonly paginated: false;
+        readonly summary: "Retrieve the account";
+    };
+    readonly updateAccount: {
+        readonly operationId: "updateAccount";
+        readonly namespace: "account";
+        readonly method: "update";
+        readonly httpMethod: "POST";
+        readonly path: "/v1/account";
+        readonly pathParams: readonly [];
+        readonly queryParams: readonly [];
+        readonly body: true;
+        readonly idempotent: true;
+        readonly auth: true;
+        readonly scope: "account:write";
+        readonly response: "json";
+        readonly list: false;
+        readonly paginated: false;
+        readonly summary: "Update the account";
+    };
+    readonly listSites: {
+        readonly operationId: "listSites";
+        readonly namespace: "sites";
+        readonly method: "list";
+        readonly httpMethod: "GET";
+        readonly path: "/v1/sites";
+        readonly pathParams: readonly [];
+        readonly queryParams: readonly ["limit", "starting_after", "ending_before", "archived"];
+        readonly body: false;
+        readonly idempotent: false;
+        readonly auth: true;
+        readonly scope: "sites:read";
+        readonly response: "json";
+        readonly list: true;
+        readonly paginated: true;
+        readonly summary: "List sites";
+    };
+    readonly createSite: {
+        readonly operationId: "createSite";
+        readonly namespace: "sites";
+        readonly method: "create";
+        readonly httpMethod: "POST";
+        readonly path: "/v1/sites";
+        readonly pathParams: readonly [];
+        readonly queryParams: readonly [];
+        readonly body: true;
+        readonly idempotent: true;
+        readonly auth: true;
+        readonly scope: "sites:write";
+        readonly response: "json";
+        readonly list: false;
+        readonly paginated: false;
+        readonly summary: "Create a site";
+    };
+    readonly retrieveSite: {
+        readonly operationId: "retrieveSite";
+        readonly namespace: "sites";
+        readonly method: "retrieve";
+        readonly httpMethod: "GET";
+        readonly path: "/v1/sites/{site}";
+        readonly pathParams: readonly ["site"];
+        readonly queryParams: readonly ["expand[]"];
+        readonly body: false;
+        readonly idempotent: false;
+        readonly auth: true;
+        readonly scope: "sites:read";
+        readonly response: "json";
+        readonly list: false;
+        readonly paginated: false;
+        readonly summary: "Retrieve a site";
+    };
+    readonly updateSite: {
+        readonly operationId: "updateSite";
+        readonly namespace: "sites";
+        readonly method: "update";
+        readonly httpMethod: "POST";
+        readonly path: "/v1/sites/{site}";
+        readonly pathParams: readonly ["site"];
+        readonly queryParams: readonly [];
+        readonly body: true;
+        readonly idempotent: true;
+        readonly auth: true;
+        readonly scope: "sites:write";
+        readonly response: "json";
+        readonly list: false;
+        readonly paginated: false;
+        readonly summary: "Update a site";
+    };
+    readonly deleteSite: {
+        readonly operationId: "deleteSite";
+        readonly namespace: "sites";
+        readonly method: "del";
+        readonly httpMethod: "DELETE";
+        readonly path: "/v1/sites/{site}";
+        readonly pathParams: readonly ["site"];
+        readonly queryParams: readonly [];
+        readonly body: false;
+        readonly idempotent: false;
+        readonly auth: true;
+        readonly scope: "sites:write";
+        readonly response: "json";
+        readonly list: false;
+        readonly paginated: false;
+        readonly summary: "Archive a site";
+    };
+    readonly restoreSite: {
+        readonly operationId: "restoreSite";
+        readonly namespace: "sites";
+        readonly method: "restore";
+        readonly httpMethod: "POST";
+        readonly path: "/v1/sites/{site}/restore";
+        readonly pathParams: readonly ["site"];
+        readonly queryParams: readonly [];
+        readonly body: false;
+        readonly idempotent: true;
+        readonly auth: true;
+        readonly scope: "sites:write";
+        readonly response: "json";
+        readonly list: false;
+        readonly paginated: false;
+        readonly summary: "Restore an archived site";
+    };
+    readonly connectBillingPlatform: {
+        readonly operationId: "connectBillingPlatform";
+        readonly namespace: "sites";
+        readonly method: "connectBillingPlatform";
+        readonly httpMethod: "POST";
+        readonly path: "/v1/sites/{site}/integrations";
+        readonly pathParams: readonly ["site"];
+        readonly queryParams: readonly [];
+        readonly body: true;
+        readonly idempotent: true;
+        readonly auth: true;
+        readonly scope: "sites:write";
+        readonly response: "json";
+        readonly list: false;
+        readonly paginated: false;
+        readonly summary: "Connect a billing platform";
+    };
+    readonly retrieveDomainVerification: {
+        readonly operationId: "retrieveDomainVerification";
+        readonly namespace: "domainVerifications";
+        readonly method: "retrieve";
+        readonly httpMethod: "GET";
+        readonly path: "/v1/sites/{site}/domain_verification";
+        readonly pathParams: readonly ["site"];
+        readonly queryParams: readonly [];
+        readonly body: false;
+        readonly idempotent: false;
+        readonly auth: true;
+        readonly scope: "sites:read";
+        readonly response: "json";
+        readonly list: false;
+        readonly paginated: false;
+        readonly summary: "Retrieve domain verification";
+    };
+    readonly createDomainVerification: {
+        readonly operationId: "createDomainVerification";
+        readonly namespace: "domainVerifications";
+        readonly method: "create";
+        readonly httpMethod: "POST";
+        readonly path: "/v1/sites/{site}/domain_verification";
+        readonly pathParams: readonly ["site"];
+        readonly queryParams: readonly [];
+        readonly body: true;
+        readonly idempotent: true;
+        readonly auth: true;
+        readonly scope: "sites:write";
+        readonly response: "json";
+        readonly list: false;
+        readonly paginated: false;
+        readonly summary: "Start domain verification";
+    };
+    readonly checkDomainVerification: {
+        readonly operationId: "checkDomainVerification";
+        readonly namespace: "domainVerifications";
+        readonly method: "check";
+        readonly httpMethod: "POST";
+        readonly path: "/v1/sites/{site}/domain_verification/check";
+        readonly pathParams: readonly ["site"];
+        readonly queryParams: readonly [];
+        readonly body: false;
+        readonly idempotent: true;
+        readonly auth: true;
+        readonly scope: "sites:write";
+        readonly response: "json";
+        readonly list: false;
+        readonly paginated: false;
+        readonly summary: "Check domain verification now";
+    };
+    readonly createScan: {
+        readonly operationId: "createScan";
+        readonly namespace: "scans";
+        readonly method: "create";
+        readonly httpMethod: "POST";
+        readonly path: "/v1/sites/{site}/scans";
+        readonly pathParams: readonly ["site"];
+        readonly queryParams: readonly [];
+        readonly body: true;
+        readonly idempotent: true;
+        readonly auth: true;
+        readonly scope: "scans:write";
+        readonly response: "json";
+        readonly list: false;
+        readonly paginated: false;
+        readonly summary: "Run a scan";
+    };
+    readonly listScans: {
+        readonly operationId: "listScans";
+        readonly namespace: "scans";
+        readonly method: "list";
+        readonly httpMethod: "GET";
+        readonly path: "/v1/scans";
+        readonly pathParams: readonly [];
+        readonly queryParams: readonly ["limit", "starting_after", "ending_before", "site"];
+        readonly body: false;
+        readonly idempotent: false;
+        readonly auth: true;
+        readonly scope: "scans:read";
+        readonly response: "json";
+        readonly list: true;
+        readonly paginated: true;
+        readonly summary: "List scans";
+    };
+    readonly retrieveScan: {
+        readonly operationId: "retrieveScan";
+        readonly namespace: "scans";
+        readonly method: "retrieve";
+        readonly httpMethod: "GET";
+        readonly path: "/v1/scans/{scan}";
+        readonly pathParams: readonly ["scan"];
+        readonly queryParams: readonly [];
+        readonly body: false;
+        readonly idempotent: false;
+        readonly auth: true;
+        readonly scope: "scans:read";
+        readonly response: "json";
+        readonly list: false;
+        readonly paginated: false;
+        readonly summary: "Retrieve a scan";
+    };
+    readonly createEvaluation: {
+        readonly operationId: "createEvaluation";
+        readonly namespace: "evaluations";
+        readonly method: "create";
+        readonly httpMethod: "POST";
+        readonly path: "/v1/sites/{site}/evaluations";
+        readonly pathParams: readonly ["site"];
+        readonly queryParams: readonly [];
+        readonly body: true;
+        readonly idempotent: true;
+        readonly auth: true;
+        readonly scope: "evaluations:write";
+        readonly response: "json";
+        readonly list: false;
+        readonly paginated: false;
+        readonly summary: "Re-evaluate a site now";
+    };
+    readonly listEvaluations: {
+        readonly operationId: "listEvaluations";
+        readonly namespace: "evaluations";
+        readonly method: "list";
+        readonly httpMethod: "GET";
+        readonly path: "/v1/evaluations";
+        readonly pathParams: readonly [];
+        readonly queryParams: readonly ["limit", "starting_after", "ending_before", "site"];
+        readonly body: false;
+        readonly idempotent: false;
+        readonly auth: true;
+        readonly scope: "evaluations:read";
+        readonly response: "json";
+        readonly list: true;
+        readonly paginated: true;
+        readonly summary: "List evaluations";
+    };
+    readonly retrieveEvaluation: {
+        readonly operationId: "retrieveEvaluation";
+        readonly namespace: "evaluations";
+        readonly method: "retrieve";
+        readonly httpMethod: "GET";
+        readonly path: "/v1/evaluations/{evaluation}";
+        readonly pathParams: readonly ["evaluation"];
+        readonly queryParams: readonly [];
+        readonly body: false;
+        readonly idempotent: false;
+        readonly auth: true;
+        readonly scope: "evaluations:read";
+        readonly response: "json";
+        readonly list: false;
+        readonly paginated: false;
+        readonly summary: "Retrieve an evaluation";
+    };
+    readonly retrieveLatestEvaluation: {
+        readonly operationId: "retrieveLatestEvaluation";
+        readonly namespace: "evaluations";
+        readonly method: "retrieveLatest";
+        readonly httpMethod: "GET";
+        readonly path: "/v1/sites/{site}/evaluation";
+        readonly pathParams: readonly ["site"];
+        readonly queryParams: readonly [];
+        readonly body: false;
+        readonly idempotent: false;
+        readonly auth: true;
+        readonly scope: "evaluations:read";
+        readonly response: "json";
+        readonly list: false;
+        readonly paginated: false;
+        readonly summary: "Get the current verdict of a site";
+    };
+    readonly listFindings: {
+        readonly operationId: "listFindings";
+        readonly namespace: "findings";
+        readonly method: "list";
+        readonly httpMethod: "GET";
+        readonly path: "/v1/findings";
+        readonly pathParams: readonly [];
+        readonly queryParams: readonly ["limit", "starting_after", "ending_before", "site", "status", "state"];
+        readonly body: false;
+        readonly idempotent: false;
+        readonly auth: true;
+        readonly scope: "findings:read";
+        readonly response: "json";
+        readonly list: true;
+        readonly paginated: true;
+        readonly summary: "List findings";
+    };
+    readonly retrieveFinding: {
+        readonly operationId: "retrieveFinding";
+        readonly namespace: "findings";
+        readonly method: "retrieve";
+        readonly httpMethod: "GET";
+        readonly path: "/v1/findings/{finding}";
+        readonly pathParams: readonly ["finding"];
+        readonly queryParams: readonly [];
+        readonly body: false;
+        readonly idempotent: false;
+        readonly auth: true;
+        readonly scope: "findings:read";
+        readonly response: "json";
+        readonly list: false;
+        readonly paginated: false;
+        readonly summary: "Retrieve a finding";
+    };
+    readonly updateFinding: {
+        readonly operationId: "updateFinding";
+        readonly namespace: "findings";
+        readonly method: "update";
+        readonly httpMethod: "POST";
+        readonly path: "/v1/findings/{finding}";
+        readonly pathParams: readonly ["finding"];
+        readonly queryParams: readonly [];
+        readonly body: true;
+        readonly idempotent: true;
+        readonly auth: true;
+        readonly scope: "findings:write";
+        readonly response: "json";
+        readonly list: false;
+        readonly paginated: false;
+        readonly summary: "Triage a finding";
+    };
+    readonly retrieveCompliancePlan: {
+        readonly operationId: "retrieveCompliancePlan";
+        readonly namespace: "plans";
+        readonly method: "retrieve";
+        readonly httpMethod: "GET";
+        readonly path: "/v1/sites/{site}/plan";
+        readonly pathParams: readonly ["site"];
+        readonly queryParams: readonly [];
+        readonly body: false;
+        readonly idempotent: false;
+        readonly auth: true;
+        readonly scope: "compliance_plans:read";
+        readonly response: "json";
+        readonly list: false;
+        readonly paginated: false;
+        readonly summary: "Get the compliance plan for a site";
+    };
+    readonly retrieveTask: {
+        readonly operationId: "retrieveTask";
+        readonly namespace: "tasks";
+        readonly method: "retrieve";
+        readonly httpMethod: "GET";
+        readonly path: "/v1/tasks/{task}";
+        readonly pathParams: readonly ["task"];
+        readonly queryParams: readonly [];
+        readonly body: false;
+        readonly idempotent: false;
+        readonly auth: true;
+        readonly scope: "compliance_plans:read";
+        readonly response: "json";
+        readonly list: false;
+        readonly paginated: false;
+        readonly summary: "Get one task of a compliance plan";
+    };
+    readonly updateTask: {
+        readonly operationId: "updateTask";
+        readonly namespace: "tasks";
+        readonly method: "update";
+        readonly httpMethod: "POST";
+        readonly path: "/v1/tasks/{task}";
+        readonly pathParams: readonly ["task"];
+        readonly queryParams: readonly [];
+        readonly body: true;
+        readonly idempotent: true;
+        readonly auth: true;
+        readonly scope: "compliance_plans:write";
+        readonly response: "json";
+        readonly list: false;
+        readonly paginated: false;
+        readonly summary: "Claim, decline or reopen a task";
+    };
+    readonly answerTask: {
+        readonly operationId: "answerTask";
+        readonly namespace: "tasks";
+        readonly method: "answer";
+        readonly httpMethod: "POST";
+        readonly path: "/v1/tasks/{task}/answer";
+        readonly pathParams: readonly ["task"];
+        readonly queryParams: readonly [];
+        readonly body: true;
+        readonly idempotent: true;
+        readonly auth: true;
+        readonly scope: "compliance_plans:write";
+        readonly response: "json";
+        readonly list: false;
+        readonly paginated: false;
+        readonly summary: "Record the human answer to a manual task";
+    };
+    readonly verifyTask: {
+        readonly operationId: "verifyTask";
+        readonly namespace: "tasks";
+        readonly method: "verify";
+        readonly httpMethod: "POST";
+        readonly path: "/v1/tasks/{task}/verify";
+        readonly pathParams: readonly ["task"];
+        readonly queryParams: readonly ["wait"];
+        readonly body: true;
+        readonly idempotent: true;
+        readonly auth: true;
+        readonly scope: "compliance_plans:write";
+        readonly response: "json";
+        readonly list: false;
+        readonly paginated: false;
+        readonly summary: "Verify a task after applying its change";
+    };
+    readonly verifySite: {
+        readonly operationId: "verifySite";
+        readonly namespace: "sites";
+        readonly method: "verify";
+        readonly httpMethod: "POST";
+        readonly path: "/v1/sites/{site}/verify";
+        readonly pathParams: readonly ["site"];
+        readonly queryParams: readonly ["wait"];
+        readonly body: false;
+        readonly idempotent: true;
+        readonly auth: true;
+        readonly scope: "compliance_plans:write";
+        readonly response: "json";
+        readonly list: false;
+        readonly paginated: false;
+        readonly summary: "Re-check the whole site now";
+    };
+    readonly retrieveVerification: {
+        readonly operationId: "retrieveVerification";
+        readonly namespace: "verifications";
+        readonly method: "retrieve";
+        readonly httpMethod: "GET";
+        readonly path: "/v1/verifications/{verification}";
+        readonly pathParams: readonly ["verification"];
+        readonly queryParams: readonly ["wait"];
+        readonly body: false;
+        readonly idempotent: false;
+        readonly auth: true;
+        readonly scope: "compliance_plans:read";
+        readonly response: "json";
+        readonly list: false;
+        readonly paginated: false;
+        readonly summary: "Get a verification (long-poll with ?wait=30)";
+    };
+    readonly listVerifications: {
+        readonly operationId: "listVerifications";
+        readonly namespace: "verifications";
+        readonly method: "list";
+        readonly httpMethod: "GET";
+        readonly path: "/v1/sites/{site}/verifications";
+        readonly pathParams: readonly ["site"];
+        readonly queryParams: readonly ["limit", "starting_after", "ending_before", "task"];
+        readonly body: false;
+        readonly idempotent: false;
+        readonly auth: true;
+        readonly scope: "compliance_plans:read";
+        readonly response: "json";
+        readonly list: true;
+        readonly paginated: true;
+        readonly summary: "List verifications of a site";
+    };
+    readonly retrieveFindingFix: {
+        readonly operationId: "retrieveFindingFix";
+        readonly namespace: "fixes";
+        readonly method: "retrieve";
+        readonly httpMethod: "GET";
+        readonly path: "/v1/findings/{finding}/fix";
+        readonly pathParams: readonly ["finding"];
+        readonly queryParams: readonly ["plan", "cancel_url", "target"];
+        readonly body: false;
+        readonly idempotent: false;
+        readonly auth: true;
+        readonly scope: "fixes:read";
+        readonly response: "json";
+        readonly list: false;
+        readonly paginated: false;
+        readonly summary: "Get the fix for a finding";
+    };
+    readonly listSiteFixes: {
+        readonly operationId: "listSiteFixes";
+        readonly namespace: "fixes";
+        readonly method: "list";
+        readonly httpMethod: "GET";
+        readonly path: "/v1/sites/{site}/fixes";
+        readonly pathParams: readonly ["site"];
+        readonly queryParams: readonly ["plan", "cancel_url", "target"];
+        readonly body: false;
+        readonly idempotent: false;
+        readonly auth: true;
+        readonly scope: "fixes:read";
+        readonly response: "json";
+        readonly list: true;
+        readonly paginated: false;
+        readonly summary: "List fix plans for a site";
+    };
+    readonly listEvidence: {
+        readonly operationId: "listEvidence";
+        readonly namespace: "evidence";
+        readonly method: "list";
+        readonly httpMethod: "GET";
+        readonly path: "/v1/evidence";
+        readonly pathParams: readonly [];
+        readonly queryParams: readonly ["limit", "starting_after", "ending_before", "site", "kind"];
+        readonly body: false;
+        readonly idempotent: false;
+        readonly auth: true;
+        readonly scope: "evidence:read";
+        readonly response: "json";
+        readonly list: true;
+        readonly paginated: true;
+        readonly summary: "List evidence";
+    };
+    readonly retrieveEvidence: {
+        readonly operationId: "retrieveEvidence";
+        readonly namespace: "evidence";
+        readonly method: "retrieve";
+        readonly httpMethod: "GET";
+        readonly path: "/v1/evidence/{evidence}";
+        readonly pathParams: readonly ["evidence"];
+        readonly queryParams: readonly [];
+        readonly body: false;
+        readonly idempotent: false;
+        readonly auth: true;
+        readonly scope: "evidence:read";
+        readonly response: "json";
+        readonly list: false;
+        readonly paginated: false;
+        readonly summary: "Retrieve evidence metadata";
+    };
+    readonly downloadEvidenceContent: {
+        readonly operationId: "downloadEvidenceContent";
+        readonly namespace: "evidence";
+        readonly method: "downloadContent";
+        readonly httpMethod: "GET";
+        readonly path: "/v1/evidence/{evidence}/content";
+        readonly pathParams: readonly ["evidence"];
+        readonly queryParams: readonly [];
+        readonly body: false;
+        readonly idempotent: false;
+        readonly auth: true;
+        readonly scope: "evidence:read";
+        readonly response: "binary";
+        readonly list: false;
+        readonly paginated: false;
+        readonly summary: "Download evidence content";
+    };
+    readonly verifyEvidenceChain: {
+        readonly operationId: "verifyEvidenceChain";
+        readonly namespace: "evidence";
+        readonly method: "verifyChain";
+        readonly httpMethod: "POST";
+        readonly path: "/v1/sites/{site}/evidence/verify";
+        readonly pathParams: readonly ["site"];
+        readonly queryParams: readonly [];
+        readonly body: true;
+        readonly idempotent: false;
+        readonly auth: true;
+        readonly scope: "evidence:read";
+        readonly response: "json";
+        readonly list: false;
+        readonly paginated: false;
+        readonly summary: "Verify the evidence chain";
+    };
+    readonly listCertificates: {
+        readonly operationId: "listCertificates";
+        readonly namespace: "certificates";
+        readonly method: "list";
+        readonly httpMethod: "GET";
+        readonly path: "/v1/certificates";
+        readonly pathParams: readonly [];
+        readonly queryParams: readonly ["limit", "starting_after", "ending_before", "site"];
+        readonly body: false;
+        readonly idempotent: false;
+        readonly auth: true;
+        readonly scope: "certificates:read";
+        readonly response: "json";
+        readonly list: true;
+        readonly paginated: true;
+        readonly summary: "List certificates";
+    };
+    readonly retrieveCertificate: {
+        readonly operationId: "retrieveCertificate";
+        readonly namespace: "certificates";
+        readonly method: "retrieve";
+        readonly httpMethod: "GET";
+        readonly path: "/v1/certificates/{certificate}";
+        readonly pathParams: readonly ["certificate"];
+        readonly queryParams: readonly [];
+        readonly body: false;
+        readonly idempotent: false;
+        readonly auth: true;
+        readonly scope: "certificates:read";
+        readonly response: "json";
+        readonly list: false;
+        readonly paginated: false;
+        readonly summary: "Retrieve a certificate";
+    };
+    readonly createCertificate: {
+        readonly operationId: "createCertificate";
+        readonly namespace: "certificates";
+        readonly method: "create";
+        readonly httpMethod: "POST";
+        readonly path: "/v1/sites/{site}/certificates";
+        readonly pathParams: readonly ["site"];
+        readonly queryParams: readonly [];
+        readonly body: true;
+        readonly idempotent: true;
+        readonly auth: true;
+        readonly scope: "certificates:write";
+        readonly response: "json";
+        readonly list: false;
+        readonly paginated: false;
+        readonly summary: "Issue a certificate";
+    };
+    readonly revokeCertificate: {
+        readonly operationId: "revokeCertificate";
+        readonly namespace: "certificates";
+        readonly method: "revoke";
+        readonly httpMethod: "POST";
+        readonly path: "/v1/certificates/{certificate}/revoke";
+        readonly pathParams: readonly ["certificate"];
+        readonly queryParams: readonly [];
+        readonly body: true;
+        readonly idempotent: true;
+        readonly auth: true;
+        readonly scope: "certificates:write";
+        readonly response: "json";
+        readonly list: false;
+        readonly paginated: false;
+        readonly summary: "Revoke a certificate";
+    };
+    readonly retrieveNoticeSettings: {
+        readonly operationId: "retrieveNoticeSettings";
+        readonly namespace: "noticeSettings";
+        readonly method: "retrieve";
+        readonly httpMethod: "GET";
+        readonly path: "/v1/sites/{site}/notice_settings";
+        readonly pathParams: readonly ["site"];
+        readonly queryParams: readonly [];
+        readonly body: false;
+        readonly idempotent: false;
+        readonly auth: true;
+        readonly scope: "notices:read";
+        readonly response: "json";
+        readonly list: false;
+        readonly paginated: false;
+        readonly summary: "Retrieve notice settings";
+    };
+    readonly updateNoticeSettings: {
+        readonly operationId: "updateNoticeSettings";
+        readonly namespace: "noticeSettings";
+        readonly method: "update";
+        readonly httpMethod: "POST";
+        readonly path: "/v1/sites/{site}/notice_settings";
+        readonly pathParams: readonly ["site"];
+        readonly queryParams: readonly [];
+        readonly body: true;
+        readonly idempotent: true;
+        readonly auth: true;
+        readonly scope: "notices:write";
+        readonly response: "json";
+        readonly list: false;
+        readonly paginated: false;
+        readonly summary: "Update notice settings";
+    };
+    readonly listDueNotices: {
+        readonly operationId: "listDueNotices";
+        readonly namespace: "notices";
+        readonly method: "listDue";
+        readonly httpMethod: "GET";
+        readonly path: "/v1/notices/due";
+        readonly pathParams: readonly [];
+        readonly queryParams: readonly ["limit", "starting_after", "ending_before", "site", "status", "kind", "subscription"];
+        readonly body: false;
+        readonly idempotent: false;
+        readonly auth: true;
+        readonly scope: "notices:read";
+        readonly response: "json";
+        readonly list: true;
+        readonly paginated: true;
+        readonly summary: "List due notices";
+    };
+    readonly listNoticeTemplates: {
+        readonly operationId: "listNoticeTemplates";
+        readonly namespace: "notices";
+        readonly method: "listTemplates";
+        readonly httpMethod: "GET";
+        readonly path: "/v1/notices/templates";
+        readonly pathParams: readonly [];
+        readonly queryParams: readonly ["site"];
+        readonly body: false;
+        readonly idempotent: false;
+        readonly auth: true;
+        readonly scope: "notices:read";
+        readonly response: "json";
+        readonly list: true;
+        readonly paginated: false;
+        readonly summary: "List notice email templates";
+    };
+    readonly checkNoticeTemplate: {
+        readonly operationId: "checkNoticeTemplate";
+        readonly namespace: "notices";
+        readonly method: "checkTemplate";
+        readonly httpMethod: "POST";
+        readonly path: "/v1/notices/templates/check";
+        readonly pathParams: readonly [];
+        readonly queryParams: readonly [];
+        readonly body: true;
+        readonly idempotent: false;
+        readonly auth: true;
+        readonly scope: "notices:read";
+        readonly response: "json";
+        readonly list: false;
+        readonly paginated: false;
+        readonly summary: "Check a notice email template";
+    };
+    readonly retrieveDueNotice: {
+        readonly operationId: "retrieveDueNotice";
+        readonly namespace: "notices";
+        readonly method: "retrieve";
+        readonly httpMethod: "GET";
+        readonly path: "/v1/notices/{notice}";
+        readonly pathParams: readonly ["notice"];
+        readonly queryParams: readonly [];
+        readonly body: false;
+        readonly idempotent: false;
+        readonly auth: true;
+        readonly scope: "notices:read";
+        readonly response: "json";
+        readonly list: false;
+        readonly paginated: false;
+        readonly summary: "Retrieve a due notice";
+    };
+    readonly markNoticeSent: {
+        readonly operationId: "markNoticeSent";
+        readonly namespace: "notices";
+        readonly method: "markSent";
+        readonly httpMethod: "POST";
+        readonly path: "/v1/notices/{notice}/sent";
+        readonly pathParams: readonly ["notice"];
+        readonly queryParams: readonly [];
+        readonly body: true;
+        readonly idempotent: true;
+        readonly auth: true;
+        readonly scope: "notices:write";
+        readonly response: "json";
+        readonly list: false;
+        readonly paginated: false;
+        readonly summary: "Mark a due notice as sent";
+    };
+    readonly markNoticeMissed: {
+        readonly operationId: "markNoticeMissed";
+        readonly namespace: "notices";
+        readonly method: "markMissed";
+        readonly httpMethod: "POST";
+        readonly path: "/v1/notices/{notice}/missed";
+        readonly pathParams: readonly ["notice"];
+        readonly queryParams: readonly [];
+        readonly body: true;
+        readonly idempotent: true;
+        readonly auth: true;
+        readonly scope: "notices:write";
+        readonly response: "json";
+        readonly list: false;
+        readonly paginated: false;
+        readonly summary: "Record a due notice as missed";
+    };
+    readonly listLawUpdates: {
+        readonly operationId: "listLawUpdates";
+        readonly namespace: "lawUpdates";
+        readonly method: "list";
+        readonly httpMethod: "GET";
+        readonly path: "/v1/law_updates";
+        readonly pathParams: readonly [];
+        readonly queryParams: readonly ["limit", "starting_after", "ending_before", "since"];
+        readonly body: false;
+        readonly idempotent: false;
+        readonly auth: true;
+        readonly scope: "law_updates:read";
+        readonly response: "json";
+        readonly list: true;
+        readonly paginated: true;
+        readonly summary: "List law updates";
+    };
+    readonly retrieveLawUpdate: {
+        readonly operationId: "retrieveLawUpdate";
+        readonly namespace: "lawUpdates";
+        readonly method: "retrieve";
+        readonly httpMethod: "GET";
+        readonly path: "/v1/law_updates/{law_update}";
+        readonly pathParams: readonly ["law_update"];
+        readonly queryParams: readonly [];
+        readonly body: false;
+        readonly idempotent: false;
+        readonly auth: true;
+        readonly scope: "law_updates:read";
+        readonly response: "json";
+        readonly list: false;
+        readonly paginated: false;
+        readonly summary: "Retrieve a law update";
+    };
+    readonly checkDisclosure: {
+        readonly operationId: "checkDisclosure";
+        readonly namespace: "checks";
+        readonly method: "disclosure";
+        readonly httpMethod: "POST";
+        readonly path: "/v1/checks/disclosure";
+        readonly pathParams: readonly [];
+        readonly queryParams: readonly [];
+        readonly body: true;
+        readonly idempotent: false;
+        readonly auth: true;
+        readonly scope: "checks:read";
+        readonly response: "json";
+        readonly list: false;
+        readonly paginated: false;
+        readonly summary: "Check checkout disclosure text";
+    };
+    readonly checkStripeCheckoutSession: {
+        readonly operationId: "checkStripeCheckoutSession";
+        readonly namespace: "checks";
+        readonly method: "stripeCheckoutSession";
+        readonly httpMethod: "POST";
+        readonly path: "/v1/checks/stripe_checkout_session";
+        readonly pathParams: readonly [];
+        readonly queryParams: readonly [];
+        readonly body: true;
+        readonly idempotent: false;
+        readonly auth: true;
+        readonly scope: "checks:read";
+        readonly response: "json";
+        readonly list: false;
+        readonly paginated: false;
+        readonly summary: "Check Stripe Checkout Session params";
+    };
+    readonly checkStripePaymentLink: {
+        readonly operationId: "checkStripePaymentLink";
+        readonly namespace: "checks";
+        readonly method: "stripePaymentLink";
+        readonly httpMethod: "POST";
+        readonly path: "/v1/checks/stripe_payment_link";
+        readonly pathParams: readonly [];
+        readonly queryParams: readonly [];
+        readonly body: true;
+        readonly idempotent: false;
+        readonly auth: true;
+        readonly scope: "checks:read";
+        readonly response: "json";
+        readonly list: false;
+        readonly paginated: false;
+        readonly summary: "Check Stripe Payment Link params";
+    };
+    readonly checkEmail: {
+        readonly operationId: "checkEmail";
+        readonly namespace: "checks";
+        readonly method: "email";
+        readonly httpMethod: "POST";
+        readonly path: "/v1/checks/email";
+        readonly pathParams: readonly [];
+        readonly queryParams: readonly [];
+        readonly body: true;
+        readonly idempotent: false;
+        readonly auth: true;
+        readonly scope: "checks:read";
+        readonly response: "json";
+        readonly list: false;
+        readonly paginated: false;
+        readonly summary: "Check a subscription lifecycle email";
+    };
+    readonly checkPage: {
+        readonly operationId: "checkPage";
+        readonly namespace: "checks";
+        readonly method: "page";
+        readonly httpMethod: "POST";
+        readonly path: "/v1/checks/page";
+        readonly pathParams: readonly [];
+        readonly queryParams: readonly [];
+        readonly body: true;
+        readonly idempotent: false;
+        readonly auth: true;
+        readonly scope: "checks:read";
+        readonly response: "json";
+        readonly list: false;
+        readonly paginated: false;
+        readonly summary: "Check a checkout page (HTML or URL)";
+    };
+    readonly checkNoticeSchedule: {
+        readonly operationId: "checkNoticeSchedule";
+        readonly namespace: "checks";
+        readonly method: "noticeSchedule";
+        readonly httpMethod: "POST";
+        readonly path: "/v1/checks/notice_schedule";
+        readonly pathParams: readonly [];
+        readonly queryParams: readonly [];
+        readonly body: true;
+        readonly idempotent: false;
+        readonly auth: true;
+        readonly scope: "checks:read";
+        readonly response: "json";
+        readonly list: false;
+        readonly paginated: false;
+        readonly summary: "Get the dates each required notice must be sent";
+    };
+    readonly getElementsBundle: {
+        readonly operationId: "getElementsBundle";
+        readonly namespace: "elements";
+        readonly method: "retrieveBundle";
+        readonly httpMethod: "GET";
+        readonly path: "/v1/elements.js";
+        readonly pathParams: readonly [];
+        readonly queryParams: readonly [];
+        readonly body: false;
+        readonly idempotent: false;
+        readonly auth: false;
+        readonly scope: "none";
+        readonly response: "text";
+        readonly list: false;
+        readonly paginated: false;
+        readonly summary: "Load the Elements browser bundle";
+    };
+    readonly getElementsManifest: {
+        readonly operationId: "getElementsManifest";
+        readonly namespace: "elements";
+        readonly method: "retrieveManifest";
+        readonly httpMethod: "GET";
+        readonly path: "/v1/elements/manifest.json";
+        readonly pathParams: readonly [];
+        readonly queryParams: readonly [];
+        readonly body: false;
+        readonly idempotent: false;
+        readonly auth: false;
+        readonly scope: "none";
+        readonly response: "json";
+        readonly list: false;
+        readonly paginated: false;
+        readonly summary: "List Elements bundle versions and SRI hashes";
+    };
+    readonly getElementsBundleVersion: {
+        readonly operationId: "getElementsBundleVersion";
+        readonly namespace: "elements";
+        readonly method: "retrieveBundleVersion";
+        readonly httpMethod: "GET";
+        readonly path: "/v1/elements/{version}/elements.js";
+        readonly pathParams: readonly ["version"];
+        readonly queryParams: readonly [];
+        readonly body: false;
+        readonly idempotent: false;
+        readonly auth: false;
+        readonly scope: "none";
+        readonly response: "text";
+        readonly list: false;
+        readonly paginated: false;
+        readonly summary: "Load a pinned Elements bundle version";
+    };
+    readonly createDisclosure: {
+        readonly operationId: "createDisclosure";
+        readonly namespace: "disclosures";
+        readonly method: "create";
+        readonly httpMethod: "POST";
+        readonly path: "/v1/disclosures";
+        readonly pathParams: readonly [];
+        readonly queryParams: readonly [];
+        readonly body: true;
+        readonly idempotent: true;
+        readonly auth: true;
+        readonly scope: "consents:write";
+        readonly response: "json";
+        readonly list: false;
+        readonly paginated: false;
+        readonly summary: "Create a locked disclosure for a site";
+    };
+    readonly retrieveDisclosure: {
+        readonly operationId: "retrieveDisclosure";
+        readonly namespace: "disclosures";
+        readonly method: "retrieve";
+        readonly httpMethod: "GET";
+        readonly path: "/v1/disclosures/{disclosure}";
+        readonly pathParams: readonly ["disclosure"];
+        readonly queryParams: readonly [];
+        readonly body: false;
+        readonly idempotent: false;
+        readonly auth: true;
+        readonly scope: "publishable";
+        readonly response: "json";
+        readonly list: false;
+        readonly paginated: false;
+        readonly summary: "Retrieve a disclosure";
+    };
+    readonly createConsent: {
+        readonly operationId: "createConsent";
+        readonly namespace: "consents";
+        readonly method: "create";
+        readonly httpMethod: "POST";
+        readonly path: "/v1/consents";
+        readonly pathParams: readonly [];
+        readonly queryParams: readonly [];
+        readonly body: true;
+        readonly idempotent: true;
+        readonly auth: true;
+        readonly scope: "publishable";
+        readonly response: "json";
+        readonly list: false;
+        readonly paginated: false;
+        readonly summary: "Record a consent";
+    };
+    readonly listConsents: {
+        readonly operationId: "listConsents";
+        readonly namespace: "consents";
+        readonly method: "list";
+        readonly httpMethod: "GET";
+        readonly path: "/v1/consents";
+        readonly pathParams: readonly [];
+        readonly queryParams: readonly ["limit", "starting_after", "ending_before", "site", "customer_reference", "disclosure", "created_gte", "created_lte"];
+        readonly body: false;
+        readonly idempotent: false;
+        readonly auth: true;
+        readonly scope: "consents:read";
+        readonly response: "json";
+        readonly list: true;
+        readonly paginated: true;
+        readonly summary: "List consents";
+    };
+    readonly retrieveConsent: {
+        readonly operationId: "retrieveConsent";
+        readonly namespace: "consents";
+        readonly method: "retrieve";
+        readonly httpMethod: "GET";
+        readonly path: "/v1/consents/{consent}";
+        readonly pathParams: readonly ["consent"];
+        readonly queryParams: readonly [];
+        readonly body: false;
+        readonly idempotent: false;
+        readonly auth: true;
+        readonly scope: "consents:read";
+        readonly response: "json";
+        readonly list: false;
+        readonly paginated: false;
+        readonly summary: "Retrieve a consent";
+    };
+    readonly updateConsent: {
+        readonly operationId: "updateConsent";
+        readonly namespace: "consents";
+        readonly method: "update";
+        readonly httpMethod: "POST";
+        readonly path: "/v1/consents/{consent}";
+        readonly pathParams: readonly ["consent"];
+        readonly queryParams: readonly [];
+        readonly body: true;
+        readonly idempotent: true;
+        readonly auth: true;
+        readonly scope: "consents:write";
+        readonly response: "json";
+        readonly list: false;
+        readonly paginated: false;
+        readonly summary: "Attach a customer reference to a consent";
+    };
+    readonly createReceiptToken: {
+        readonly operationId: "createReceiptToken";
+        readonly namespace: "receiptTokens";
+        readonly method: "create";
+        readonly httpMethod: "POST";
+        readonly path: "/v1/receipt_tokens";
+        readonly pathParams: readonly [];
+        readonly queryParams: readonly [];
+        readonly body: true;
+        readonly idempotent: true;
+        readonly auth: true;
+        readonly scope: "receipts:write";
+        readonly response: "json";
+        readonly list: false;
+        readonly paginated: false;
+        readonly summary: "Mint a capture token for a checkout";
+    };
+    readonly createReceipt: {
+        readonly operationId: "createReceipt";
+        readonly namespace: "receipts";
+        readonly method: "create";
+        readonly httpMethod: "POST";
+        readonly path: "/v1/receipts";
+        readonly pathParams: readonly [];
+        readonly queryParams: readonly [];
+        readonly body: true;
+        readonly idempotent: true;
+        readonly auth: true;
+        readonly scope: "publishable";
+        readonly response: "json";
+        readonly list: false;
+        readonly paginated: false;
+        readonly summary: "Record a consent receipt";
+    };
+    readonly listReceipts: {
+        readonly operationId: "listReceipts";
+        readonly namespace: "receipts";
+        readonly method: "list";
+        readonly httpMethod: "GET";
+        readonly path: "/v1/receipts";
+        readonly pathParams: readonly [];
+        readonly queryParams: readonly ["limit", "starting_after", "ending_before", "site", "customer_reference", "checkout_session", "email", "source", "binding", "created_gte", "created_lte"];
+        readonly body: false;
+        readonly idempotent: false;
+        readonly auth: true;
+        readonly scope: "receipts:read";
+        readonly response: "json";
+        readonly list: true;
+        readonly paginated: true;
+        readonly summary: "List consent receipts";
+    };
+    readonly eraseReceipts: {
+        readonly operationId: "eraseReceipts";
+        readonly namespace: "receipts";
+        readonly method: "erase";
+        readonly httpMethod: "POST";
+        readonly path: "/v1/receipts/erase";
+        readonly pathParams: readonly [];
+        readonly queryParams: readonly [];
+        readonly body: true;
+        readonly idempotent: true;
+        readonly auth: true;
+        readonly scope: "receipts:write";
+        readonly response: "json";
+        readonly list: false;
+        readonly paginated: false;
+        readonly summary: "Erase a subscriber's receipts";
+    };
+    readonly retrieveReceipt: {
+        readonly operationId: "retrieveReceipt";
+        readonly namespace: "receipts";
+        readonly method: "retrieve";
+        readonly httpMethod: "GET";
+        readonly path: "/v1/receipts/{receipt}";
+        readonly pathParams: readonly ["receipt"];
+        readonly queryParams: readonly [];
+        readonly body: false;
+        readonly idempotent: false;
+        readonly auth: true;
+        readonly scope: "receipts:read";
+        readonly response: "json";
+        readonly list: false;
+        readonly paginated: false;
+        readonly summary: "Retrieve a consent receipt";
+    };
+    readonly renderReceipt: {
+        readonly operationId: "renderReceipt";
+        readonly namespace: "receipts";
+        readonly method: "render";
+        readonly httpMethod: "GET";
+        readonly path: "/v1/receipts/{receipt}/render.png";
+        readonly pathParams: readonly ["receipt"];
+        readonly queryParams: readonly [];
+        readonly body: false;
+        readonly idempotent: false;
+        readonly auth: true;
+        readonly scope: "receipts:read";
+        readonly response: "binary";
+        readonly list: false;
+        readonly paginated: false;
+        readonly summary: "Render a receipt as an image";
+    };
+    readonly verifyReceipt: {
+        readonly operationId: "verifyReceipt";
+        readonly namespace: "receipts";
+        readonly method: "verify";
+        readonly httpMethod: "GET";
+        readonly path: "/v1/receipts/{receipt}/verify";
+        readonly pathParams: readonly ["receipt"];
+        readonly queryParams: readonly [];
+        readonly body: false;
+        readonly idempotent: false;
+        readonly auth: true;
+        readonly scope: "receipts:read";
+        readonly response: "json";
+        readonly list: false;
+        readonly paginated: false;
+        readonly summary: "Verify a receipt's integrity";
+    };
+    readonly exportReceipt: {
+        readonly operationId: "exportReceipt";
+        readonly namespace: "receipts";
+        readonly method: "export";
+        readonly httpMethod: "GET";
+        readonly path: "/v1/receipts/{receipt}/export";
+        readonly pathParams: readonly ["receipt"];
+        readonly queryParams: readonly [];
+        readonly body: false;
+        readonly idempotent: false;
+        readonly auth: true;
+        readonly scope: "receipts:read";
+        readonly response: "binary";
+        readonly list: false;
+        readonly paginated: false;
+        readonly summary: "Download a self-verifying receipt bundle";
+    };
+    readonly retrieveReceiptSettings: {
+        readonly operationId: "retrieveReceiptSettings";
+        readonly namespace: "receiptSettings";
+        readonly method: "retrieve";
+        readonly httpMethod: "GET";
+        readonly path: "/v1/receipt_settings";
+        readonly pathParams: readonly [];
+        readonly queryParams: readonly [];
+        readonly body: false;
+        readonly idempotent: false;
+        readonly auth: true;
+        readonly scope: "receipts:read";
+        readonly response: "json";
+        readonly list: false;
+        readonly paginated: false;
+        readonly summary: "Retrieve receipt settings";
+    };
+    readonly updateReceiptSettings: {
+        readonly operationId: "updateReceiptSettings";
+        readonly namespace: "receiptSettings";
+        readonly method: "update";
+        readonly httpMethod: "POST";
+        readonly path: "/v1/receipt_settings";
+        readonly pathParams: readonly [];
+        readonly queryParams: readonly [];
+        readonly body: true;
+        readonly idempotent: true;
+        readonly auth: true;
+        readonly scope: "receipts:write";
+        readonly response: "json";
+        readonly list: false;
+        readonly paginated: false;
+        readonly summary: "Update receipt settings";
+    };
+    readonly createTestCredential: {
+        readonly operationId: "createTestCredential";
+        readonly namespace: "testCredentials";
+        readonly method: "create";
+        readonly httpMethod: "POST";
+        readonly path: "/v1/sites/{site}/test_credentials";
+        readonly pathParams: readonly ["site"];
+        readonly queryParams: readonly [];
+        readonly body: true;
+        readonly idempotent: true;
+        readonly auth: true;
+        readonly scope: "test_runs:write";
+        readonly response: "json";
+        readonly list: false;
+        readonly paginated: false;
+        readonly summary: "Store a billing test-mode key";
+    };
+    readonly listTestCredentials: {
+        readonly operationId: "listTestCredentials";
+        readonly namespace: "testCredentials";
+        readonly method: "list";
+        readonly httpMethod: "GET";
+        readonly path: "/v1/sites/{site}/test_credentials";
+        readonly pathParams: readonly ["site"];
+        readonly queryParams: readonly [];
+        readonly body: false;
+        readonly idempotent: false;
+        readonly auth: true;
+        readonly scope: "test_runs:read";
+        readonly response: "json";
+        readonly list: true;
+        readonly paginated: false;
+        readonly summary: "List billing test-mode keys of a site";
+    };
+    readonly deleteTestCredential: {
+        readonly operationId: "deleteTestCredential";
+        readonly namespace: "testCredentials";
+        readonly method: "del";
+        readonly httpMethod: "DELETE";
+        readonly path: "/v1/sites/{site}/test_credentials/{test_credential}";
+        readonly pathParams: readonly ["site", "test_credential"];
+        readonly queryParams: readonly [];
+        readonly body: false;
+        readonly idempotent: false;
+        readonly auth: true;
+        readonly scope: "test_runs:write";
+        readonly response: "json";
+        readonly list: false;
+        readonly paginated: false;
+        readonly summary: "Delete a billing test-mode key";
+    };
+    readonly createStripeCheckoutConfig: {
+        readonly operationId: "createStripeCheckoutConfig";
+        readonly namespace: "stripeCheckoutConfigs";
+        readonly method: "create";
+        readonly httpMethod: "POST";
+        readonly path: "/v1/sites/{site}/stripe_checkout_configs";
+        readonly pathParams: readonly ["site"];
+        readonly queryParams: readonly [];
+        readonly body: true;
+        readonly idempotent: true;
+        readonly auth: true;
+        readonly scope: "test_runs:write";
+        readonly response: "json";
+        readonly list: false;
+        readonly paginated: false;
+        readonly summary: "Register the Checkout Session params your code uses";
+    };
+    readonly listStripeCheckoutConfigs: {
+        readonly operationId: "listStripeCheckoutConfigs";
+        readonly namespace: "stripeCheckoutConfigs";
+        readonly method: "list";
+        readonly httpMethod: "GET";
+        readonly path: "/v1/sites/{site}/stripe_checkout_configs";
+        readonly pathParams: readonly ["site"];
+        readonly queryParams: readonly ["limit", "starting_after", "ending_before"];
+        readonly body: false;
+        readonly idempotent: false;
+        readonly auth: true;
+        readonly scope: "test_runs:read";
+        readonly response: "json";
+        readonly list: true;
+        readonly paginated: true;
+        readonly summary: "List registered checkout configs";
+    };
+    readonly retrieveStripeCheckoutConfig: {
+        readonly operationId: "retrieveStripeCheckoutConfig";
+        readonly namespace: "stripeCheckoutConfigs";
+        readonly method: "retrieve";
+        readonly httpMethod: "GET";
+        readonly path: "/v1/stripe_checkout_configs/{stripe_checkout_config}";
+        readonly pathParams: readonly ["stripe_checkout_config"];
+        readonly queryParams: readonly [];
+        readonly body: false;
+        readonly idempotent: false;
+        readonly auth: true;
+        readonly scope: "test_runs:read";
+        readonly response: "json";
+        readonly list: false;
+        readonly paginated: false;
+        readonly summary: "Retrieve a registered checkout config";
+    };
+    readonly deleteStripeCheckoutConfig: {
+        readonly operationId: "deleteStripeCheckoutConfig";
+        readonly namespace: "stripeCheckoutConfigs";
+        readonly method: "del";
+        readonly httpMethod: "DELETE";
+        readonly path: "/v1/stripe_checkout_configs/{stripe_checkout_config}";
+        readonly pathParams: readonly ["stripe_checkout_config"];
+        readonly queryParams: readonly [];
+        readonly body: false;
+        readonly idempotent: false;
+        readonly auth: true;
+        readonly scope: "test_runs:write";
+        readonly response: "json";
+        readonly list: false;
+        readonly paginated: false;
+        readonly summary: "Delete a registered checkout config";
+    };
+    readonly createTestRun: {
+        readonly operationId: "createTestRun";
+        readonly namespace: "testRuns";
+        readonly method: "create";
+        readonly httpMethod: "POST";
+        readonly path: "/v1/sites/{site}/test_runs";
+        readonly pathParams: readonly ["site"];
+        readonly queryParams: readonly [];
+        readonly body: true;
+        readonly idempotent: true;
+        readonly auth: true;
+        readonly scope: "test_runs:write";
+        readonly response: "json";
+        readonly list: false;
+        readonly paginated: false;
+        readonly summary: "Start a lifecycle test run";
+    };
+    readonly listTestRuns: {
+        readonly operationId: "listTestRuns";
+        readonly namespace: "testRuns";
+        readonly method: "list";
+        readonly httpMethod: "GET";
+        readonly path: "/v1/sites/{site}/test_runs";
+        readonly pathParams: readonly ["site"];
+        readonly queryParams: readonly ["limit", "starting_after", "ending_before"];
+        readonly body: false;
+        readonly idempotent: false;
+        readonly auth: true;
+        readonly scope: "test_runs:read";
+        readonly response: "json";
+        readonly list: true;
+        readonly paginated: true;
+        readonly summary: "List test runs of a site";
+    };
+    readonly retrieveTestRun: {
+        readonly operationId: "retrieveTestRun";
+        readonly namespace: "testRuns";
+        readonly method: "retrieve";
+        readonly httpMethod: "GET";
+        readonly path: "/v1/test_runs/{test_run}";
+        readonly pathParams: readonly ["test_run"];
+        readonly queryParams: readonly [];
+        readonly body: false;
+        readonly idempotent: false;
+        readonly auth: true;
+        readonly scope: "test_runs:read";
+        readonly response: "json";
+        readonly list: false;
+        readonly paginated: false;
+        readonly summary: "Retrieve a test run";
+    };
+    readonly cancelTestRun: {
+        readonly operationId: "cancelTestRun";
+        readonly namespace: "testRuns";
+        readonly method: "cancel";
+        readonly httpMethod: "POST";
+        readonly path: "/v1/test_runs/{test_run}/cancel";
+        readonly pathParams: readonly ["test_run"];
+        readonly queryParams: readonly [];
+        readonly body: false;
+        readonly idempotent: true;
+        readonly auth: true;
+        readonly scope: "test_runs:write";
+        readonly response: "json";
+        readonly list: false;
+        readonly paginated: false;
+        readonly summary: "Cancel a test run";
+    };
+    readonly createWebhookEndpoint: {
+        readonly operationId: "createWebhookEndpoint";
+        readonly namespace: "webhookEndpoints";
+        readonly method: "create";
+        readonly httpMethod: "POST";
+        readonly path: "/v1/webhook_endpoints";
+        readonly pathParams: readonly [];
+        readonly queryParams: readonly [];
+        readonly body: true;
+        readonly idempotent: true;
+        readonly auth: true;
+        readonly scope: "webhook_endpoints:write";
+        readonly response: "json";
+        readonly list: false;
+        readonly paginated: false;
+        readonly summary: "Create a webhook endpoint";
+    };
+    readonly listWebhookEndpoints: {
+        readonly operationId: "listWebhookEndpoints";
+        readonly namespace: "webhookEndpoints";
+        readonly method: "list";
+        readonly httpMethod: "GET";
+        readonly path: "/v1/webhook_endpoints";
+        readonly pathParams: readonly [];
+        readonly queryParams: readonly ["limit", "starting_after", "ending_before"];
+        readonly body: false;
+        readonly idempotent: false;
+        readonly auth: true;
+        readonly scope: "webhook_endpoints:read";
+        readonly response: "json";
+        readonly list: true;
+        readonly paginated: true;
+        readonly summary: "List webhook endpoints";
+    };
+    readonly retrieveWebhookEndpoint: {
+        readonly operationId: "retrieveWebhookEndpoint";
+        readonly namespace: "webhookEndpoints";
+        readonly method: "retrieve";
+        readonly httpMethod: "GET";
+        readonly path: "/v1/webhook_endpoints/{webhook_endpoint}";
+        readonly pathParams: readonly ["webhook_endpoint"];
+        readonly queryParams: readonly [];
+        readonly body: false;
+        readonly idempotent: false;
+        readonly auth: true;
+        readonly scope: "webhook_endpoints:read";
+        readonly response: "json";
+        readonly list: false;
+        readonly paginated: false;
+        readonly summary: "Retrieve a webhook endpoint";
+    };
+    readonly updateWebhookEndpoint: {
+        readonly operationId: "updateWebhookEndpoint";
+        readonly namespace: "webhookEndpoints";
+        readonly method: "update";
+        readonly httpMethod: "POST";
+        readonly path: "/v1/webhook_endpoints/{webhook_endpoint}";
+        readonly pathParams: readonly ["webhook_endpoint"];
+        readonly queryParams: readonly [];
+        readonly body: true;
+        readonly idempotent: true;
+        readonly auth: true;
+        readonly scope: "webhook_endpoints:write";
+        readonly response: "json";
+        readonly list: false;
+        readonly paginated: false;
+        readonly summary: "Update a webhook endpoint";
+    };
+    readonly deleteWebhookEndpoint: {
+        readonly operationId: "deleteWebhookEndpoint";
+        readonly namespace: "webhookEndpoints";
+        readonly method: "del";
+        readonly httpMethod: "DELETE";
+        readonly path: "/v1/webhook_endpoints/{webhook_endpoint}";
+        readonly pathParams: readonly ["webhook_endpoint"];
+        readonly queryParams: readonly [];
+        readonly body: false;
+        readonly idempotent: false;
+        readonly auth: true;
+        readonly scope: "webhook_endpoints:write";
+        readonly response: "json";
+        readonly list: false;
+        readonly paginated: false;
+        readonly summary: "Delete a webhook endpoint";
+    };
+    readonly rollWebhookEndpointSecret: {
+        readonly operationId: "rollWebhookEndpointSecret";
+        readonly namespace: "webhookEndpoints";
+        readonly method: "rollSecret";
+        readonly httpMethod: "POST";
+        readonly path: "/v1/webhook_endpoints/{webhook_endpoint}/roll_secret";
+        readonly pathParams: readonly ["webhook_endpoint"];
+        readonly queryParams: readonly [];
+        readonly body: true;
+        readonly idempotent: true;
+        readonly auth: true;
+        readonly scope: "webhook_endpoints:write";
+        readonly response: "json";
+        readonly list: false;
+        readonly paginated: false;
+        readonly summary: "Roll a webhook signing secret";
+    };
+    readonly listEvents: {
+        readonly operationId: "listEvents";
+        readonly namespace: "events";
+        readonly method: "list";
+        readonly httpMethod: "GET";
+        readonly path: "/v1/events";
+        readonly pathParams: readonly [];
+        readonly queryParams: readonly ["limit", "starting_after", "ending_before", "type", "created_gte", "created_lte"];
+        readonly body: false;
+        readonly idempotent: false;
+        readonly auth: true;
+        readonly scope: "events:read";
+        readonly response: "json";
+        readonly list: true;
+        readonly paginated: true;
+        readonly summary: "List events";
+    };
+    readonly retrieveEvent: {
+        readonly operationId: "retrieveEvent";
+        readonly namespace: "events";
+        readonly method: "retrieve";
+        readonly httpMethod: "GET";
+        readonly path: "/v1/events/{event}";
+        readonly pathParams: readonly ["event"];
+        readonly queryParams: readonly [];
+        readonly body: false;
+        readonly idempotent: false;
+        readonly auth: true;
+        readonly scope: "events:read";
+        readonly response: "json";
+        readonly list: false;
+        readonly paginated: false;
+        readonly summary: "Retrieve an event";
+    };
+    readonly createFeedback: {
+        readonly operationId: "createFeedback";
+        readonly namespace: "feedbacks";
+        readonly method: "create";
+        readonly httpMethod: "POST";
+        readonly path: "/v1/feedback";
+        readonly pathParams: readonly [];
+        readonly queryParams: readonly [];
+        readonly body: true;
+        readonly idempotent: true;
+        readonly auth: true;
+        readonly scope: "account:read";
+        readonly response: "json";
+        readonly list: false;
+        readonly paginated: false;
+        readonly summary: "Send feedback";
+    };
+};
+export interface OperationSpec {
+    operationId: string;
+    namespace: string;
+    method: string;
+    httpMethod: 'GET' | 'POST' | 'DELETE';
+    path: string;
+    pathParams: readonly string[];
+    queryParams: readonly string[];
+    body: boolean;
+    idempotent: boolean;
+    auth: boolean;
+    scope: string;
+    response: 'json' | 'binary' | 'text';
+    list: boolean;
+    paginated: boolean;
+    summary: string;
+}
+export type OperationId = keyof typeof OPERATIONS;
+/** Argument and result types per operation, for `checkbox.call(operationId, args)` (path params + params, flat). */
+export interface OperationTypes {
+    createDeviceAuthorization: {
+        args: T.DeviceAuthorizationParams;
+        response: T.DeviceAuthorization;
+    };
+    createDeviceToken: {
+        args: T.CreateDeviceTokenParams;
+        response: T.DeviceToken;
+    };
+    createSetupSession: {
+        args: T.SetupSessionUpdate;
+        response: T.SetupSession;
+    };
+    listSetupSessions: {
+        args: T.ListSetupSessionsParams;
+        response: T.SetupSessionList;
+    };
+    retrieveSetupSession: {
+        args: {
+            setup_session: string;
+        };
+        response: T.SetupSession;
+    };
+    updateSetupSession: {
+        args: {
+            setup_session: string;
+        } & T.SetupSessionUpdate;
+        response: T.SetupSession;
+    };
+    verifySetupSession: {
+        args: {
+            setup_session: string;
+        };
+        response: T.SetupVerification;
+    };
+    completeSetupSession: {
+        args: {
+            setup_session: string;
+        };
+        response: T.SetupSession;
+    };
+    retrieveAccount: {
+        args: Record<string, never>;
+        response: T.Account;
+    };
+    updateAccount: {
+        args: T.UpdateAccountParams;
+        response: T.Account;
+    };
+    listSites: {
+        args: T.ListSitesParams;
+        response: T.SiteList;
+    };
+    createSite: {
+        args: T.CreateSiteParams;
+        response: T.Site;
+    };
+    retrieveSite: {
+        args: {
+            site: string;
+        } & T.RetrieveSiteParams;
+        response: T.Site;
+    };
+    updateSite: {
+        args: {
+            site: string;
+        } & T.UpdateSiteParams;
+        response: T.Site;
+    };
+    deleteSite: {
+        args: {
+            site: string;
+        };
+        response: T.Site;
+    };
+    restoreSite: {
+        args: {
+            site: string;
+        };
+        response: T.Site;
+    };
+    connectBillingPlatform: {
+        args: {
+            site: string;
+        } & T.ConnectBillingPlatformParams;
+        response: T.Integration;
+    };
+    retrieveDomainVerification: {
+        args: {
+            site: string;
+        };
+        response: T.DomainVerification;
+    };
+    createDomainVerification: {
+        args: {
+            site: string;
+        } & T.CreateDomainVerificationParams;
+        response: T.DomainVerification;
+    };
+    checkDomainVerification: {
+        args: {
+            site: string;
+        };
+        response: T.DomainVerification;
+    };
+    createScan: {
+        args: {
+            site: string;
+        } & T.CreateScanParams;
+        response: T.Scan;
+    };
+    listScans: {
+        args: T.ListScansParams;
+        response: T.ScanList;
+    };
+    retrieveScan: {
+        args: {
+            scan: string;
+        };
+        response: T.Scan;
+    };
+    createEvaluation: {
+        args: {
+            site: string;
+        } & T.CreateEvaluationParams;
+        response: T.Evaluation;
+    };
+    listEvaluations: {
+        args: T.ListEvaluationsParams;
+        response: T.EvaluationList;
+    };
+    retrieveEvaluation: {
+        args: {
+            evaluation: string;
+        };
+        response: T.Evaluation;
+    };
+    retrieveLatestEvaluation: {
+        args: {
+            site: string;
+        };
+        response: T.Evaluation;
+    };
+    listFindings: {
+        args: T.ListFindingsParams;
+        response: T.FindingList;
+    };
+    retrieveFinding: {
+        args: {
+            finding: string;
+        };
+        response: T.Finding;
+    };
+    updateFinding: {
+        args: {
+            finding: string;
+        } & T.UpdateFindingParams;
+        response: T.Finding;
+    };
+    retrieveCompliancePlan: {
+        args: {
+            site: string;
+        };
+        response: T.CompliancePlan;
+    };
+    retrieveTask: {
+        args: {
+            task: string;
+        };
+        response: T.Task;
+    };
+    updateTask: {
+        args: {
+            task: string;
+        } & T.UpdateTaskParams;
+        response: T.Task;
+    };
+    answerTask: {
+        args: {
+            task: string;
+        } & T.AnswerTaskParams;
+        response: T.Task;
+    };
+    verifyTask: {
+        args: {
+            task: string;
+        } & T.VerifyTaskRequestParams;
+        response: T.Verification;
+    };
+    verifySite: {
+        args: {
+            site: string;
+        } & T.VerifySiteParams;
+        response: T.Verification;
+    };
+    retrieveVerification: {
+        args: {
+            verification: string;
+        } & T.RetrieveVerificationParams;
+        response: T.Verification;
+    };
+    listVerifications: {
+        args: {
+            site: string;
+        } & T.ListVerificationsParams;
+        response: T.VerificationList;
+    };
+    retrieveFindingFix: {
+        args: {
+            finding: string;
+        } & T.RetrieveFindingFixParams;
+        response: T.Fix;
+    };
+    listSiteFixes: {
+        args: {
+            site: string;
+        } & T.ListSiteFixesParams;
+        response: T.FixList;
+    };
+    listEvidence: {
+        args: T.ListEvidenceParams;
+        response: T.EvidenceList;
+    };
+    retrieveEvidence: {
+        args: {
+            evidence: string;
+        };
+        response: T.Evidence;
+    };
+    downloadEvidenceContent: {
+        args: {
+            evidence: string;
+        };
+        response: T.CheckboxFile;
+    };
+    verifyEvidenceChain: {
+        args: {
+            site: string;
+        } & T.VerifyEvidenceChainParams;
+        response: T.EvidenceChainVerification;
+    };
+    listCertificates: {
+        args: T.ListCertificatesParams;
+        response: T.CertificateList;
+    };
+    retrieveCertificate: {
+        args: {
+            certificate: string;
+        };
+        response: T.Certificate;
+    };
+    createCertificate: {
+        args: {
+            site: string;
+        } & T.CreateCertificateParams;
+        response: T.Certificate;
+    };
+    revokeCertificate: {
+        args: {
+            certificate: string;
+        } & T.RevokeCertificateParams;
+        response: T.Certificate;
+    };
+    retrieveNoticeSettings: {
+        args: {
+            site: string;
+        };
+        response: T.NoticeSettings;
+    };
+    updateNoticeSettings: {
+        args: {
+            site: string;
+        } & T.UpdateNoticeSettingsParams;
+        response: T.NoticeSettings;
+    };
+    listDueNotices: {
+        args: T.ListDueNoticesParams;
+        response: T.DueNoticeList;
+    };
+    listNoticeTemplates: {
+        args: T.ListNoticeTemplatesParams;
+        response: T.NoticeTemplateList;
+    };
+    checkNoticeTemplate: {
+        args: T.CheckNoticeTemplateParams;
+        response: T.NoticeTemplateCheck;
+    };
+    retrieveDueNotice: {
+        args: {
+            notice: string;
+        };
+        response: T.DueNotice;
+    };
+    markNoticeSent: {
+        args: {
+            notice: string;
+        } & T.MarkNoticeSentParams;
+        response: T.DueNotice;
+    };
+    markNoticeMissed: {
+        args: {
+            notice: string;
+        } & T.MarkNoticeMissedParams;
+        response: T.DueNotice;
+    };
+    listLawUpdates: {
+        args: T.ListLawUpdatesParams;
+        response: T.LawUpdateList;
+    };
+    retrieveLawUpdate: {
+        args: {
+            law_update: string;
+        };
+        response: T.LawUpdate;
+    };
+    checkDisclosure: {
+        args: T.DisclosureCheckParams;
+        response: T.DisclosureCheckResult;
+    };
+    checkStripeCheckoutSession: {
+        args: T.StripeCheckParams;
+        response: T.StripeCheckoutSessionCheckResult;
+    };
+    checkStripePaymentLink: {
+        args: T.StripeCheckParams;
+        response: T.StripePaymentLinkCheckResult;
+    };
+    checkEmail: {
+        args: T.EmailCheckParams;
+        response: T.EmailCheckResult;
+    };
+    checkPage: {
+        args: T.PageCheckParams;
+        response: T.PageCheckResult;
+    };
+    checkNoticeSchedule: {
+        args: T.NoticeScheduleParams;
+        response: T.NoticeScheduleResult;
+    };
+    getElementsBundle: {
+        args: Record<string, never>;
+        response: string;
+    };
+    getElementsManifest: {
+        args: Record<string, never>;
+        response: T.ElementsManifest;
+    };
+    getElementsBundleVersion: {
+        args: {
+            version: string;
+        };
+        response: string;
+    };
+    createDisclosure: {
+        args: T.DisclosureCreateParams;
+        response: T.Disclosure;
+    };
+    retrieveDisclosure: {
+        args: {
+            disclosure: string;
+        };
+        response: T.Disclosure;
+    };
+    createConsent: {
+        args: T.ConsentCreateParams;
+        response: T.Consent;
+    };
+    listConsents: {
+        args: T.ListConsentsParams;
+        response: T.ConsentList;
+    };
+    retrieveConsent: {
+        args: {
+            consent: string;
+        };
+        response: T.Consent;
+    };
+    updateConsent: {
+        args: {
+            consent: string;
+        } & T.ConsentUpdateParams;
+        response: T.Consent;
+    };
+    createReceiptToken: {
+        args: T.ReceiptTokenCreateParams;
+        response: T.ReceiptToken;
+    };
+    createReceipt: {
+        args: T.ReceiptCreateParams;
+        response: T.Receipt;
+    };
+    listReceipts: {
+        args: T.ListReceiptsParams;
+        response: T.ReceiptList;
+    };
+    eraseReceipts: {
+        args: T.ReceiptErasureParams;
+        response: T.ReceiptErasure;
+    };
+    retrieveReceipt: {
+        args: {
+            receipt: string;
+        };
+        response: T.Receipt;
+    };
+    renderReceipt: {
+        args: {
+            receipt: string;
+        };
+        response: T.CheckboxFile;
+    };
+    verifyReceipt: {
+        args: {
+            receipt: string;
+        };
+        response: T.ReceiptVerification;
+    };
+    exportReceipt: {
+        args: {
+            receipt: string;
+        };
+        response: T.CheckboxFile;
+    };
+    retrieveReceiptSettings: {
+        args: Record<string, never>;
+        response: T.ReceiptSettings;
+    };
+    updateReceiptSettings: {
+        args: T.ReceiptSettingsUpdateParams;
+        response: T.ReceiptSettings;
+    };
+    createTestCredential: {
+        args: {
+            site: string;
+        } & T.CreateTestCredentialParams;
+        response: T.TestCredential;
+    };
+    listTestCredentials: {
+        args: {
+            site: string;
+        };
+        response: T.TestCredentialList;
+    };
+    deleteTestCredential: {
+        args: {
+            site: string;
+            test_credential: string;
+        };
+        response: T.DeletedTestCredential;
+    };
+    createStripeCheckoutConfig: {
+        args: {
+            site: string;
+        } & T.CreateStripeCheckoutConfigParams;
+        response: T.StripeCheckoutConfig;
+    };
+    listStripeCheckoutConfigs: {
+        args: {
+            site: string;
+        } & T.ListStripeCheckoutConfigsParams;
+        response: T.StripeCheckoutConfigList;
+    };
+    retrieveStripeCheckoutConfig: {
+        args: {
+            stripe_checkout_config: string;
+        };
+        response: T.StripeCheckoutConfig;
+    };
+    deleteStripeCheckoutConfig: {
+        args: {
+            stripe_checkout_config: string;
+        };
+        response: T.DeletedStripeCheckoutConfig;
+    };
+    createTestRun: {
+        args: {
+            site: string;
+        } & T.CreateTestRunParams;
+        response: T.TestRun;
+    };
+    listTestRuns: {
+        args: {
+            site: string;
+        } & T.ListTestRunsParams;
+        response: T.TestRunList;
+    };
+    retrieveTestRun: {
+        args: {
+            test_run: string;
+        };
+        response: T.TestRun;
+    };
+    cancelTestRun: {
+        args: {
+            test_run: string;
+        };
+        response: T.TestRun;
+    };
+    createWebhookEndpoint: {
+        args: T.CreateWebhookEndpointParams;
+        response: T.WebhookEndpoint;
+    };
+    listWebhookEndpoints: {
+        args: T.ListWebhookEndpointsParams;
+        response: T.WebhookEndpointList;
+    };
+    retrieveWebhookEndpoint: {
+        args: {
+            webhook_endpoint: string;
+        };
+        response: T.WebhookEndpoint;
+    };
+    updateWebhookEndpoint: {
+        args: {
+            webhook_endpoint: string;
+        } & T.UpdateWebhookEndpointParams;
+        response: T.WebhookEndpoint;
+    };
+    deleteWebhookEndpoint: {
+        args: {
+            webhook_endpoint: string;
+        };
+        response: T.DeletedWebhookEndpoint;
+    };
+    rollWebhookEndpointSecret: {
+        args: {
+            webhook_endpoint: string;
+        } & T.RollWebhookEndpointSecretParams;
+        response: T.WebhookEndpoint;
+    };
+    listEvents: {
+        args: T.ListEventsParams;
+        response: T.EventList;
+    };
+    retrieveEvent: {
+        args: {
+            event: string;
+        };
+        response: T.Event;
+    };
+    createFeedback: {
+        args: T.FeedbackParams;
+        response: T.Feedback;
+    };
+}
+/** `checkbox.device` */
+export declare class DeviceResource extends Resource {
+    /**
+     * Start a device login (setup_checkbox).
+     *
+     * Public (no API key). Returns a device_code (keep it private), a user_code and verification_uri_complete. Show the human ONE line ("Open <verification_uri_complete> and click Approve"), open it in their browser when possible, then poll createDeviceToken every `interval` seconds. New users sign up on that page with an email link or GitHub / Google; nothing is created until they click Approve.
+     *
+     * @see POST /v1/device/authorize (operation `createDeviceAuthorization`, scope `none`)
+     */
+    authorize(params?: T.DeviceAuthorizationParams, options?: RequestOptions): Promise<T.DeviceAuthorization>;
+    /**
+     * Poll a device login for its keys.
+     *
+     * Public (no API key). Poll every `interval` seconds with the device_code. Errors (stable codes): authorization_pending (keep polling), slow_down (add 5 s), access_denied (the human clicked Deny: stop), expired_token (start again). On approval returns the keys exactly once, the setup session and the next action.
+     *
+     * @see POST /v1/device/token (operation `createDeviceToken`, scope `none`)
+     */
+    token(params: T.CreateDeviceTokenParams, options?: RequestOptions): Promise<T.DeviceToken>;
+}
+/** `checkbox.setupSessions` */
+export declare class SetupSessionsResource extends Resource {
+    /**
+     * Start a setup session (agents that already have a key).
+     *
+     * For agents that already hold a secret key (no device login): starts a setup session for a project with the same fields as updateSetupSession. `checkbox init` creates the session during the device login instead.
+     *
+     * @see POST /v1/setup_sessions (operation `createSetupSession`, scope `setup_sessions:write`)
+     */
+    create(params?: T.SetupSessionUpdate, options?: RequestOptions): Promise<T.SetupSession>;
+    /**
+     * List setup sessions.
+     *
+     * Setup sessions of the account, newest first. Test keys see the sessions created in test mode (device login, test keys); live keys see all.
+     *
+     * @see GET /v1/setup_sessions (operation `listSetupSessions`, scope `setup_sessions:read`)
+     */
+    list(params?: T.ListSetupSessionsParams, options?: RequestOptions): ApiListPromise<T.SetupSession>;
+    /**
+     * Retrieve a setup session.
+     *
+     * The setup checklist with one next_action. Agents: do next_action, then call verifySetupSession; stop when next_action.type is "done".
+     *
+     * @param setupSession Unique identifier of the setup session (setup_…).
+     * @see GET /v1/setup_sessions/{setup_session} (operation `retrieveSetupSession`, scope `setup_sessions:read`)
+     */
+    retrieve(setupSession: string, options?: RequestOptions): Promise<T.SetupSession>;
+    /**
+     * Report what the agent learned or changed.
+     *
+     * Reports project facts and business URLs: site_url (creates the test-mode site), checkout_url, terms_url / refund_url / cancellation_url / privacy_url (fetched now, stored as evidence and checked against the law), plans, where checkout code lives, snippet_installed_in, env_written. Returns the updated checklist.
+     *
+     * @param setupSession Unique identifier of the setup session (setup_…).
+     * @see POST /v1/setup_sessions/{setup_session} (operation `updateSetupSession`, scope `setup_sessions:write`)
+     */
+    update(setupSession: string, params?: T.SetupSessionUpdate, options?: RequestOptions): Promise<T.SetupSession>;
+    /**
+     * Re-check the site now.
+     *
+     * Loads the site (is the snippet live? which policy links does it have?), re-fetches the Terms and policies, re-evaluates compliance and queues the first synthetic-shopper scan. Call it after every change the agent made (and after deploying). Returns what was seen plus the updated session.
+     *
+     * @param setupSession Unique identifier of the setup session (setup_…).
+     * @see POST /v1/setup_sessions/{setup_session}/verify (operation `verifySetupSession`, scope `setup_sessions:write`)
+     */
+    verify(setupSession: string, options?: RequestOptions): Promise<T.SetupVerification>;
+    /**
+     * Finish the setup and notify the human.
+     *
+     * Marks the setup finished and emails the person who approved it a summary ("<agent> set up Checkbox for <domain>") with what was created, what is still open and a review link. Idempotent: the email is sent once. Checks keep running afterwards.
+     *
+     * @param setupSession Unique identifier of the setup session (setup_…).
+     * @see POST /v1/setup_sessions/{setup_session}/complete (operation `completeSetupSession`, scope `setup_sessions:write`)
+     */
+    complete(setupSession: string, options?: RequestOptions): Promise<T.SetupSession>;
+}
+/** `checkbox.account` */
+export declare class AccountResource extends Resource {
+    /**
+     * Retrieve the account.
+     *
+     * Returns the account behind the key: test or live mode, whether live mode is activated, fair-use limits, the publishable key, and `next_action`. Call this first to check a key.
+     *
+     * @see GET /v1/account (operation `retrieveAccount`, scope `account:read`)
+     */
+    retrieve(options?: RequestOptions): Promise<T.Account>;
+    /**
+     * Update the account.
+     *
+     * Pins the account to an API version (requests without a Checkbox-Version header use it). Known versions: 2026-10-30.
+     *
+     * @see POST /v1/account (operation `updateAccount`, scope `account:write`)
+     */
+    update(params?: T.UpdateAccountParams, options?: RequestOptions): Promise<T.Account>;
+}
+/** `checkbox.sites` */
+export declare class SitesResource extends Resource {
+    /**
+     * List sites.
+     *
+     * Returns the sites of the account in the current mode, newest first. Archived sites are included only with archived=true.
+     *
+     * @see GET /v1/sites (operation `listSites`, scope `sites:read`)
+     */
+    list(params?: T.ListSitesParams, options?: RequestOptions): ApiListPromise<T.Site>;
+    /**
+     * Create a site.
+     *
+     * Registers a subscription business. Only `url` is required; Checkbox derives the name and uses the URL as the checkout entry page. The response includes `install` (snippet tag, inbound email, platform webhook URLs). Next: install the snippet, then run createScan (or let `checkbox init` do both). In live mode before activation, monitoring is held until a domain is verified; in test mode, monitoring of a host that is not localhost or a domain the account verified is held the same way, and on-demand scans of such hosts are limited to a few a day.
+     *
+     * @see POST /v1/sites (operation `createSite`, scope `sites:write`)
+     */
+    create(params: T.CreateSiteParams, options?: RequestOptions): Promise<T.Site>;
+    /**
+     * Retrieve a site.
+     *
+     * Returns a site with its latest compliance verdict (score, insurable) and install details.
+     *
+     * @param site Unique identifier of the site (site_…).
+     * @see GET /v1/sites/{site} (operation `retrieveSite`, scope `sites:read`)
+     */
+    retrieve(site: string, params?: T.RetrieveSiteParams, options?: RequestOptions): Promise<T.Site>;
+    /**
+     * Update a site.
+     *
+     * Updates the given fields; omitted fields keep their values. Changing `url` to another domain forgets the domain verification and ends the active certificate.
+     *
+     * @param site Unique identifier of the site (site_…).
+     * @see POST /v1/sites/{site} (operation `updateSite`, scope `sites:write`)
+     */
+    update(site: string, params?: T.UpdateSiteParams, options?: RequestOptions): Promise<T.Site>;
+    /**
+     * Archive a site.
+     *
+     * Archives (soft-deletes) the site: monitoring stops and it disappears from lists, but evidence and findings are retained for the warranty. Undo with restoreSite.
+     *
+     * @param site Unique identifier of the site (site_…).
+     * @see DELETE /v1/sites/{site} (operation `deleteSite`, scope `sites:write`)
+     */
+    del(site: string, options?: RequestOptions): Promise<T.Site>;
+    /** Alias of `del()`. */
+    delete(site: string, options?: RequestOptions): Promise<T.Site>;
+    /**
+     * Restore an archived site.
+     *
+     * Un-archives a site (counts against the fair-use site limit again).
+     *
+     * @param site Unique identifier of the site (site_…).
+     * @see POST /v1/sites/{site}/restore (operation `restoreSite`, scope `sites:write`)
+     */
+    restore(site: string, options?: RequestOptions): Promise<T.Site>;
+    /**
+     * Connect a billing platform.
+     *
+     * Connects the site's billing platform with read-only credentials (a Stripe restricted key, a Recharge token or a Shopify Admin API token), so Checkbox reads the customer-portal and reminder settings. Works for test-mode sites too (use an rk_test_ key). The credentials are validated by reading the settings once and stored encrypted. Pilot fix: this used to be possible only in the dashboard, which could not open test-mode sites.
+     *
+     * @param site Unique identifier of the site (site_…).
+     * @see POST /v1/sites/{site}/integrations (operation `connectBillingPlatform`, scope `sites:write`)
+     */
+    connectBillingPlatform(site: string, params: T.ConnectBillingPlatformParams, options?: RequestOptions): Promise<T.Integration>;
+    /**
+     * Re-check the whole site now.
+     *
+     * Re-fetches the registered policies, pre-checks the checkout, re-evaluates and queues a scan. Use it for the first check after setup, or after applying several tasks. Pass ?wait=30 to long-poll; then get the plan (retrieveCompliancePlan).
+     *
+     * @param site Unique identifier of the site (site_…).
+     * @see POST /v1/sites/{site}/verify (operation `verifySite`, scope `compliance_plans:write`)
+     */
+    verify(site: string, params?: T.VerifySiteParams, options?: RequestOptions): Promise<T.Verification>;
+}
+/** `checkbox.domainVerifications` */
+export declare class DomainVerificationsResource extends Resource {
+    /**
+     * Retrieve domain verification.
+     *
+     * Status of the site domain verification, with the DNS record / file to publish.
+     *
+     * @param site Unique identifier of the site (site_…).
+     * @see GET /v1/sites/{site}/domain_verification (operation `retrieveDomainVerification`, scope `sites:read`)
+     */
+    retrieve(site: string, options?: RequestOptions): Promise<T.DomainVerification>;
+    /**
+     * Start domain verification.
+     *
+     * Starts verification of the site domain and returns a DNS TXT record and a /.well-known file; publishing either proves control. Then call checkDomainVerification. Verifying a live-mode site activates live mode for the account (instant, self-serve).
+     *
+     * @param site Unique identifier of the site (site_…).
+     * @see POST /v1/sites/{site}/domain_verification (operation `createDomainVerification`, scope `sites:write`)
+     */
+    create(site: string, params?: T.CreateDomainVerificationParams, options?: RequestOptions): Promise<T.DomainVerification>;
+    /**
+     * Check domain verification now.
+     *
+     * Looks for the DNS TXT record and the /.well-known file now. On success in live mode, the account is activated and held monitoring starts.
+     *
+     * @param site Unique identifier of the site (site_…).
+     * @see POST /v1/sites/{site}/domain_verification/check (operation `checkDomainVerification`, scope `sites:write`)
+     */
+    check(site: string, options?: RequestOptions): Promise<T.DomainVerification>;
+}
+/** `checkbox.scans` */
+export declare class ScansResource extends Resource {
+    /**
+     * Run a scan.
+     *
+     * Queues a synthetic-shopper scan of the site. Poll retrieveScan (or wait for the scan.completed webhook); a scan takes 1-3 minutes. When it completes, the evaluation and findings are updated. In live mode the account must be activated.
+     *
+     * @param site Unique identifier of the site (site_…).
+     * @see POST /v1/sites/{site}/scans (operation `createScan`, scope `scans:write`, live mode needs an activated account)
+     */
+    create(site: string, params?: T.CreateScanParams, options?: RequestOptions): Promise<T.Scan>;
+    /**
+     * List scans.
+     *
+     * Scans newest first, optionally for one site.
+     *
+     * @see GET /v1/scans (operation `listScans`, scope `scans:read`)
+     */
+    list(params?: T.ListScansParams, options?: RequestOptions): ApiListPromise<T.Scan>;
+    /**
+     * Retrieve a scan.
+     *
+     * Returns a scan. When status is completed, `evaluation` names the verdict (retrieveEvaluation).
+     *
+     * @param scan Unique identifier of the scan (scan_…).
+     * @see GET /v1/scans/{scan} (operation `retrieveScan`, scope `scans:read`)
+     */
+    retrieve(scan: string, options?: RequestOptions): Promise<T.Scan>;
+}
+/** `checkbox.evaluations` */
+export declare class EvaluationsResource extends Resource {
+    /**
+     * Re-evaluate a site now.
+     *
+     * Re-runs the legal rules against the evidence already collected (no new scan) and returns the verdict synchronously. Use after changing site facts, or to get a verdict right after evidence arrived.
+     *
+     * @param site Unique identifier of the site (site_…).
+     * @see POST /v1/sites/{site}/evaluations (operation `createEvaluation`, scope `evaluations:write`)
+     */
+    create(site: string, params?: T.CreateEvaluationParams, options?: RequestOptions): Promise<T.Evaluation>;
+    /**
+     * List evaluations.
+     *
+     * Verdicts newest first (score history), optionally for one site.
+     *
+     * @see GET /v1/evaluations (operation `listEvaluations`, scope `evaluations:read`)
+     */
+    list(params?: T.ListEvaluationsParams, options?: RequestOptions): ApiListPromise<T.Evaluation>;
+    /**
+     * Retrieve an evaluation.
+     *
+     * Returns one verdict with all checks and the insurability blockers.
+     *
+     * @param evaluation Unique identifier of the evaluation (eval_…).
+     * @see GET /v1/evaluations/{evaluation} (operation `retrieveEvaluation`, scope `evaluations:read`)
+     */
+    retrieve(evaluation: string, options?: RequestOptions): Promise<T.Evaluation>;
+    /**
+     * Get the current verdict of a site.
+     *
+     * The latest evaluation of the site: is it compliant (score) and insurable, and what blocks it. 404 resource_missing with next_action createScan when the site was never evaluated.
+     *
+     * @param site Unique identifier of the site (site_…).
+     * @see GET /v1/sites/{site}/evaluation (operation `retrieveLatestEvaluation`, scope `evaluations:read`)
+     */
+    retrieveLatest(site: string, options?: RequestOptions): Promise<T.Evaluation>;
+}
+/** `checkbox.findings` */
+export declare class FindingsResource extends Resource {
+    /**
+     * List findings.
+     *
+     * Findings ordered by urgency (failing first, then by severity). Filter by site, status (fail, needs_review, pass, not_applicable) and state (open, acknowledged, resolved, accepted_risk). Fix the open `fail` findings to become compliant.
+     *
+     * @see GET /v1/findings (operation `listFindings`, scope `findings:read`)
+     */
+    list(params?: T.ListFindingsParams, options?: RequestOptions): ApiListPromise<T.Finding>;
+    /**
+     * Retrieve a finding.
+     *
+     * One finding with its legal requirements (citations), evidence references and remediation.
+     *
+     * @param finding Unique identifier of the finding (fnd_…).
+     * @see GET /v1/findings/{finding} (operation `retrieveFinding`, scope `findings:read`)
+     */
+    retrieve(finding: string, options?: RequestOptions): Promise<T.Finding>;
+    /**
+     * Triage a finding.
+     *
+     * Sets the triage state (open, acknowledged, accepted_risk, resolved) and an optional note. Triage does not change the check result; fixing the issue and re-scanning does.
+     *
+     * @param finding Unique identifier of the finding (fnd_…).
+     * @see POST /v1/findings/{finding} (operation `updateFinding`, scope `findings:write`)
+     */
+    update(finding: string, params: T.UpdateFindingParams, options?: RequestOptions): Promise<T.Finding>;
+}
+/** `checkbox.plans` */
+export declare class PlansResource extends Resource {
+    /**
+     * Get the compliance plan for a site.
+     *
+     * Ordered tasks that make the site compliant, recomputed from its latest evaluation: each with the requirement and citation, where to change (file / URL / selector / Stripe object), the exact change (unified-diff template with machine-applicable edits, copy, or Stripe params) and how to verify it. Do plan.next_action: apply the first open task, call verifyTask, repeat until status is compliant. Tasks with status manual hold a question for the human (answerTask); they never block the others.
+     *
+     * @param site Unique identifier of the site (site_…).
+     * @see GET /v1/sites/{site}/plan (operation `retrieveCompliancePlan`, scope `compliance_plans:read`)
+     */
+    retrieve(site: string, options?: RequestOptions): Promise<T.CompliancePlan>;
+}
+/** `checkbox.tasks` */
+export declare class TasksResource extends Resource {
+    /**
+     * Get one task of a compliance plan.
+     *
+     * The task as in the current plan (recomputed): the change to apply, how to verify, its last verification and next_action.
+     *
+     * @param task Unique identifier of the task (task_…).
+     * @see GET /v1/tasks/{task} (operation `retrieveTask`, scope `compliance_plans:read`)
+     */
+    retrieve(task: string, options?: RequestOptions): Promise<T.Task>;
+    /**
+     * Claim, decline or reopen a task.
+     *
+     * status in_progress claims the task (shown to other agents and the dashboard); wont_fix declines it with a reason (the merchant's decision, recorded; a declined critical or high task keeps the plan blocked); open clears the decision. Applying a change does not need this call: call verifyTask.
+     *
+     * @param task Unique identifier of the task (task_…).
+     * @see POST /v1/tasks/{task} (operation `updateTask`, scope `compliance_plans:write`)
+     */
+    update(task: string, params: T.UpdateTaskParams, options?: RequestOptions): Promise<T.Task>;
+    /**
+     * Record the human answer to a manual task.
+     *
+     * For tasks with status manual: record the human's answer to task.question (ask them; never answer on their behalf). Answers that assert a legal fact (yes, confirmed) are stored as a proposal and return next_action.type "ask_human_to_confirm" with a link the human opens while signed in to Checkbox; only their confirmation writes the attestation, sets the site fact and re-evaluates. no / needs_change turn the task into a change for the agent; done (after a dashboard-only step) re-checks at once. Every answer is stored in the evidence vault.
+     *
+     * @param task Unique identifier of the task (task_…).
+     * @see POST /v1/tasks/{task}/answer (operation `answerTask`, scope `compliance_plans:write`)
+     */
+    answer(task: string, params: T.AnswerTaskParams, options?: RequestOptions): Promise<T.Task>;
+    /**
+     * Verify a task after applying its change.
+     *
+     * Runs the fastest re-check that can confirm the task (static fetch of the live checkout or the html you send, the Stripe params you send, the email copy you send, a re-fetch of the Terms) and queues the confirming observation (a scan, a billing-platform sync, the next email). A failing pre-check fails the verification at once with a diff. Pass ?wait=30 to long-poll; otherwise poll retrieveVerification or wait for the task.verified webhook. Then follow next_action.
+     *
+     * @param task Unique identifier of the task (task_…).
+     * @see POST /v1/tasks/{task}/verify (operation `verifyTask`, scope `compliance_plans:write`)
+     */
+    verify(task: string, params?: T.VerifyTaskRequestParams, options?: RequestOptions): Promise<T.Verification>;
+}
+/** `checkbox.verifications` */
+export declare class VerificationsResource extends Resource {
+    /**
+     * Get a verification (long-poll with ?wait=30).
+     *
+     * The verification's status (pending, passed, failed), expected vs observed per check, the diff and next_action. ?wait=N (≤ 30) holds the request until it resolves or N seconds pass.
+     *
+     * @param verification Unique identifier of the verification (ver_…).
+     * @see GET /v1/verifications/{verification} (operation `retrieveVerification`, scope `compliance_plans:read`)
+     */
+    retrieve(verification: string, params?: T.RetrieveVerificationParams, options?: RequestOptions): Promise<T.Verification>;
+    /**
+     * List verifications of a site.
+     *
+     * Verifications newest first (optionally for one task).
+     *
+     * @param site Unique identifier of the site (site_…).
+     * @see GET /v1/sites/{site}/verifications (operation `listVerifications`, scope `compliance_plans:read`)
+     */
+    list(site: string, params?: T.ListVerificationsParams, options?: RequestOptions): ApiListPromise<T.Verification>;
+}
+/** `checkbox.fixes` */
+export declare class FixesResource extends Resource {
+    /**
+     * Get the fix for a finding.
+     *
+     * The concrete change that makes the finding pass: verified disclosure text and code for the detected platform, or the generic remediation. Apply it, then re-scan (createScan) or re-evaluate.
+     *
+     * @param finding Unique identifier of the finding (fnd_…).
+     * @see GET /v1/findings/{finding}/fix (operation `retrieveFindingFix`, scope `fixes:read`)
+     */
+    retrieve(finding: string, params?: T.RetrieveFindingFixParams, options?: RequestOptions): Promise<T.Fix>;
+    /**
+     * List fix plans for a site.
+     *
+     * Site-level fix plans: the sign-up disclosure fix and the cancellation fix (hosted cancellation page), each with the checks it covers.
+     *
+     * @param site Unique identifier of the site (site_…).
+     * @see GET /v1/sites/{site}/fixes (operation `listSiteFixes`, scope `fixes:read`)
+     */
+    list(site: string, params?: T.ListSiteFixesParams, options?: RequestOptions): Promise<T.FixList>;
+}
+/** `checkbox.evidence` */
+export declare class EvidenceResource extends Resource {
+    /**
+     * List evidence.
+     *
+     * Evidence records of a site, newest first. Use downloadEvidenceContent for the raw bytes.
+     *
+     * @see GET /v1/evidence (operation `listEvidence`, scope `evidence:read`)
+     */
+    list(params: T.ListEvidenceParams, options?: RequestOptions): ApiListPromise<T.Evidence>;
+    /**
+     * Retrieve evidence metadata.
+     *
+     * One evidence record (hashes, metadata, content URL).
+     *
+     * @param evidence Unique identifier of the evidence (ev_…).
+     * @see GET /v1/evidence/{evidence} (operation `retrieveEvidence`, scope `evidence:read`)
+     */
+    retrieve(evidence: string, options?: RequestOptions): Promise<T.Evidence>;
+    /**
+     * Download evidence content.
+     *
+     * The raw stored bytes (screenshot, HTML, raw email…). The X-Evidence-Sha256 header carries the hash to check.
+     *
+     * @param evidence Unique identifier of the evidence (ev_…).
+     * @see GET /v1/evidence/{evidence}/content (operation `downloadEvidenceContent`, scope `evidence:read`)
+     */
+    downloadContent(evidence: string, options?: RequestOptions): Promise<T.CheckboxFile>;
+    /**
+     * Verify the evidence chain.
+     *
+     * Re-reads and re-hashes every evidence record of the site and checks the hash chain and signed anchors.
+     *
+     * @param site Unique identifier of the site (site_…).
+     * @see POST /v1/sites/{site}/evidence/verify (operation `verifyEvidenceChain`, scope `evidence:read`)
+     */
+    verifyChain(site: string, params?: T.VerifyEvidenceChainParams, options?: RequestOptions): Promise<T.EvidenceChainVerification>;
+}
+/** `checkbox.certificates` */
+export declare class CertificatesResource extends Resource {
+    /**
+     * List certificates.
+     *
+     * Certificates newest first, optionally for one site.
+     *
+     * @see GET /v1/certificates (operation `listCertificates`, scope `certificates:read`)
+     */
+    list(params?: T.ListCertificatesParams, options?: RequestOptions): ApiListPromise<T.Certificate>;
+    /**
+     * Retrieve a certificate.
+     *
+     * One certificate with its verification URL and badge embed code.
+     *
+     * @param certificate Unique identifier of the certificate (cert_…).
+     * @see GET /v1/certificates/{certificate} (operation `retrieveCertificate`, scope `certificates:read`)
+     */
+    retrieve(certificate: string, options?: RequestOptions): Promise<T.Certificate>;
+    /**
+     * Issue a certificate.
+     *
+     * Issues a signed monitoring certificate once the site has been insurable for the required streak of days with a verified domain and fresh scans. Otherwise fails with resource_conflict and next_action describing what is missing.
+     *
+     * @param site Unique identifier of the site (site_…).
+     * @see POST /v1/sites/{site}/certificates (operation `createCertificate`, scope `certificates:write`, live mode needs an activated account)
+     */
+    create(site: string, params?: T.CreateCertificateParams, options?: RequestOptions): Promise<T.Certificate>;
+    /**
+     * Revoke a certificate.
+     *
+     * Revokes an active certificate. The reason stays private; the verification page shows "revoked by merchant".
+     *
+     * @param certificate Unique identifier of the certificate (cert_…).
+     * @see POST /v1/certificates/{certificate}/revoke (operation `revokeCertificate`, scope `certificates:write`)
+     */
+    revoke(certificate: string, params: T.RevokeCertificateParams, options?: RequestOptions): Promise<T.Certificate>;
+}
+/** `checkbox.noticeSettings` */
+export declare class NoticeSettingsResource extends Resource {
+    /**
+     * Retrieve notice settings.
+     *
+     * Who sends the site's required emails (mode), the BCC address, which notices Checkbox sends in checkbox mode, and what to do next (next_action).
+     *
+     * @param site Unique identifier of the site (site_…).
+     * @see GET /v1/sites/{site}/notice_settings (operation `retrieveNoticeSettings`, scope `notices:read`)
+     */
+    retrieve(site: string, options?: RequestOptions): Promise<T.NoticeSettings>;
+    /**
+     * Update notice settings.
+     *
+     * Chooses who sends the required emails (mode: merchant = you send them and Checkbox tracks them, the default; checkbox = Checkbox sends them), and sets branding, cancel_url and the confirmed cancellation policy. In checkbox mode, turning a notice on (enabled_kinds) requires cancel_url, a confirmed policy, a connected Stripe or Recharge account and a sending address; otherwise resource_conflict explains what is missing.
+     *
+     * @param site Unique identifier of the site (site_…).
+     * @see POST /v1/sites/{site}/notice_settings (operation `updateNoticeSettings`, scope `notices:write`, live mode needs an activated account)
+     */
+    update(site: string, params?: T.UpdateNoticeSettingsParams, options?: RequestOptions): Promise<T.NoticeSettings>;
+}
+/** `checkbox.notices` */
+export declare class NoticesResource extends Resource {
+    /**
+     * List due notices.
+     *
+     * The legally required emails you owe subscribers (sites in "You send" mode, the default): kind, the subscriber (billing-platform ids), the legal window for the subscriber's state, the recommended send date, the copy-ready email and the BCC address. Default: everything not yet sent (upcoming, due, overdue), soonest first. Live keys list live subscribers' notices, test keys test-mode ones. Send each one on its send_date (inside its window), then call markNoticeSent (or BCC the notice's bcc address). Subscribe to the notice.due webhook to get each one on its send date.
+     *
+     * @see GET /v1/notices/due (operation `listDueNotices`, scope `notices:read`)
+     */
+    listDue(params?: T.ListDueNoticesParams, options?: RequestOptions): ApiListPromise<T.DueNotice>;
+    /**
+     * List notice email templates.
+     *
+     * Copy-ready HTML + text templates for every required notice (acknowledgment with and without a trial, trial ending, renewal, yearly terms, price change, cancellation confirmation), with {{merge_fields}}. Each passes the preflight email check for its kind when filled. Pass ?site= to get each kind's BCC address too. Adapt one, then call checkNoticeTemplate.
+     *
+     * @see GET /v1/notices/templates (operation `listNoticeTemplates`, scope `notices:read`)
+     */
+    listTemplates(params?: T.ListNoticeTemplatesParams, options?: RequestOptions): Promise<T.NoticeTemplateList>;
+    /**
+     * Check a notice email template.
+     *
+     * Checks your own version of a notice email: Checkbox fills the merge fields with the site's plan, brand and cancel URL (sample dates), then runs the preflight email check for the kind across the site's jurisdictions. Stateless. Fix what fails (or start from listNoticeTemplates) and check again until verdict is pass.
+     *
+     * @see POST /v1/notices/templates/check (operation `checkNoticeTemplate`, scope `notices:read`)
+     */
+    checkTemplate(params: T.CheckNoticeTemplateParams, options?: RequestOptions): Promise<T.NoticeTemplateCheck>;
+    /**
+     * Retrieve a due notice.
+     *
+     * One notice you owe a subscriber, with its window, recommended send date, copy-ready email, BCC address and send status.
+     *
+     * @param notice Unique identifier of the due notice (ntd_…).
+     * @see GET /v1/notices/{notice} (operation `retrieveDueNotice`, scope `notices:read`)
+     */
+    retrieve(notice: string, options?: RequestOptions): Promise<T.DueNotice>;
+    /**
+     * Mark a due notice as sent.
+     *
+     * Records that you sent this notice (optionally with your email provider's message id). Idempotent: a notice already marked sent is returned unchanged. A send before window_start is refused (it does not satisfy the law: send again inside the window). An overdue notice marked sent stops failing its check and is recorded as late; a sent_at earlier than when it became overdue is refused (only the BCC copy can prove an in-window send). Canceled and missed notices cannot be marked. BCC'ing the notice's bcc address does the same with the email itself as evidence.
+     *
+     * @param notice Unique identifier of the due notice (ntd_…).
+     * @see POST /v1/notices/{notice}/sent (operation `markNoticeSent`, scope `notices:write`)
+     */
+    markSent(notice: string, params?: T.MarkNoticeSentParams, options?: RequestOptions): Promise<T.DueNotice>;
+    /**
+     * Record a due notice as missed.
+     *
+     * Records that an overdue notice was not sent and will not be (for example, the subscriber already left). Nothing is attested as sent: the notice moves to missed and stops failing its compliance check, and the record stays in the history. Only overdue notices can be recorded as missed. Idempotent.
+     *
+     * @param notice Unique identifier of the due notice (ntd_…).
+     * @see POST /v1/notices/{notice}/missed (operation `markNoticeMissed`, scope `notices:write`)
+     */
+    markMissed(notice: string, params?: T.MarkNoticeMissedParams, options?: RequestOptions): Promise<T.DueNotice>;
+}
+/** `checkbox.lawUpdates` */
+export declare class LawUpdatesResource extends Resource {
+    /**
+     * List law updates.
+     *
+     * Law changes newest first, each with its effect on this account's sites.
+     *
+     * @see GET /v1/law_updates (operation `listLawUpdates`, scope `law_updates:read`)
+     */
+    list(params?: T.ListLawUpdatesParams, options?: RequestOptions): ApiListPromise<T.LawUpdate>;
+    /**
+     * Retrieve a law update.
+     *
+     * One law change with its effect on this account's sites.
+     *
+     * @param lawUpdate Unique identifier of the law update (law_…).
+     * @see GET /v1/law_updates/{law_update} (operation `retrieveLawUpdate`, scope `law_updates:read`)
+     */
+    retrieve(lawUpdate: string, options?: RequestOptions): Promise<T.LawUpdate>;
+}
+/** `checkbox.checks` */
+export declare class ChecksResource extends Resource {
+    /**
+     * Check checkout disclosure text.
+     *
+     * Checks the automatic-renewal disclosure you are about to show next to a subscribe button: what it says (renewal until canceled, price, frequency, trial, term, how to cancel), where it sits (above the button, same page) and how it looks (size, contrast, set off), and the consent checkbox (present, not pre-checked). Returns the verdict per check and per legal requirement, plus `replacement`: compliant text and drop-in HTML generated from your price/interval/trial/cancel_url and verified by the engine. Call it whenever you write or change checkout copy. Stateless and deterministic: nothing is stored, the same input on the same as_of date gives the same verdicts. Every verdict comes from the Checkbox rules engine over the legal catalog (federal ROSCA / EFTA plus the state automatic-renewal laws); the response carries rules_version, catalog_version and a disclaimer (not legal advice). Read `verdict`, then `next_action`: it tells you exactly what to change and to call the check again until verdict is pass.
+     *
+     * @see POST /v1/checks/disclosure (operation `checkDisclosure`, scope `checks:read`)
+     */
+    disclosure(params: T.DisclosureCheckParams, options?: RequestOptions): Promise<T.DisclosureCheckResult>;
+    /**
+     * Check Stripe Checkout Session params.
+     *
+     * Pass exactly the object your code gives stripe.checkout.sessions.create (plus merchant.merchant_name and merchant.cancel_url, and merchant.price/interval when line_items use a Price id). Checkbox models the Stripe-hosted page those params render and returns findings plus `correction`: a JSON Patch (RFC 6902) and the full corrected params (custom_text.submit with the renewal terms, consent_collection.terms_of_service = "required", custom_text.terms_of_service_acceptance as the consent label), verified by the engine. Stripe's own small grey styling keeps "clear and conspicuous" at needs_review on any Stripe-hosted page; also show the terms on your page before redirecting. Stateless and deterministic: nothing is stored, the same input on the same as_of date gives the same verdicts. Every verdict comes from the Checkbox rules engine over the legal catalog (federal ROSCA / EFTA plus the state automatic-renewal laws); the response carries rules_version, catalog_version and a disclaimer (not legal advice). Read `verdict`, then `next_action`: it tells you exactly what to change and to call the check again until verdict is pass.
+     *
+     * @see POST /v1/checks/stripe_checkout_session (operation `checkStripeCheckoutSession`, scope `checks:read`)
+     */
+    stripeCheckoutSession(params: T.StripeCheckParams, options?: RequestOptions): Promise<T.StripeCheckoutSessionCheckResult>;
+    /**
+     * Check Stripe Payment Link params.
+     *
+     * Like checkStripeCheckoutSession, for stripe.paymentLinks.create params or a retrieved Payment Link object. For an existing link (params.id) the correction also gives update_params for stripe.paymentLinks.update (same URL); Stripe cannot add a consent checkbox to an existing link, so needs_new_link_for_consent says when a new link (corrected_params) is required. Stateless and deterministic: nothing is stored, the same input on the same as_of date gives the same verdicts. Every verdict comes from the Checkbox rules engine over the legal catalog (federal ROSCA / EFTA plus the state automatic-renewal laws); the response carries rules_version, catalog_version and a disclaimer (not legal advice). Read `verdict`, then `next_action`: it tells you exactly what to change and to call the check again until verdict is pass.
+     *
+     * @see POST /v1/checks/stripe_payment_link (operation `checkStripePaymentLink`, scope `checks:read`)
+     */
+    stripePaymentLink(params: T.StripeCheckParams, options?: RequestOptions): Promise<T.StripePaymentLinkCheckResult>;
+    /**
+     * Check a subscription lifecycle email.
+     *
+     * Checks the content of an acknowledgment (welcome) email, trial-ending reminder, renewal reminder, price-change notice, yearly terms reminder or cancellation confirmation against the requirements for that notice (renewal terms, amount, frequency, how to cancel, trial cancellation). The email is modelled as sent on time, so the verdict is about content; get send dates from checkNoticeSchedule. Returns `required_by` (requirements that make the email mandatory for this plan) and a compliant `template` with {{merge_tags}}, verified by the engine. Stateless and deterministic: nothing is stored, the same input on the same as_of date gives the same verdicts. Every verdict comes from the Checkbox rules engine over the legal catalog (federal ROSCA / EFTA plus the state automatic-renewal laws); the response carries rules_version, catalog_version and a disclaimer (not legal advice). Read `verdict`, then `next_action`: it tells you exactly what to change and to call the check again until verdict is pass.
+     *
+     * @see POST /v1/checks/email (operation `checkEmail`, scope `checks:read`)
+     */
+    email(params: T.EmailCheckParams, options?: RequestOptions): Promise<T.EmailCheckResult>;
+    /**
+     * Check a checkout page (HTML or URL).
+     *
+     * Reads a checkout page's HTML (send the rendered HTML of client-side apps) with Checkbox's static extractor — purchase buttons, terms blocks, consent checkboxes, terms links — and runs the sign-up checks on it. Without a browser, placement and conspicuousness are estimates: a passing estimate is reported as needs_review (with static_estimate), never as pass; install the snippet or run a scan after deploying for rendered measurements. `url` (instead of html) fetches a public page and needs a live-mode key on an activated account. Pass terms to compare the disclosed price with your real one and get a verified replacement. Stateless and deterministic: nothing is stored, the same input on the same as_of date gives the same verdicts. Every verdict comes from the Checkbox rules engine over the legal catalog (federal ROSCA / EFTA plus the state automatic-renewal laws); the response carries rules_version, catalog_version and a disclaimer (not legal advice). Read `verdict`, then `next_action`: it tells you exactly what to change and to call the check again until verdict is pass.
+     *
+     * @see POST /v1/checks/page (operation `checkPage`, scope `checks:read`)
+     */
+    page(params?: T.PageCheckParams, options?: RequestOptions): Promise<T.PageCheckResult>;
+    /**
+     * Get the dates each required notice must be sent.
+     *
+     * For a subscription plan (price, interval, trial) and where you sell, returns every legally required notice — acknowledgment, trial-ending reminder, renewal reminders, yearly terms reminder, price-change notice — with the recommended send time and the compliant window (opens / closes), the jurisdictions each send satisfies and the citations. Uses the same timing as Checkbox Notices: per-state windows intersected, or the fewest sends that cover conflicting windows. Stateless. Check each email's content with checkEmail, or let Checkbox Notices send them.
+     *
+     * @see POST /v1/checks/notice_schedule (operation `checkNoticeSchedule`, scope `checks:read`)
+     */
+    noticeSchedule(params: T.NoticeScheduleParams, options?: RequestOptions): Promise<T.NoticeScheduleResult>;
+}
+/** `checkbox.elements` */
+export declare class ElementsResource extends Resource {
+    /**
+     * Load the Elements browser bundle.
+     *
+     * The current elements.js (registers <checkbox-disclosure>). For production pin a version with SRI: use the script_tag from getElementsManifest or createDisclosure.
+     *
+     * @see GET /v1/elements.js (operation `getElementsBundle`, scope `none`)
+     */
+    retrieveBundle(options?: RequestOptions): Promise<string>;
+    /**
+     * List Elements bundle versions and SRI hashes.
+     *
+     * Released elements.js versions with their immutable URLs and Subresource Integrity hashes, plus a ready-to-paste script tag for the latest one.
+     *
+     * @see GET /v1/elements/manifest.json (operation `getElementsManifest`, scope `none`)
+     */
+    retrieveManifest(options?: RequestOptions): Promise<T.ElementsManifest>;
+    /**
+     * Load a pinned Elements bundle version.
+     *
+     * An immutable elements.js release (cached for a year). Its integrity hash is in getElementsManifest.
+     *
+     * @param versionId Semver, e.g. 1.0.0.
+     * @see GET /v1/elements/{version}/elements.js (operation `getElementsBundleVersion`, scope `none`)
+     */
+    retrieveBundleVersion(versionId: string, options?: RequestOptions): Promise<string>;
+}
+/** `checkbox.disclosures` */
+export declare class DisclosuresResource extends Resource {
+    /**
+     * Create a locked disclosure for a site.
+     *
+     * Generates the locked automatic-renewal disclosure and consent label for the site's terms (from the billing connection, the given terms, or both), verifies with the rules engine that the element passes the sign-up checks on your checkout, and returns the markup to paste above your pay button. Next: put script_tag in <head> and element_html directly above the pay button, then call listConsents after a test sign-up.
+     *
+     * @see POST /v1/disclosures (operation `createDisclosure`, scope `consents:write`)
+     */
+    create(params: T.DisclosureCreateParams, options?: RequestOptions): Promise<T.Disclosure>;
+    /**
+     * Retrieve a disclosure.
+     *
+     * The locked disclosure text, consent label and terms. Works with the publishable key from the site's own pages (this is how <checkbox-disclosure disclosure="disc_…"> loads its text).
+     *
+     * @param disclosure Unique identifier of the disclosure (disc_…).
+     * @see GET /v1/disclosures/{disclosure} (operation `retrieveDisclosure`, scope `publishable`)
+     */
+    retrieve(disclosure: string, options?: RequestOptions): Promise<T.Disclosure>;
+}
+/** `checkbox.consents` */
+export declare class ConsentsResource extends Resource {
+    /**
+     * Record a consent.
+     *
+     * Records that a subscriber ticked the consent checkbox for the exact disclosure shown: stored with the text, its hashes, the terms, the page, a hash of the user agent and your customer reference, written to the site's hash-chained evidence vault, and fed to the compliance evaluation as corroborating evidence. <checkbox-disclosure> calls this with the publishable key (Origin-checked); servers may call it with a secret key and site. Next: attach the returned cons_… id to the subscription (metadata.checkbox_consent) or call updateConsent.
+     *
+     * @see POST /v1/consents (operation `createConsent`, scope `publishable`)
+     */
+    create(params: T.ConsentCreateParams, options?: RequestOptions): Promise<T.Consent>;
+    /**
+     * List consents.
+     *
+     * Consents, newest first. Filter by site, customer_reference (e.g. find the consent behind a disputed Stripe subscription), disclosure or creation time.
+     *
+     * @see GET /v1/consents (operation `listConsents`, scope `consents:read`)
+     */
+    list(params?: T.ListConsentsParams, options?: RequestOptions): ApiListPromise<T.Consent>;
+    /**
+     * Retrieve a consent.
+     *
+     * A consent record: what the subscriber saw and agreed to, when, where, and its evidence record. Use it to answer a chargeback or a regulator: the evidence id verifies against the site's hash chain (verifyEvidenceChain) and downloads with downloadEvidenceContent.
+     *
+     * @param consent Unique identifier of the consent (cons_…).
+     * @see GET /v1/consents/{consent} (operation `retrieveConsent`, scope `consents:read`)
+     */
+    retrieve(consent: string, options?: RequestOptions): Promise<T.Consent>;
+    /**
+     * Attach a customer reference to a consent.
+     *
+     * Sets customer_reference once (e.g. the Stripe subscription id created after the consent) and merges metadata. A different reference on a consent that already has one answers 409 consent_reference_locked. The change is appended to the evidence chain.
+     *
+     * @param consent Unique identifier of the consent (cons_…).
+     * @see POST /v1/consents/{consent} (operation `updateConsent`, scope `consents:write`)
+     */
+    update(consent: string, params?: T.ConsentUpdateParams, options?: RequestOptions): Promise<T.Consent>;
+}
+/** `checkbox.receiptTokens` */
+export declare class ReceiptTokensResource extends Resource {
+    /**
+     * Mint a capture token for a checkout.
+     *
+     * Call from your server when you render a checkout page: returns a short-lived token (rct_…) to put into the page (data-receipt-token on the disclosure or form, or receipt-token on <checkbox-disclosure>). Receipts that present it are "bound" to this checkout and carry your customer_reference; receipts without one are accepted but flagged "unbound". For Stripe-hosted checkouts also set metadata.checkbox_receipt_token=<id> on the Checkout Session (or pass checkout_session here).
+     *
+     * @see POST /v1/receipt_tokens (operation `createReceiptToken`, scope `receipts:write`)
+     */
+    create(params: T.ReceiptTokenCreateParams, options?: RequestOptions): Promise<T.ReceiptToken>;
+}
+/** `checkbox.receipts` */
+export declare class ReceiptsResource extends Resource {
+    /**
+     * Record a consent receipt.
+     *
+     * Records one receipt from the structured snapshot the browser captured at submit (the /r.js snippet add-on calls this with the publishable key, Origin-checked; servers may call it with a secret key and site). The snapshot is validated strictly and re-sanitized. Next: retrieveReceipt / renderReceipt to see it, verifyReceipt to check its integrity.
+     *
+     * @see POST /v1/receipts (operation `createReceipt`, scope `publishable`)
+     */
+    create(params: T.ReceiptCreateParams, options?: RequestOptions): Promise<T.Receipt>;
+    /**
+     * List consent receipts.
+     *
+     * Receipts newest first. Filter by site, customer_reference (find the receipt behind a disputed subscription), checkout_session, email (hashed before the lookup), source, binding or creation time.
+     *
+     * @see GET /v1/receipts (operation `listReceipts`, scope `receipts:read`)
+     */
+    list(params?: T.ListReceiptsParams, options?: RequestOptions): ApiListPromise<T.Receipt>;
+    /**
+     * Erase a subscriber's receipts.
+     *
+     * For a subscriber's deletion request: deletes every receipt that matches customer_reference, email (hashed before the lookup) or checkout_session (optionally only for one site). The signed copy in the write-once evidence vault is kept but holds only a salted commitment to the subscriber's identifiers; erasing destroys the salt, so it can no longer be tied to the person. Pending attorney review.
+     *
+     * @see POST /v1/receipts/erase (operation `eraseReceipts`, scope `receipts:write`)
+     */
+    erase(params?: T.ReceiptErasureParams, options?: RequestOptions): Promise<T.ReceiptErasure>;
+    /**
+     * Retrieve a consent receipt.
+     *
+     * What one subscriber saw and agreed to at checkout: disclosure text and presentation, checkbox state and label, button label, page, time, binding, flags and integrity data. renderReceipt shows it as an image; exportReceipt downloads a self-verifying bundle.
+     *
+     * @param receipt Unique identifier of the receipt (rcpt_…).
+     * @see GET /v1/receipts/{receipt} (operation `retrieveReceipt`, scope `receipts:read`)
+     */
+    retrieve(receipt: string, options?: RequestOptions): Promise<T.Receipt>;
+    /**
+     * Render a receipt as an image.
+     *
+     * A PNG of "what the subscriber saw", rendered on demand in an isolated Chromium (no network, scripts disabled) from the sanitized snapshot — a reconstruction, labeled as such, not a screenshot taken from the browser.
+     *
+     * @param receipt Unique identifier of the receipt (rcpt_…).
+     * @see GET /v1/receipts/{receipt}/render.png (operation `renderReceipt`, scope `receipts:read`)
+     */
+    render(receipt: string, options?: RequestOptions): Promise<T.CheckboxFile>;
+    /**
+     * Verify a receipt's integrity.
+     *
+     * Re-hashes the stored receipt, checks Checkbox's Ed25519 signature over its hash and chain position, and verifies the site's evidence chain. For a check that does not rely on Checkbox, download exportReceipt and run its verify.mjs.
+     *
+     * @param receipt Unique identifier of the receipt (rcpt_…).
+     * @see GET /v1/receipts/{receipt}/verify (operation `verifyReceipt`, scope `receipts:read`)
+     */
+    verify(receipt: string, options?: RequestOptions): Promise<T.ReceiptVerification>;
+    /**
+     * Download a self-verifying receipt bundle.
+     *
+     * ZIP for a lawyer, insurer or court expert: manifest.json (the receipt's evidence record with its chain links) + manifest.sig.json, the canonical receipt JSON under records/, receipt.sig.json (Checkbox's signature over the receipt hash), receipt.png and render.html (the reconstruction), README.md and verify.mjs (zero-dependency offline verifier: node verify.mjs --keys checkbox-keys.json).
+     *
+     * @param receipt Unique identifier of the receipt (rcpt_…).
+     * @see GET /v1/receipts/{receipt}/export (operation `exportReceipt`, scope `receipts:read`)
+     */
+    export(receipt: string, options?: RequestOptions): Promise<T.CheckboxFile>;
+}
+/** `checkbox.receiptSettings` */
+export declare class ReceiptSettingsResource extends Resource {
+    /**
+     * Retrieve receipt settings.
+     *
+     * Whether consent receipts are collected for this account (in this mode) and how long they are kept.
+     *
+     * @see GET /v1/receipt_settings (operation `retrieveReceiptSettings`, scope `receipts:read`)
+     */
+    retrieve(options?: RequestOptions): Promise<T.ReceiptSettings>;
+    /**
+     * Update receipt settings.
+     *
+     * Turn receipts on or off and set the retention in days (default 1461 = 4 years, the California UCL limitation period; pending attorney review). A new retention applies to receipts recorded afterwards.
+     *
+     * @see POST /v1/receipt_settings (operation `updateReceiptSettings`, scope `receipts:write`)
+     */
+    update(params?: T.ReceiptSettingsUpdateParams, options?: RequestOptions): Promise<T.ReceiptSettings>;
+}
+/** `checkbox.testCredentials` */
+export declare class TestCredentialsResource extends Resource {
+    /**
+     * Store a billing test-mode key.
+     *
+     * Stores the site's Stripe TEST-mode key (rk_test_… preferred) used by test runs, after checking it with Stripe. Live keys are refused (test_key_not_test_mode). Least privilege: Write on Customers, Checkout Sessions, Subscriptions, Test clocks and Customer portal; Read on Prices, Products and Billing portal configuration. Replaces an existing key. Next: createTestRun.
+     *
+     * @param site Unique identifier of the site (site_…).
+     * @see POST /v1/sites/{site}/test_credentials (operation `createTestCredential`, scope `test_runs:write`)
+     */
+    create(site: string, params: T.CreateTestCredentialParams, options?: RequestOptions): Promise<T.TestCredential>;
+    /**
+     * List billing test-mode keys of a site.
+     *
+     * The site's stored test-mode keys (hints only).
+     *
+     * @param site Unique identifier of the site (site_…).
+     * @see GET /v1/sites/{site}/test_credentials (operation `listTestCredentials`, scope `test_runs:read`)
+     */
+    list(site: string, options?: RequestOptions): Promise<T.TestCredentialList>;
+    /**
+     * Delete a billing test-mode key.
+     *
+     * Deletes the stored key. Running test runs fail at their next Stripe call.
+     *
+     * @param site Unique identifier of the site (site_…).
+     * @param testCredential Unique identifier of the test credential (tcred_…).
+     * @see DELETE /v1/sites/{site}/test_credentials/{test_credential} (operation `deleteTestCredential`, scope `test_runs:write`)
+     */
+    del(site: string, testCredential: string, options?: RequestOptions): Promise<T.DeletedTestCredential>;
+    /** Alias of `del()`. */
+    delete(site: string, testCredential: string, options?: RequestOptions): Promise<T.DeletedTestCredential>;
+}
+/** `checkbox.stripeCheckoutConfigs` */
+export declare class StripeCheckoutConfigsResource extends Resource {
+    /**
+     * Register the Checkout Session params your code uses.
+     *
+     * Registers exactly the object your code passes to stripe.checkout.sessions.create (customer, URLs and secrets are not needed and are ignored). Test runs mirror it into Stripe test mode; when it matches your latest live checkout, the scanned test page counts as an observation of your live checkout. Re-register after changing your checkout code, then call createTestRun.
+     *
+     * @param site Unique identifier of the site (site_…).
+     * @see POST /v1/sites/{site}/stripe_checkout_configs (operation `createStripeCheckoutConfig`, scope `test_runs:write`)
+     */
+    create(site: string, params: T.CreateStripeCheckoutConfigParams, options?: RequestOptions): Promise<T.StripeCheckoutConfig>;
+    /**
+     * List registered checkout configs.
+     *
+     * Registered Checkout Session configs of the site, newest first (test runs mirror the newest by default).
+     *
+     * @param site Unique identifier of the site (site_…).
+     * @see GET /v1/sites/{site}/stripe_checkout_configs (operation `listStripeCheckoutConfigs`, scope `test_runs:read`)
+     */
+    list(site: string, params?: T.ListStripeCheckoutConfigsParams, options?: RequestOptions): ApiListPromise<T.StripeCheckoutConfig>;
+    /**
+     * Retrieve a registered checkout config.
+     *
+     * One registered Checkout Session config.
+     *
+     * @param stripeCheckoutConfig Unique identifier of the stripe checkout config (scc_…).
+     * @see GET /v1/stripe_checkout_configs/{stripe_checkout_config} (operation `retrieveStripeCheckoutConfig`, scope `test_runs:read`)
+     */
+    retrieve(stripeCheckoutConfig: string, options?: RequestOptions): Promise<T.StripeCheckoutConfig>;
+    /**
+     * Delete a registered checkout config.
+     *
+     * Deletes the config; later runs mirror the next newest one (or your live checkout).
+     *
+     * @param stripeCheckoutConfig Unique identifier of the stripe checkout config (scc_…).
+     * @see DELETE /v1/stripe_checkout_configs/{stripe_checkout_config} (operation `deleteStripeCheckoutConfig`, scope `test_runs:write`)
+     */
+    del(stripeCheckoutConfig: string, options?: RequestOptions): Promise<T.DeletedStripeCheckoutConfig>;
+    /** Alias of `del()`. */
+    delete(stripeCheckoutConfig: string, options?: RequestOptions): Promise<T.DeletedStripeCheckoutConfig>;
+}
+/** `checkbox.testRuns` */
+export declare class TestRunsResource extends Resource {
+    /**
+     * Start a lifecycle test run.
+     *
+     * Starts a synthetic test subscription in TEST mode and returns it queued. Stripe runs mirror your checkout into a test-mode Checkout Session, subscribe a test customer (card 4242) whose email is a Checkbox inbox, wait for your acknowledgment, advance a test clock through every legal notice window before trial end and renewal, cancel online in the customer portal and wait for the confirmation; then delete the test clock. Takes about 5-20 minutes: poll retrieveTestRun (next_action says when) or listen for test_run.completed. Each step reports observations, check results and agent-readable fixes; apply them and run again to verify.
+     *
+     * @param site Unique identifier of the site (site_…).
+     * @see POST /v1/sites/{site}/test_runs (operation `createTestRun`, scope `test_runs:write`, live mode needs an activated account)
+     */
+    create(site: string, params?: T.CreateTestRunParams, options?: RequestOptions): Promise<T.TestRun>;
+    /**
+     * List test runs of a site.
+     *
+     * Test runs of the site, newest first.
+     *
+     * @param site Unique identifier of the site (site_…).
+     * @see GET /v1/sites/{site}/test_runs (operation `listTestRuns`, scope `test_runs:read`)
+     */
+    list(site: string, params?: T.ListTestRunsParams, options?: RequestOptions): ApiListPromise<T.TestRun>;
+    /**
+     * Retrieve a test run.
+     *
+     * The run with every step's status, observations, check results and fixes. While it runs, next_action.type is "wait"; when it finished, next_action says what to fix (apply_fixes / review_warnings) or "none".
+     *
+     * @param testRun Unique identifier of the test run (run_…).
+     * @see GET /v1/test_runs/{test_run} (operation `retrieveTestRun`, scope `test_runs:read`)
+     */
+    retrieve(testRun: string, options?: RequestOptions): Promise<T.TestRun>;
+    /**
+     * Cancel a test run.
+     *
+     * Stops a queued or running test run; the worker deletes its Stripe test clock (and with it the test customer and subscription). Finished runs cannot be canceled (resource_conflict).
+     *
+     * @param testRun Unique identifier of the test run (run_…).
+     * @see POST /v1/test_runs/{test_run}/cancel (operation `cancelTestRun`, scope `test_runs:write`)
+     */
+    cancel(testRun: string, options?: RequestOptions): Promise<T.TestRun>;
+}
+/** `checkbox.webhookEndpoints` */
+export declare class WebhookEndpointsResource extends Resource {
+    /**
+     * Create a webhook endpoint.
+     *
+     * Registers an HTTPS endpoint for the given event types. The response contains the signing `secret` (only now). Respond 2xx quickly; do slow work asynchronously.
+     *
+     * @see POST /v1/webhook_endpoints (operation `createWebhookEndpoint`, scope `webhook_endpoints:write`)
+     */
+    create(params: T.CreateWebhookEndpointParams, options?: RequestOptions): Promise<T.WebhookEndpoint>;
+    /**
+     * List webhook endpoints.
+     *
+     * Webhook endpoints of this mode, newest first.
+     *
+     * @see GET /v1/webhook_endpoints (operation `listWebhookEndpoints`, scope `webhook_endpoints:read`)
+     */
+    list(params?: T.ListWebhookEndpointsParams, options?: RequestOptions): ApiListPromise<T.WebhookEndpoint>;
+    /**
+     * Retrieve a webhook endpoint.
+     *
+     * One webhook endpoint (without its secret).
+     *
+     * @param webhookEndpoint Unique identifier of the webhook endpoint (we_…).
+     * @see GET /v1/webhook_endpoints/{webhook_endpoint} (operation `retrieveWebhookEndpoint`, scope `webhook_endpoints:read`)
+     */
+    retrieve(webhookEndpoint: string, options?: RequestOptions): Promise<T.WebhookEndpoint>;
+    /**
+     * Update a webhook endpoint.
+     *
+     * Changes the URL, event types, description, metadata, or disables / re-enables the endpoint.
+     *
+     * @param webhookEndpoint Unique identifier of the webhook endpoint (we_…).
+     * @see POST /v1/webhook_endpoints/{webhook_endpoint} (operation `updateWebhookEndpoint`, scope `webhook_endpoints:write`)
+     */
+    update(webhookEndpoint: string, params?: T.UpdateWebhookEndpointParams, options?: RequestOptions): Promise<T.WebhookEndpoint>;
+    /**
+     * Delete a webhook endpoint.
+     *
+     * Deletes the endpoint; pending deliveries to it are dropped.
+     *
+     * @param webhookEndpoint Unique identifier of the webhook endpoint (we_…).
+     * @see DELETE /v1/webhook_endpoints/{webhook_endpoint} (operation `deleteWebhookEndpoint`, scope `webhook_endpoints:write`)
+     */
+    del(webhookEndpoint: string, options?: RequestOptions): Promise<T.DeletedWebhookEndpoint>;
+    /** Alias of `del()`. */
+    delete(webhookEndpoint: string, options?: RequestOptions): Promise<T.DeletedWebhookEndpoint>;
+    /**
+     * Roll a webhook signing secret.
+     *
+     * Replaces the signing secret immediately and returns the new one (only now).
+     *
+     * @param webhookEndpoint Unique identifier of the webhook endpoint (we_…).
+     * @see POST /v1/webhook_endpoints/{webhook_endpoint}/roll_secret (operation `rollWebhookEndpointSecret`, scope `webhook_endpoints:write`)
+     */
+    rollSecret(webhookEndpoint: string, params?: T.RollWebhookEndpointSecretParams, options?: RequestOptions): Promise<T.WebhookEndpoint>;
+}
+/** `checkbox.events` */
+export declare class EventsResource extends Resource {
+    /**
+     * List events.
+     *
+     * Events newest first. Poll with ending_before=<newest id you have> to get only new events (an alternative to webhooks).
+     *
+     * @see GET /v1/events (operation `listEvents`, scope `events:read`)
+     */
+    list(params?: T.ListEventsParams, options?: RequestOptions): ApiListPromise<T.Event>;
+    /**
+     * Retrieve an event.
+     *
+     * One event with its payload (data.object) and the number of webhook deliveries still pending.
+     *
+     * @param event Unique identifier of the event (evt_…).
+     * @see GET /v1/events/{event} (operation `retrieveEvent`, scope `events:read`)
+     */
+    retrieve(event: string, options?: RequestOptions): Promise<T.Event>;
+}
+/** `checkbox.feedbacks` */
+export declare class FeedbacksResource extends Resource {
+    /**
+     * Send feedback.
+     *
+     * Report a problem or a missing feature in Checkbox. Include what you tried, what happened and what you expected, and the site / request id when there is one. The Checkbox team reads every message. Rate limited to 20 per key per hour.
+     *
+     * @see POST /v1/feedback (operation `createFeedback`, scope `account:read`)
+     */
+    create(params: T.FeedbackParams, options?: RequestOptions): Promise<T.Feedback>;
+}
+/** Resource namespaces of the client. */
+export declare const RESOURCES: {
+    readonly device: typeof DeviceResource;
+    readonly setupSessions: typeof SetupSessionsResource;
+    readonly account: typeof AccountResource;
+    readonly sites: typeof SitesResource;
+    readonly domainVerifications: typeof DomainVerificationsResource;
+    readonly scans: typeof ScansResource;
+    readonly evaluations: typeof EvaluationsResource;
+    readonly findings: typeof FindingsResource;
+    readonly plans: typeof PlansResource;
+    readonly tasks: typeof TasksResource;
+    readonly verifications: typeof VerificationsResource;
+    readonly fixes: typeof FixesResource;
+    readonly evidence: typeof EvidenceResource;
+    readonly certificates: typeof CertificatesResource;
+    readonly noticeSettings: typeof NoticeSettingsResource;
+    readonly notices: typeof NoticesResource;
+    readonly lawUpdates: typeof LawUpdatesResource;
+    readonly checks: typeof ChecksResource;
+    readonly elements: typeof ElementsResource;
+    readonly disclosures: typeof DisclosuresResource;
+    readonly consents: typeof ConsentsResource;
+    readonly receiptTokens: typeof ReceiptTokensResource;
+    readonly receipts: typeof ReceiptsResource;
+    readonly receiptSettings: typeof ReceiptSettingsResource;
+    readonly testCredentials: typeof TestCredentialsResource;
+    readonly stripeCheckoutConfigs: typeof StripeCheckoutConfigsResource;
+    readonly testRuns: typeof TestRunsResource;
+    readonly webhookEndpoints: typeof WebhookEndpointsResource;
+    readonly events: typeof EventsResource;
+    readonly feedbacks: typeof FeedbacksResource;
+};