@checkbox-site/node 0.0.0-stage → 0.1.0

package/dist/generated/operations.js

@@ -0,0 +1,2990 @@
+import { Resource } from "../resource.js";
+/** How to call each operation. Keys are the OpenAPI operationIds (also the MCP tool names). */
+export const OPERATIONS = {
+    createDeviceAuthorization: {
+        operationId: "createDeviceAuthorization",
+        namespace: "device",
+        method: "authorize",
+        httpMethod: "POST",
+        path: "/v1/device/authorize",
+        pathParams: [],
+        queryParams: [],
+        body: true,
+        idempotent: false,
+        auth: false,
+        scope: "none",
+        response: "json",
+        list: false,
+        paginated: false,
+        summary: "Start a device login (setup_checkbox)",
+    },
+    createDeviceToken: {
+        operationId: "createDeviceToken",
+        namespace: "device",
+        method: "token",
+        httpMethod: "POST",
+        path: "/v1/device/token",
+        pathParams: [],
+        queryParams: [],
+        body: true,
+        idempotent: false,
+        auth: false,
+        scope: "none",
+        response: "json",
+        list: false,
+        paginated: false,
+        summary: "Poll a device login for its keys",
+    },
+    createSetupSession: {
+        operationId: "createSetupSession",
+        namespace: "setupSessions",
+        method: "create",
+        httpMethod: "POST",
+        path: "/v1/setup_sessions",
+        pathParams: [],
+        queryParams: [],
+        body: true,
+        idempotent: true,
+        auth: true,
+        scope: "setup_sessions:write",
+        response: "json",
+        list: false,
+        paginated: false,
+        summary: "Start a setup session (agents that already have a key)",
+    },
+    listSetupSessions: {
+        operationId: "listSetupSessions",
+        namespace: "setupSessions",
+        method: "list",
+        httpMethod: "GET",
+        path: "/v1/setup_sessions",
+        pathParams: [],
+        queryParams: ["limit", "starting_after", "ending_before"],
+        body: false,
+        idempotent: false,
+        auth: true,
+        scope: "setup_sessions:read",
+        response: "json",
+        list: true,
+        paginated: true,
+        summary: "List setup sessions",
+    },
+    retrieveSetupSession: {
+        operationId: "retrieveSetupSession",
+        namespace: "setupSessions",
+        method: "retrieve",
+        httpMethod: "GET",
+        path: "/v1/setup_sessions/{setup_session}",
+        pathParams: ["setup_session"],
+        queryParams: [],
+        body: false,
+        idempotent: false,
+        auth: true,
+        scope: "setup_sessions:read",
+        response: "json",
+        list: false,
+        paginated: false,
+        summary: "Retrieve a setup session",
+    },
+    updateSetupSession: {
+        operationId: "updateSetupSession",
+        namespace: "setupSessions",
+        method: "update",
+        httpMethod: "POST",
+        path: "/v1/setup_sessions/{setup_session}",
+        pathParams: ["setup_session"],
+        queryParams: [],
+        body: true,
+        idempotent: true,
+        auth: true,
+        scope: "setup_sessions:write",
+        response: "json",
+        list: false,
+        paginated: false,
+        summary: "Report what the agent learned or changed",
+    },
+    verifySetupSession: {
+        operationId: "verifySetupSession",
+        namespace: "setupSessions",
+        method: "verify",
+        httpMethod: "POST",
+        path: "/v1/setup_sessions/{setup_session}/verify",
+        pathParams: ["setup_session"],
+        queryParams: [],
+        body: false,
+        idempotent: true,
+        auth: true,
+        scope: "setup_sessions:write",
+        response: "json",
+        list: false,
+        paginated: false,
+        summary: "Re-check the site now",
+    },
+    completeSetupSession: {
+        operationId: "completeSetupSession",
+        namespace: "setupSessions",
+        method: "complete",
+        httpMethod: "POST",
+        path: "/v1/setup_sessions/{setup_session}/complete",
+        pathParams: ["setup_session"],
+        queryParams: [],
+        body: false,
+        idempotent: true,
+        auth: true,
+        scope: "setup_sessions:write",
+        response: "json",
+        list: false,
+        paginated: false,
+        summary: "Finish the setup and notify the human",
+    },
+    retrieveAccount: {
+        operationId: "retrieveAccount",
+        namespace: "account",
+        method: "retrieve",
+        httpMethod: "GET",
+        path: "/v1/account",
+        pathParams: [],
+        queryParams: [],
+        body: false,
+        idempotent: false,
+        auth: true,
+        scope: "account:read",
+        response: "json",
+        list: false,
+        paginated: false,
+        summary: "Retrieve the account",
+    },
+    updateAccount: {
+        operationId: "updateAccount",
+        namespace: "account",
+        method: "update",
+        httpMethod: "POST",
+        path: "/v1/account",
+        pathParams: [],
+        queryParams: [],
+        body: true,
+        idempotent: true,
+        auth: true,
+        scope: "account:write",
+        response: "json",
+        list: false,
+        paginated: false,
+        summary: "Update the account",
+    },
+    listSites: {
+        operationId: "listSites",
+        namespace: "sites",
+        method: "list",
+        httpMethod: "GET",
+        path: "/v1/sites",
+        pathParams: [],
+        queryParams: ["limit", "starting_after", "ending_before", "archived"],
+        body: false,
+        idempotent: false,
+        auth: true,
+        scope: "sites:read",
+        response: "json",
+        list: true,
+        paginated: true,
+        summary: "List sites",
+    },
+    createSite: {
+        operationId: "createSite",
+        namespace: "sites",
+        method: "create",
+        httpMethod: "POST",
+        path: "/v1/sites",
+        pathParams: [],
+        queryParams: [],
+        body: true,
+        idempotent: true,
+        auth: true,
+        scope: "sites:write",
+        response: "json",
+        list: false,
+        paginated: false,
+        summary: "Create a site",
+    },
+    retrieveSite: {
+        operationId: "retrieveSite",
+        namespace: "sites",
+        method: "retrieve",
+        httpMethod: "GET",
+        path: "/v1/sites/{site}",
+        pathParams: ["site"],
+        queryParams: ["expand[]"],
+        body: false,
+        idempotent: false,
+        auth: true,
+        scope: "sites:read",
+        response: "json",
+        list: false,
+        paginated: false,
+        summary: "Retrieve a site",
+    },
+    updateSite: {
+        operationId: "updateSite",
+        namespace: "sites",
+        method: "update",
+        httpMethod: "POST",
+        path: "/v1/sites/{site}",
+        pathParams: ["site"],
+        queryParams: [],
+        body: true,
+        idempotent: true,
+        auth: true,
+        scope: "sites:write",
+        response: "json",
+        list: false,
+        paginated: false,
+        summary: "Update a site",
+    },
+    deleteSite: {
+        operationId: "deleteSite",
+        namespace: "sites",
+        method: "del",
+        httpMethod: "DELETE",
+        path: "/v1/sites/{site}",
+        pathParams: ["site"],
+        queryParams: [],
+        body: false,
+        idempotent: false,
+        auth: true,
+        scope: "sites:write",
+        response: "json",
+        list: false,
+        paginated: false,
+        summary: "Archive a site",
+    },
+    restoreSite: {
+        operationId: "restoreSite",
+        namespace: "sites",
+        method: "restore",
+        httpMethod: "POST",
+        path: "/v1/sites/{site}/restore",
+        pathParams: ["site"],
+        queryParams: [],
+        body: false,
+        idempotent: true,
+        auth: true,
+        scope: "sites:write",
+        response: "json",
+        list: false,
+        paginated: false,
+        summary: "Restore an archived site",
+    },
+    connectBillingPlatform: {
+        operationId: "connectBillingPlatform",
+        namespace: "sites",
+        method: "connectBillingPlatform",
+        httpMethod: "POST",
+        path: "/v1/sites/{site}/integrations",
+        pathParams: ["site"],
+        queryParams: [],
+        body: true,
+        idempotent: true,
+        auth: true,
+        scope: "sites:write",
+        response: "json",
+        list: false,
+        paginated: false,
+        summary: "Connect a billing platform",
+    },
+    retrieveDomainVerification: {
+        operationId: "retrieveDomainVerification",
+        namespace: "domainVerifications",
+        method: "retrieve",
+        httpMethod: "GET",
+        path: "/v1/sites/{site}/domain_verification",
+        pathParams: ["site"],
+        queryParams: [],
+        body: false,
+        idempotent: false,
+        auth: true,
+        scope: "sites:read",
+        response: "json",
+        list: false,
+        paginated: false,
+        summary: "Retrieve domain verification",
+    },
+    createDomainVerification: {
+        operationId: "createDomainVerification",
+        namespace: "domainVerifications",
+        method: "create",
+        httpMethod: "POST",
+        path: "/v1/sites/{site}/domain_verification",
+        pathParams: ["site"],
+        queryParams: [],
+        body: true,
+        idempotent: true,
+        auth: true,
+        scope: "sites:write",
+        response: "json",
+        list: false,
+        paginated: false,
+        summary: "Start domain verification",
+    },
+    checkDomainVerification: {
+        operationId: "checkDomainVerification",
+        namespace: "domainVerifications",
+        method: "check",
+        httpMethod: "POST",
+        path: "/v1/sites/{site}/domain_verification/check",
+        pathParams: ["site"],
+        queryParams: [],
+        body: false,
+        idempotent: true,
+        auth: true,
+        scope: "sites:write",
+        response: "json",
+        list: false,
+        paginated: false,
+        summary: "Check domain verification now",
+    },
+    createScan: {
+        operationId: "createScan",
+        namespace: "scans",
+        method: "create",
+        httpMethod: "POST",
+        path: "/v1/sites/{site}/scans",
+        pathParams: ["site"],
+        queryParams: [],
+        body: true,
+        idempotent: true,
+        auth: true,
+        scope: "scans:write",
+        response: "json",
+        list: false,
+        paginated: false,
+        summary: "Run a scan",
+    },
+    listScans: {
+        operationId: "listScans",
+        namespace: "scans",
+        method: "list",
+        httpMethod: "GET",
+        path: "/v1/scans",
+        pathParams: [],
+        queryParams: ["limit", "starting_after", "ending_before", "site"],
+        body: false,
+        idempotent: false,
+        auth: true,
+        scope: "scans:read",
+        response: "json",
+        list: true,
+        paginated: true,
+        summary: "List scans",
+    },
+    retrieveScan: {
+        operationId: "retrieveScan",
+        namespace: "scans",
+        method: "retrieve",
+        httpMethod: "GET",
+        path: "/v1/scans/{scan}",
+        pathParams: ["scan"],
+        queryParams: [],
+        body: false,
+        idempotent: false,
+        auth: true,
+        scope: "scans:read",
+        response: "json",
+        list: false,
+        paginated: false,
+        summary: "Retrieve a scan",
+    },
+    createEvaluation: {
+        operationId: "createEvaluation",
+        namespace: "evaluations",
+        method: "create",
+        httpMethod: "POST",
+        path: "/v1/sites/{site}/evaluations",
+        pathParams: ["site"],
+        queryParams: [],
+        body: true,
+        idempotent: true,
+        auth: true,
+        scope: "evaluations:write",
+        response: "json",
+        list: false,
+        paginated: false,
+        summary: "Re-evaluate a site now",
+    },
+    listEvaluations: {
+        operationId: "listEvaluations",
+        namespace: "evaluations",
+        method: "list",
+        httpMethod: "GET",
+        path: "/v1/evaluations",
+        pathParams: [],
+        queryParams: ["limit", "starting_after", "ending_before", "site"],
+        body: false,
+        idempotent: false,
+        auth: true,
+        scope: "evaluations:read",
+        response: "json",
+        list: true,
+        paginated: true,
+        summary: "List evaluations",
+    },
+    retrieveEvaluation: {
+        operationId: "retrieveEvaluation",
+        namespace: "evaluations",
+        method: "retrieve",
+        httpMethod: "GET",
+        path: "/v1/evaluations/{evaluation}",
+        pathParams: ["evaluation"],
+        queryParams: [],
+        body: false,
+        idempotent: false,
+        auth: true,
+        scope: "evaluations:read",
+        response: "json",
+        list: false,
+        paginated: false,
+        summary: "Retrieve an evaluation",
+    },
+    retrieveLatestEvaluation: {
+        operationId: "retrieveLatestEvaluation",
+        namespace: "evaluations",
+        method: "retrieveLatest",
+        httpMethod: "GET",
+        path: "/v1/sites/{site}/evaluation",
+        pathParams: ["site"],
+        queryParams: [],
+        body: false,
+        idempotent: false,
+        auth: true,
+        scope: "evaluations:read",
+        response: "json",
+        list: false,
+        paginated: false,
+        summary: "Get the current verdict of a site",
+    },
+    listFindings: {
+        operationId: "listFindings",
+        namespace: "findings",
+        method: "list",
+        httpMethod: "GET",
+        path: "/v1/findings",
+        pathParams: [],
+        queryParams: ["limit", "starting_after", "ending_before", "site", "status", "state"],
+        body: false,
+        idempotent: false,
+        auth: true,
+        scope: "findings:read",
+        response: "json",
+        list: true,
+        paginated: true,
+        summary: "List findings",
+    },
+    retrieveFinding: {
+        operationId: "retrieveFinding",
+        namespace: "findings",
+        method: "retrieve",
+        httpMethod: "GET",
+        path: "/v1/findings/{finding}",
+        pathParams: ["finding"],
+        queryParams: [],
+        body: false,
+        idempotent: false,
+        auth: true,
+        scope: "findings:read",
+        response: "json",
+        list: false,
+        paginated: false,
+        summary: "Retrieve a finding",
+    },
+    updateFinding: {
+        operationId: "updateFinding",
+        namespace: "findings",
+        method: "update",
+        httpMethod: "POST",
+        path: "/v1/findings/{finding}",
+        pathParams: ["finding"],
+        queryParams: [],
+        body: true,
+        idempotent: true,
+        auth: true,
+        scope: "findings:write",
+        response: "json",
+        list: false,
+        paginated: false,
+        summary: "Triage a finding",
+    },
+    retrieveCompliancePlan: {
+        operationId: "retrieveCompliancePlan",
+        namespace: "plans",
+        method: "retrieve",
+        httpMethod: "GET",
+        path: "/v1/sites/{site}/plan",
+        pathParams: ["site"],
+        queryParams: [],
+        body: false,
+        idempotent: false,
+        auth: true,
+        scope: "compliance_plans:read",
+        response: "json",
+        list: false,
+        paginated: false,
+        summary: "Get the compliance plan for a site",
+    },
+    retrieveTask: {
+        operationId: "retrieveTask",
+        namespace: "tasks",
+        method: "retrieve",
+        httpMethod: "GET",
+        path: "/v1/tasks/{task}",
+        pathParams: ["task"],
+        queryParams: [],
+        body: false,
+        idempotent: false,
+        auth: true,
+        scope: "compliance_plans:read",
+        response: "json",
+        list: false,
+        paginated: false,
+        summary: "Get one task of a compliance plan",
+    },
+    updateTask: {
+        operationId: "updateTask",
+        namespace: "tasks",
+        method: "update",
+        httpMethod: "POST",
+        path: "/v1/tasks/{task}",
+        pathParams: ["task"],
+        queryParams: [],
+        body: true,
+        idempotent: true,
+        auth: true,
+        scope: "compliance_plans:write",
+        response: "json",
+        list: false,
+        paginated: false,
+        summary: "Claim, decline or reopen a task",
+    },
+    answerTask: {
+        operationId: "answerTask",
+        namespace: "tasks",
+        method: "answer",
+        httpMethod: "POST",
+        path: "/v1/tasks/{task}/answer",
+        pathParams: ["task"],
+        queryParams: [],
+        body: true,
+        idempotent: true,
+        auth: true,
+        scope: "compliance_plans:write",
+        response: "json",
+        list: false,
+        paginated: false,
+        summary: "Record the human answer to a manual task",
+    },
+    verifyTask: {
+        operationId: "verifyTask",
+        namespace: "tasks",
+        method: "verify",
+        httpMethod: "POST",
+        path: "/v1/tasks/{task}/verify",
+        pathParams: ["task"],
+        queryParams: ["wait"],
+        body: true,
+        idempotent: true,
+        auth: true,
+        scope: "compliance_plans:write",
+        response: "json",
+        list: false,
+        paginated: false,
+        summary: "Verify a task after applying its change",
+    },
+    verifySite: {
+        operationId: "verifySite",
+        namespace: "sites",
+        method: "verify",
+        httpMethod: "POST",
+        path: "/v1/sites/{site}/verify",
+        pathParams: ["site"],
+        queryParams: ["wait"],
+        body: false,
+        idempotent: true,
+        auth: true,
+        scope: "compliance_plans:write",
+        response: "json",
+        list: false,
+        paginated: false,
+        summary: "Re-check the whole site now",
+    },
+    retrieveVerification: {
+        operationId: "retrieveVerification",
+        namespace: "verifications",
+        method: "retrieve",
+        httpMethod: "GET",
+        path: "/v1/verifications/{verification}",
+        pathParams: ["verification"],
+        queryParams: ["wait"],
+        body: false,
+        idempotent: false,
+        auth: true,
+        scope: "compliance_plans:read",
+        response: "json",
+        list: false,
+        paginated: false,
+        summary: "Get a verification (long-poll with ?wait=30)",
+    },
+    listVerifications: {
+        operationId: "listVerifications",
+        namespace: "verifications",
+        method: "list",
+        httpMethod: "GET",
+        path: "/v1/sites/{site}/verifications",
+        pathParams: ["site"],
+        queryParams: ["limit", "starting_after", "ending_before", "task"],
+        body: false,
+        idempotent: false,
+        auth: true,
+        scope: "compliance_plans:read",
+        response: "json",
+        list: true,
+        paginated: true,
+        summary: "List verifications of a site",
+    },
+    retrieveFindingFix: {
+        operationId: "retrieveFindingFix",
+        namespace: "fixes",
+        method: "retrieve",
+        httpMethod: "GET",
+        path: "/v1/findings/{finding}/fix",
+        pathParams: ["finding"],
+        queryParams: ["plan", "cancel_url", "target"],
+        body: false,
+        idempotent: false,
+        auth: true,
+        scope: "fixes:read",
+        response: "json",
+        list: false,
+        paginated: false,
+        summary: "Get the fix for a finding",
+    },
+    listSiteFixes: {
+        operationId: "listSiteFixes",
+        namespace: "fixes",
+        method: "list",
+        httpMethod: "GET",
+        path: "/v1/sites/{site}/fixes",
+        pathParams: ["site"],
+        queryParams: ["plan", "cancel_url", "target"],
+        body: false,
+        idempotent: false,
+        auth: true,
+        scope: "fixes:read",
+        response: "json",
+        list: true,
+        paginated: false,
+        summary: "List fix plans for a site",
+    },
+    listEvidence: {
+        operationId: "listEvidence",
+        namespace: "evidence",
+        method: "list",
+        httpMethod: "GET",
+        path: "/v1/evidence",
+        pathParams: [],
+        queryParams: ["limit", "starting_after", "ending_before", "site", "kind"],
+        body: false,
+        idempotent: false,
+        auth: true,
+        scope: "evidence:read",
+        response: "json",
+        list: true,
+        paginated: true,
+        summary: "List evidence",
+    },
+    retrieveEvidence: {
+        operationId: "retrieveEvidence",
+        namespace: "evidence",
+        method: "retrieve",
+        httpMethod: "GET",
+        path: "/v1/evidence/{evidence}",
+        pathParams: ["evidence"],
+        queryParams: [],
+        body: false,
+        idempotent: false,
+        auth: true,
+        scope: "evidence:read",
+        response: "json",
+        list: false,
+        paginated: false,
+        summary: "Retrieve evidence metadata",
+    },
+    downloadEvidenceContent: {
+        operationId: "downloadEvidenceContent",
+        namespace: "evidence",
+        method: "downloadContent",
+        httpMethod: "GET",
+        path: "/v1/evidence/{evidence}/content",
+        pathParams: ["evidence"],
+        queryParams: [],
+        body: false,
+        idempotent: false,
+        auth: true,
+        scope: "evidence:read",
+        response: "binary",
+        list: false,
+        paginated: false,
+        summary: "Download evidence content",
+    },
+    verifyEvidenceChain: {
+        operationId: "verifyEvidenceChain",
+        namespace: "evidence",
+        method: "verifyChain",
+        httpMethod: "POST",
+        path: "/v1/sites/{site}/evidence/verify",
+        pathParams: ["site"],
+        queryParams: [],
+        body: true,
+        idempotent: false,
+        auth: true,
+        scope: "evidence:read",
+        response: "json",
+        list: false,
+        paginated: false,
+        summary: "Verify the evidence chain",
+    },
+    listCertificates: {
+        operationId: "listCertificates",
+        namespace: "certificates",
+        method: "list",
+        httpMethod: "GET",
+        path: "/v1/certificates",
+        pathParams: [],
+        queryParams: ["limit", "starting_after", "ending_before", "site"],
+        body: false,
+        idempotent: false,
+        auth: true,
+        scope: "certificates:read",
+        response: "json",
+        list: true,
+        paginated: true,
+        summary: "List certificates",
+    },
+    retrieveCertificate: {
+        operationId: "retrieveCertificate",
+        namespace: "certificates",
+        method: "retrieve",
+        httpMethod: "GET",
+        path: "/v1/certificates/{certificate}",
+        pathParams: ["certificate"],
+        queryParams: [],
+        body: false,
+        idempotent: false,
+        auth: true,
+        scope: "certificates:read",
+        response: "json",
+        list: false,
+        paginated: false,
+        summary: "Retrieve a certificate",
+    },
+    createCertificate: {
+        operationId: "createCertificate",
+        namespace: "certificates",
+        method: "create",
+        httpMethod: "POST",
+        path: "/v1/sites/{site}/certificates",
+        pathParams: ["site"],
+        queryParams: [],
+        body: true,
+        idempotent: true,
+        auth: true,
+        scope: "certificates:write",
+        response: "json",
+        list: false,
+        paginated: false,
+        summary: "Issue a certificate",
+    },
+    revokeCertificate: {
+        operationId: "revokeCertificate",
+        namespace: "certificates",
+        method: "revoke",
+        httpMethod: "POST",
+        path: "/v1/certificates/{certificate}/revoke",
+        pathParams: ["certificate"],
+        queryParams: [],
+        body: true,
+        idempotent: true,
+        auth: true,
+        scope: "certificates:write",
+        response: "json",
+        list: false,
+        paginated: false,
+        summary: "Revoke a certificate",
+    },
+    retrieveNoticeSettings: {
+        operationId: "retrieveNoticeSettings",
+        namespace: "noticeSettings",
+        method: "retrieve",
+        httpMethod: "GET",
+        path: "/v1/sites/{site}/notice_settings",
+        pathParams: ["site"],
+        queryParams: [],
+        body: false,
+        idempotent: false,
+        auth: true,
+        scope: "notices:read",
+        response: "json",
+        list: false,
+        paginated: false,
+        summary: "Retrieve notice settings",
+    },
+    updateNoticeSettings: {
+        operationId: "updateNoticeSettings",
+        namespace: "noticeSettings",
+        method: "update",
+        httpMethod: "POST",
+        path: "/v1/sites/{site}/notice_settings",
+        pathParams: ["site"],
+        queryParams: [],
+        body: true,
+        idempotent: true,
+        auth: true,
+        scope: "notices:write",
+        response: "json",
+        list: false,
+        paginated: false,
+        summary: "Update notice settings",
+    },
+    listDueNotices: {
+        operationId: "listDueNotices",
+        namespace: "notices",
+        method: "listDue",
+        httpMethod: "GET",
+        path: "/v1/notices/due",
+        pathParams: [],
+        queryParams: ["limit", "starting_after", "ending_before", "site", "status", "kind", "subscription"],
+        body: false,
+        idempotent: false,
+        auth: true,
+        scope: "notices:read",
+        response: "json",
+        list: true,
+        paginated: true,
+        summary: "List due notices",
+    },
+    listNoticeTemplates: {
+        operationId: "listNoticeTemplates",
+        namespace: "notices",
+        method: "listTemplates",
+        httpMethod: "GET",
+        path: "/v1/notices/templates",
+        pathParams: [],
+        queryParams: ["site"],
+        body: false,
+        idempotent: false,
+        auth: true,
+        scope: "notices:read",
+        response: "json",
+        list: true,
+        paginated: false,
+        summary: "List notice email templates",
+    },
+    checkNoticeTemplate: {
+        operationId: "checkNoticeTemplate",
+        namespace: "notices",
+        method: "checkTemplate",
+        httpMethod: "POST",
+        path: "/v1/notices/templates/check",
+        pathParams: [],
+        queryParams: [],
+        body: true,
+        idempotent: false,
+        auth: true,
+        scope: "notices:read",
+        response: "json",
+        list: false,
+        paginated: false,
+        summary: "Check a notice email template",
+    },
+    retrieveDueNotice: {
+        operationId: "retrieveDueNotice",
+        namespace: "notices",
+        method: "retrieve",
+        httpMethod: "GET",
+        path: "/v1/notices/{notice}",
+        pathParams: ["notice"],
+        queryParams: [],
+        body: false,
+        idempotent: false,
+        auth: true,
+        scope: "notices:read",
+        response: "json",
+        list: false,
+        paginated: false,
+        summary: "Retrieve a due notice",
+    },
+    markNoticeSent: {
+        operationId: "markNoticeSent",
+        namespace: "notices",
+        method: "markSent",
+        httpMethod: "POST",
+        path: "/v1/notices/{notice}/sent",
+        pathParams: ["notice"],
+        queryParams: [],
+        body: true,
+        idempotent: true,
+        auth: true,
+        scope: "notices:write",
+        response: "json",
+        list: false,
+        paginated: false,
+        summary: "Mark a due notice as sent",
+    },
+    markNoticeMissed: {
+        operationId: "markNoticeMissed",
+        namespace: "notices",
+        method: "markMissed",
+        httpMethod: "POST",
+        path: "/v1/notices/{notice}/missed",
+        pathParams: ["notice"],
+        queryParams: [],
+        body: true,
+        idempotent: true,
+        auth: true,
+        scope: "notices:write",
+        response: "json",
+        list: false,
+        paginated: false,
+        summary: "Record a due notice as missed",
+    },
+    listLawUpdates: {
+        operationId: "listLawUpdates",
+        namespace: "lawUpdates",
+        method: "list",
+        httpMethod: "GET",
+        path: "/v1/law_updates",
+        pathParams: [],
+        queryParams: ["limit", "starting_after", "ending_before", "since"],
+        body: false,
+        idempotent: false,
+        auth: true,
+        scope: "law_updates:read",
+        response: "json",
+        list: true,
+        paginated: true,
+        summary: "List law updates",
+    },
+    retrieveLawUpdate: {
+        operationId: "retrieveLawUpdate",
+        namespace: "lawUpdates",
+        method: "retrieve",
+        httpMethod: "GET",
+        path: "/v1/law_updates/{law_update}",
+        pathParams: ["law_update"],
+        queryParams: [],
+        body: false,
+        idempotent: false,
+        auth: true,
+        scope: "law_updates:read",
+        response: "json",
+        list: false,
+        paginated: false,
+        summary: "Retrieve a law update",
+    },
+    checkDisclosure: {
+        operationId: "checkDisclosure",
+        namespace: "checks",
+        method: "disclosure",
+        httpMethod: "POST",
+        path: "/v1/checks/disclosure",
+        pathParams: [],
+        queryParams: [],
+        body: true,
+        idempotent: false,
+        auth: true,
+        scope: "checks:read",
+        response: "json",
+        list: false,
+        paginated: false,
+        summary: "Check checkout disclosure text",
+    },
+    checkStripeCheckoutSession: {
+        operationId: "checkStripeCheckoutSession",
+        namespace: "checks",
+        method: "stripeCheckoutSession",
+        httpMethod: "POST",
+        path: "/v1/checks/stripe_checkout_session",
+        pathParams: [],
+        queryParams: [],
+        body: true,
+        idempotent: false,
+        auth: true,
+        scope: "checks:read",
+        response: "json",
+        list: false,
+        paginated: false,
+        summary: "Check Stripe Checkout Session params",
+    },
+    checkStripePaymentLink: {
+        operationId: "checkStripePaymentLink",
+        namespace: "checks",
+        method: "stripePaymentLink",
+        httpMethod: "POST",
+        path: "/v1/checks/stripe_payment_link",
+        pathParams: [],
+        queryParams: [],
+        body: true,
+        idempotent: false,
+        auth: true,
+        scope: "checks:read",
+        response: "json",
+        list: false,
+        paginated: false,
+        summary: "Check Stripe Payment Link params",
+    },
+    checkEmail: {
+        operationId: "checkEmail",
+        namespace: "checks",
+        method: "email",
+        httpMethod: "POST",
+        path: "/v1/checks/email",
+        pathParams: [],
+        queryParams: [],
+        body: true,
+        idempotent: false,
+        auth: true,
+        scope: "checks:read",
+        response: "json",
+        list: false,
+        paginated: false,
+        summary: "Check a subscription lifecycle email",
+    },
+    checkPage: {
+        operationId: "checkPage",
+        namespace: "checks",
+        method: "page",
+        httpMethod: "POST",
+        path: "/v1/checks/page",
+        pathParams: [],
+        queryParams: [],
+        body: true,
+        idempotent: false,
+        auth: true,
+        scope: "checks:read",
+        response: "json",
+        list: false,
+        paginated: false,
+        summary: "Check a checkout page (HTML or URL)",
+    },
+    checkNoticeSchedule: {
+        operationId: "checkNoticeSchedule",
+        namespace: "checks",
+        method: "noticeSchedule",
+        httpMethod: "POST",
+        path: "/v1/checks/notice_schedule",
+        pathParams: [],
+        queryParams: [],
+        body: true,
+        idempotent: false,
+        auth: true,
+        scope: "checks:read",
+        response: "json",
+        list: false,
+        paginated: false,
+        summary: "Get the dates each required notice must be sent",
+    },
+    getElementsBundle: {
+        operationId: "getElementsBundle",
+        namespace: "elements",
+        method: "retrieveBundle",
+        httpMethod: "GET",
+        path: "/v1/elements.js",
+        pathParams: [],
+        queryParams: [],
+        body: false,
+        idempotent: false,
+        auth: false,
+        scope: "none",
+        response: "text",
+        list: false,
+        paginated: false,
+        summary: "Load the Elements browser bundle",
+    },
+    getElementsManifest: {
+        operationId: "getElementsManifest",
+        namespace: "elements",
+        method: "retrieveManifest",
+        httpMethod: "GET",
+        path: "/v1/elements/manifest.json",
+        pathParams: [],
+        queryParams: [],
+        body: false,
+        idempotent: false,
+        auth: false,
+        scope: "none",
+        response: "json",
+        list: false,
+        paginated: false,
+        summary: "List Elements bundle versions and SRI hashes",
+    },
+    getElementsBundleVersion: {
+        operationId: "getElementsBundleVersion",
+        namespace: "elements",
+        method: "retrieveBundleVersion",
+        httpMethod: "GET",
+        path: "/v1/elements/{version}/elements.js",
+        pathParams: ["version"],
+        queryParams: [],
+        body: false,
+        idempotent: false,
+        auth: false,
+        scope: "none",
+        response: "text",
+        list: false,
+        paginated: false,
+        summary: "Load a pinned Elements bundle version",
+    },
+    createDisclosure: {
+        operationId: "createDisclosure",
+        namespace: "disclosures",
+        method: "create",
+        httpMethod: "POST",
+        path: "/v1/disclosures",
+        pathParams: [],
+        queryParams: [],
+        body: true,
+        idempotent: true,
+        auth: true,
+        scope: "consents:write",
+        response: "json",
+        list: false,
+        paginated: false,
+        summary: "Create a locked disclosure for a site",
+    },
+    retrieveDisclosure: {
+        operationId: "retrieveDisclosure",
+        namespace: "disclosures",
+        method: "retrieve",
+        httpMethod: "GET",
+        path: "/v1/disclosures/{disclosure}",
+        pathParams: ["disclosure"],
+        queryParams: [],
+        body: false,
+        idempotent: false,
+        auth: true,
+        scope: "publishable",
+        response: "json",
+        list: false,
+        paginated: false,
+        summary: "Retrieve a disclosure",
+    },
+    createConsent: {
+        operationId: "createConsent",
+        namespace: "consents",
+        method: "create",
+        httpMethod: "POST",
+        path: "/v1/consents",
+        pathParams: [],
+        queryParams: [],
+        body: true,
+        idempotent: true,
+        auth: true,
+        scope: "publishable",
+        response: "json",
+        list: false,
+        paginated: false,
+        summary: "Record a consent",
+    },
+    listConsents: {
+        operationId: "listConsents",
+        namespace: "consents",
+        method: "list",
+        httpMethod: "GET",
+        path: "/v1/consents",
+        pathParams: [],
+        queryParams: ["limit", "starting_after", "ending_before", "site", "customer_reference", "disclosure", "created_gte", "created_lte"],
+        body: false,
+        idempotent: false,
+        auth: true,
+        scope: "consents:read",
+        response: "json",
+        list: true,
+        paginated: true,
+        summary: "List consents",
+    },
+    retrieveConsent: {
+        operationId: "retrieveConsent",
+        namespace: "consents",
+        method: "retrieve",
+        httpMethod: "GET",
+        path: "/v1/consents/{consent}",
+        pathParams: ["consent"],
+        queryParams: [],
+        body: false,
+        idempotent: false,
+        auth: true,
+        scope: "consents:read",
+        response: "json",
+        list: false,
+        paginated: false,
+        summary: "Retrieve a consent",
+    },
+    updateConsent: {
+        operationId: "updateConsent",
+        namespace: "consents",
+        method: "update",
+        httpMethod: "POST",
+        path: "/v1/consents/{consent}",
+        pathParams: ["consent"],
+        queryParams: [],
+        body: true,
+        idempotent: true,
+        auth: true,
+        scope: "consents:write",
+        response: "json",
+        list: false,
+        paginated: false,
+        summary: "Attach a customer reference to a consent",
+    },
+    createReceiptToken: {
+        operationId: "createReceiptToken",
+        namespace: "receiptTokens",
+        method: "create",
+        httpMethod: "POST",
+        path: "/v1/receipt_tokens",
+        pathParams: [],
+        queryParams: [],
+        body: true,
+        idempotent: true,
+        auth: true,
+        scope: "receipts:write",
+        response: "json",
+        list: false,
+        paginated: false,
+        summary: "Mint a capture token for a checkout",
+    },
+    createReceipt: {
+        operationId: "createReceipt",
+        namespace: "receipts",
+        method: "create",
+        httpMethod: "POST",
+        path: "/v1/receipts",
+        pathParams: [],
+        queryParams: [],
+        body: true,
+        idempotent: true,
+        auth: true,
+        scope: "publishable",
+        response: "json",
+        list: false,
+        paginated: false,
+        summary: "Record a consent receipt",
+    },
+    listReceipts: {
+        operationId: "listReceipts",
+        namespace: "receipts",
+        method: "list",
+        httpMethod: "GET",
+        path: "/v1/receipts",
+        pathParams: [],
+        queryParams: ["limit", "starting_after", "ending_before", "site", "customer_reference", "checkout_session", "email", "source", "binding", "created_gte", "created_lte"],
+        body: false,
+        idempotent: false,
+        auth: true,
+        scope: "receipts:read",
+        response: "json",
+        list: true,
+        paginated: true,
+        summary: "List consent receipts",
+    },
+    eraseReceipts: {
+        operationId: "eraseReceipts",
+        namespace: "receipts",
+        method: "erase",
+        httpMethod: "POST",
+        path: "/v1/receipts/erase",
+        pathParams: [],
+        queryParams: [],
+        body: true,
+        idempotent: true,
+        auth: true,
+        scope: "receipts:write",
+        response: "json",
+        list: false,
+        paginated: false,
+        summary: "Erase a subscriber's receipts",
+    },
+    retrieveReceipt: {
+        operationId: "retrieveReceipt",
+        namespace: "receipts",
+        method: "retrieve",
+        httpMethod: "GET",
+        path: "/v1/receipts/{receipt}",
+        pathParams: ["receipt"],
+        queryParams: [],
+        body: false,
+        idempotent: false,
+        auth: true,
+        scope: "receipts:read",
+        response: "json",
+        list: false,
+        paginated: false,
+        summary: "Retrieve a consent receipt",
+    },
+    renderReceipt: {
+        operationId: "renderReceipt",
+        namespace: "receipts",
+        method: "render",
+        httpMethod: "GET",
+        path: "/v1/receipts/{receipt}/render.png",
+        pathParams: ["receipt"],
+        queryParams: [],
+        body: false,
+        idempotent: false,
+        auth: true,
+        scope: "receipts:read",
+        response: "binary",
+        list: false,
+        paginated: false,
+        summary: "Render a receipt as an image",
+    },
+    verifyReceipt: {
+        operationId: "verifyReceipt",
+        namespace: "receipts",
+        method: "verify",
+        httpMethod: "GET",
+        path: "/v1/receipts/{receipt}/verify",
+        pathParams: ["receipt"],
+        queryParams: [],
+        body: false,
+        idempotent: false,
+        auth: true,
+        scope: "receipts:read",
+        response: "json",
+        list: false,
+        paginated: false,
+        summary: "Verify a receipt's integrity",
+    },
+    exportReceipt: {
+        operationId: "exportReceipt",
+        namespace: "receipts",
+        method: "export",
+        httpMethod: "GET",
+        path: "/v1/receipts/{receipt}/export",
+        pathParams: ["receipt"],
+        queryParams: [],
+        body: false,
+        idempotent: false,
+        auth: true,
+        scope: "receipts:read",
+        response: "binary",
+        list: false,
+        paginated: false,
+        summary: "Download a self-verifying receipt bundle",
+    },
+    retrieveReceiptSettings: {
+        operationId: "retrieveReceiptSettings",
+        namespace: "receiptSettings",
+        method: "retrieve",
+        httpMethod: "GET",
+        path: "/v1/receipt_settings",
+        pathParams: [],
+        queryParams: [],
+        body: false,
+        idempotent: false,
+        auth: true,
+        scope: "receipts:read",
+        response: "json",
+        list: false,
+        paginated: false,
+        summary: "Retrieve receipt settings",
+    },
+    updateReceiptSettings: {
+        operationId: "updateReceiptSettings",
+        namespace: "receiptSettings",
+        method: "update",
+        httpMethod: "POST",
+        path: "/v1/receipt_settings",
+        pathParams: [],
+        queryParams: [],
+        body: true,
+        idempotent: true,
+        auth: true,
+        scope: "receipts:write",
+        response: "json",
+        list: false,
+        paginated: false,
+        summary: "Update receipt settings",
+    },
+    createTestCredential: {
+        operationId: "createTestCredential",
+        namespace: "testCredentials",
+        method: "create",
+        httpMethod: "POST",
+        path: "/v1/sites/{site}/test_credentials",
+        pathParams: ["site"],
+        queryParams: [],
+        body: true,
+        idempotent: true,
+        auth: true,
+        scope: "test_runs:write",
+        response: "json",
+        list: false,
+        paginated: false,
+        summary: "Store a billing test-mode key",
+    },
+    listTestCredentials: {
+        operationId: "listTestCredentials",
+        namespace: "testCredentials",
+        method: "list",
+        httpMethod: "GET",
+        path: "/v1/sites/{site}/test_credentials",
+        pathParams: ["site"],
+        queryParams: [],
+        body: false,
+        idempotent: false,
+        auth: true,
+        scope: "test_runs:read",
+        response: "json",
+        list: true,
+        paginated: false,
+        summary: "List billing test-mode keys of a site",
+    },
+    deleteTestCredential: {
+        operationId: "deleteTestCredential",
+        namespace: "testCredentials",
+        method: "del",
+        httpMethod: "DELETE",
+        path: "/v1/sites/{site}/test_credentials/{test_credential}",
+        pathParams: ["site", "test_credential"],
+        queryParams: [],
+        body: false,
+        idempotent: false,
+        auth: true,
+        scope: "test_runs:write",
+        response: "json",
+        list: false,
+        paginated: false,
+        summary: "Delete a billing test-mode key",
+    },
+    createStripeCheckoutConfig: {
+        operationId: "createStripeCheckoutConfig",
+        namespace: "stripeCheckoutConfigs",
+        method: "create",
+        httpMethod: "POST",
+        path: "/v1/sites/{site}/stripe_checkout_configs",
+        pathParams: ["site"],
+        queryParams: [],
+        body: true,
+        idempotent: true,
+        auth: true,
+        scope: "test_runs:write",
+        response: "json",
+        list: false,
+        paginated: false,
+        summary: "Register the Checkout Session params your code uses",
+    },
+    listStripeCheckoutConfigs: {
+        operationId: "listStripeCheckoutConfigs",
+        namespace: "stripeCheckoutConfigs",
+        method: "list",
+        httpMethod: "GET",
+        path: "/v1/sites/{site}/stripe_checkout_configs",
+        pathParams: ["site"],
+        queryParams: ["limit", "starting_after", "ending_before"],
+        body: false,
+        idempotent: false,
+        auth: true,
+        scope: "test_runs:read",
+        response: "json",
+        list: true,
+        paginated: true,
+        summary: "List registered checkout configs",
+    },
+    retrieveStripeCheckoutConfig: {
+        operationId: "retrieveStripeCheckoutConfig",
+        namespace: "stripeCheckoutConfigs",
+        method: "retrieve",
+        httpMethod: "GET",
+        path: "/v1/stripe_checkout_configs/{stripe_checkout_config}",
+        pathParams: ["stripe_checkout_config"],
+        queryParams: [],
+        body: false,
+        idempotent: false,
+        auth: true,
+        scope: "test_runs:read",
+        response: "json",
+        list: false,
+        paginated: false,
+        summary: "Retrieve a registered checkout config",
+    },
+    deleteStripeCheckoutConfig: {
+        operationId: "deleteStripeCheckoutConfig",
+        namespace: "stripeCheckoutConfigs",
+        method: "del",
+        httpMethod: "DELETE",
+        path: "/v1/stripe_checkout_configs/{stripe_checkout_config}",
+        pathParams: ["stripe_checkout_config"],
+        queryParams: [],
+        body: false,
+        idempotent: false,
+        auth: true,
+        scope: "test_runs:write",
+        response: "json",
+        list: false,
+        paginated: false,
+        summary: "Delete a registered checkout config",
+    },
+    createTestRun: {
+        operationId: "createTestRun",
+        namespace: "testRuns",
+        method: "create",
+        httpMethod: "POST",
+        path: "/v1/sites/{site}/test_runs",
+        pathParams: ["site"],
+        queryParams: [],
+        body: true,
+        idempotent: true,
+        auth: true,
+        scope: "test_runs:write",
+        response: "json",
+        list: false,
+        paginated: false,
+        summary: "Start a lifecycle test run",
+    },
+    listTestRuns: {
+        operationId: "listTestRuns",
+        namespace: "testRuns",
+        method: "list",
+        httpMethod: "GET",
+        path: "/v1/sites/{site}/test_runs",
+        pathParams: ["site"],
+        queryParams: ["limit", "starting_after", "ending_before"],
+        body: false,
+        idempotent: false,
+        auth: true,
+        scope: "test_runs:read",
+        response: "json",
+        list: true,
+        paginated: true,
+        summary: "List test runs of a site",
+    },
+    retrieveTestRun: {
+        operationId: "retrieveTestRun",
+        namespace: "testRuns",
+        method: "retrieve",
+        httpMethod: "GET",
+        path: "/v1/test_runs/{test_run}",
+        pathParams: ["test_run"],
+        queryParams: [],
+        body: false,
+        idempotent: false,
+        auth: true,
+        scope: "test_runs:read",
+        response: "json",
+        list: false,
+        paginated: false,
+        summary: "Retrieve a test run",
+    },
+    cancelTestRun: {
+        operationId: "cancelTestRun",
+        namespace: "testRuns",
+        method: "cancel",
+        httpMethod: "POST",
+        path: "/v1/test_runs/{test_run}/cancel",
+        pathParams: ["test_run"],
+        queryParams: [],
+        body: false,
+        idempotent: true,
+        auth: true,
+        scope: "test_runs:write",
+        response: "json",
+        list: false,
+        paginated: false,
+        summary: "Cancel a test run",
+    },
+    createWebhookEndpoint: {
+        operationId: "createWebhookEndpoint",
+        namespace: "webhookEndpoints",
+        method: "create",
+        httpMethod: "POST",
+        path: "/v1/webhook_endpoints",
+        pathParams: [],
+        queryParams: [],
+        body: true,
+        idempotent: true,
+        auth: true,
+        scope: "webhook_endpoints:write",
+        response: "json",
+        list: false,
+        paginated: false,
+        summary: "Create a webhook endpoint",
+    },
+    listWebhookEndpoints: {
+        operationId: "listWebhookEndpoints",
+        namespace: "webhookEndpoints",
+        method: "list",
+        httpMethod: "GET",
+        path: "/v1/webhook_endpoints",
+        pathParams: [],
+        queryParams: ["limit", "starting_after", "ending_before"],
+        body: false,
+        idempotent: false,
+        auth: true,
+        scope: "webhook_endpoints:read",
+        response: "json",
+        list: true,
+        paginated: true,
+        summary: "List webhook endpoints",
+    },
+    retrieveWebhookEndpoint: {
+        operationId: "retrieveWebhookEndpoint",
+        namespace: "webhookEndpoints",
+        method: "retrieve",
+        httpMethod: "GET",
+        path: "/v1/webhook_endpoints/{webhook_endpoint}",
+        pathParams: ["webhook_endpoint"],
+        queryParams: [],
+        body: false,
+        idempotent: false,
+        auth: true,
+        scope: "webhook_endpoints:read",
+        response: "json",
+        list: false,
+        paginated: false,
+        summary: "Retrieve a webhook endpoint",
+    },
+    updateWebhookEndpoint: {
+        operationId: "updateWebhookEndpoint",
+        namespace: "webhookEndpoints",
+        method: "update",
+        httpMethod: "POST",
+        path: "/v1/webhook_endpoints/{webhook_endpoint}",
+        pathParams: ["webhook_endpoint"],
+        queryParams: [],
+        body: true,
+        idempotent: true,
+        auth: true,
+        scope: "webhook_endpoints:write",
+        response: "json",
+        list: false,
+        paginated: false,
+        summary: "Update a webhook endpoint",
+    },
+    deleteWebhookEndpoint: {
+        operationId: "deleteWebhookEndpoint",
+        namespace: "webhookEndpoints",
+        method: "del",
+        httpMethod: "DELETE",
+        path: "/v1/webhook_endpoints/{webhook_endpoint}",
+        pathParams: ["webhook_endpoint"],
+        queryParams: [],
+        body: false,
+        idempotent: false,
+        auth: true,
+        scope: "webhook_endpoints:write",
+        response: "json",
+        list: false,
+        paginated: false,
+        summary: "Delete a webhook endpoint",
+    },
+    rollWebhookEndpointSecret: {
+        operationId: "rollWebhookEndpointSecret",
+        namespace: "webhookEndpoints",
+        method: "rollSecret",
+        httpMethod: "POST",
+        path: "/v1/webhook_endpoints/{webhook_endpoint}/roll_secret",
+        pathParams: ["webhook_endpoint"],
+        queryParams: [],
+        body: true,
+        idempotent: true,
+        auth: true,
+        scope: "webhook_endpoints:write",
+        response: "json",
+        list: false,
+        paginated: false,
+        summary: "Roll a webhook signing secret",
+    },
+    listEvents: {
+        operationId: "listEvents",
+        namespace: "events",
+        method: "list",
+        httpMethod: "GET",
+        path: "/v1/events",
+        pathParams: [],
+        queryParams: ["limit", "starting_after", "ending_before", "type", "created_gte", "created_lte"],
+        body: false,
+        idempotent: false,
+        auth: true,
+        scope: "events:read",
+        response: "json",
+        list: true,
+        paginated: true,
+        summary: "List events",
+    },
+    retrieveEvent: {
+        operationId: "retrieveEvent",
+        namespace: "events",
+        method: "retrieve",
+        httpMethod: "GET",
+        path: "/v1/events/{event}",
+        pathParams: ["event"],
+        queryParams: [],
+        body: false,
+        idempotent: false,
+        auth: true,
+        scope: "events:read",
+        response: "json",
+        list: false,
+        paginated: false,
+        summary: "Retrieve an event",
+    },
+    createFeedback: {
+        operationId: "createFeedback",
+        namespace: "feedbacks",
+        method: "create",
+        httpMethod: "POST",
+        path: "/v1/feedback",
+        pathParams: [],
+        queryParams: [],
+        body: true,
+        idempotent: true,
+        auth: true,
+        scope: "account:read",
+        response: "json",
+        list: false,
+        paginated: false,
+        summary: "Send feedback",
+    },
+};
+/** `checkbox.device` */
+export 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, options) {
+        return this._request(OPERATIONS.createDeviceAuthorization, [], params, options);
+    }
+    /**
+     * 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, options) {
+        return this._request(OPERATIONS.createDeviceToken, [], params, options);
+    }
+}
+/** `checkbox.setupSessions` */
+export 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, options) {
+        return this._request(OPERATIONS.createSetupSession, [], params, options);
+    }
+    /**
+     * 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, options) {
+        return this._list(OPERATIONS.listSetupSessions, [], params, options);
+    }
+    /**
+     * 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, options) {
+        return this._request(OPERATIONS.retrieveSetupSession, [setupSession], undefined, options);
+    }
+    /**
+     * 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, params, options) {
+        return this._request(OPERATIONS.updateSetupSession, [setupSession], params, options);
+    }
+    /**
+     * 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, options) {
+        return this._request(OPERATIONS.verifySetupSession, [setupSession], undefined, options);
+    }
+    /**
+     * 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, options) {
+        return this._request(OPERATIONS.completeSetupSession, [setupSession], undefined, options);
+    }
+}
+/** `checkbox.account` */
+export 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) {
+        return this._request(OPERATIONS.retrieveAccount, [], undefined, options);
+    }
+    /**
+     * 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, options) {
+        return this._request(OPERATIONS.updateAccount, [], params, options);
+    }
+}
+/** `checkbox.sites` */
+export 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, options) {
+        return this._list(OPERATIONS.listSites, [], params, options);
+    }
+    /**
+     * 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, options) {
+        return this._request(OPERATIONS.createSite, [], params, options);
+    }
+    /**
+     * 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, params, options) {
+        return this._request(OPERATIONS.retrieveSite, [site], params, options);
+    }
+    /**
+     * 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, params, options) {
+        return this._request(OPERATIONS.updateSite, [site], params, options);
+    }
+    /**
+     * 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, options) {
+        return this._request(OPERATIONS.deleteSite, [site], undefined, options);
+    }
+    /** Alias of `del()`. */
+    delete(site, options) {
+        return this.del(site, options);
+    }
+    /**
+     * 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, options) {
+        return this._request(OPERATIONS.restoreSite, [site], undefined, options);
+    }
+    /**
+     * 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, params, options) {
+        return this._request(OPERATIONS.connectBillingPlatform, [site], params, options);
+    }
+    /**
+     * 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, params, options) {
+        return this._request(OPERATIONS.verifySite, [site], params, options);
+    }
+}
+/** `checkbox.domainVerifications` */
+export 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, options) {
+        return this._request(OPERATIONS.retrieveDomainVerification, [site], undefined, options);
+    }
+    /**
+     * 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, params, options) {
+        return this._request(OPERATIONS.createDomainVerification, [site], params, options);
+    }
+    /**
+     * 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, options) {
+        return this._request(OPERATIONS.checkDomainVerification, [site], undefined, options);
+    }
+}
+/** `checkbox.scans` */
+export 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, params, options) {
+        return this._request(OPERATIONS.createScan, [site], params, options);
+    }
+    /**
+     * List scans.
+     *
+     * Scans newest first, optionally for one site.
+     *
+     * @see GET /v1/scans (operation `listScans`, scope `scans:read`)
+     */
+    list(params, options) {
+        return this._list(OPERATIONS.listScans, [], params, options);
+    }
+    /**
+     * 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, options) {
+        return this._request(OPERATIONS.retrieveScan, [scan], undefined, options);
+    }
+}
+/** `checkbox.evaluations` */
+export 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, params, options) {
+        return this._request(OPERATIONS.createEvaluation, [site], params, options);
+    }
+    /**
+     * List evaluations.
+     *
+     * Verdicts newest first (score history), optionally for one site.
+     *
+     * @see GET /v1/evaluations (operation `listEvaluations`, scope `evaluations:read`)
+     */
+    list(params, options) {
+        return this._list(OPERATIONS.listEvaluations, [], params, options);
+    }
+    /**
+     * 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, options) {
+        return this._request(OPERATIONS.retrieveEvaluation, [evaluation], undefined, options);
+    }
+    /**
+     * 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, options) {
+        return this._request(OPERATIONS.retrieveLatestEvaluation, [site], undefined, options);
+    }
+}
+/** `checkbox.findings` */
+export 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, options) {
+        return this._list(OPERATIONS.listFindings, [], params, options);
+    }
+    /**
+     * 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, options) {
+        return this._request(OPERATIONS.retrieveFinding, [finding], undefined, options);
+    }
+    /**
+     * 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, params, options) {
+        return this._request(OPERATIONS.updateFinding, [finding], params, options);
+    }
+}
+/** `checkbox.plans` */
+export 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, options) {
+        return this._request(OPERATIONS.retrieveCompliancePlan, [site], undefined, options);
+    }
+}
+/** `checkbox.tasks` */
+export 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, options) {
+        return this._request(OPERATIONS.retrieveTask, [task], undefined, options);
+    }
+    /**
+     * 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, params, options) {
+        return this._request(OPERATIONS.updateTask, [task], params, options);
+    }
+    /**
+     * 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, params, options) {
+        return this._request(OPERATIONS.answerTask, [task], params, options);
+    }
+    /**
+     * 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, params, options) {
+        return this._request(OPERATIONS.verifyTask, [task], params, options);
+    }
+}
+/** `checkbox.verifications` */
+export 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, params, options) {
+        return this._request(OPERATIONS.retrieveVerification, [verification], params, options);
+    }
+    /**
+     * 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, params, options) {
+        return this._list(OPERATIONS.listVerifications, [site], params, options);
+    }
+}
+/** `checkbox.fixes` */
+export 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, params, options) {
+        return this._request(OPERATIONS.retrieveFindingFix, [finding], params, options);
+    }
+    /**
+     * 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, params, options) {
+        return this._request(OPERATIONS.listSiteFixes, [site], params, options);
+    }
+}
+/** `checkbox.evidence` */
+export 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, options) {
+        return this._list(OPERATIONS.listEvidence, [], params, options);
+    }
+    /**
+     * 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, options) {
+        return this._request(OPERATIONS.retrieveEvidence, [evidence], undefined, options);
+    }
+    /**
+     * 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, options) {
+        return this._request(OPERATIONS.downloadEvidenceContent, [evidence], undefined, options);
+    }
+    /**
+     * 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, params, options) {
+        return this._request(OPERATIONS.verifyEvidenceChain, [site], params, options);
+    }
+}
+/** `checkbox.certificates` */
+export class CertificatesResource extends Resource {
+    /**
+     * List certificates.
+     *
+     * Certificates newest first, optionally for one site.
+     *
+     * @see GET /v1/certificates (operation `listCertificates`, scope `certificates:read`)
+     */
+    list(params, options) {
+        return this._list(OPERATIONS.listCertificates, [], params, options);
+    }
+    /**
+     * 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, options) {
+        return this._request(OPERATIONS.retrieveCertificate, [certificate], undefined, options);
+    }
+    /**
+     * 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, params, options) {
+        return this._request(OPERATIONS.createCertificate, [site], params, options);
+    }
+    /**
+     * 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, params, options) {
+        return this._request(OPERATIONS.revokeCertificate, [certificate], params, options);
+    }
+}
+/** `checkbox.noticeSettings` */
+export 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, options) {
+        return this._request(OPERATIONS.retrieveNoticeSettings, [site], undefined, options);
+    }
+    /**
+     * 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, params, options) {
+        return this._request(OPERATIONS.updateNoticeSettings, [site], params, options);
+    }
+}
+/** `checkbox.notices` */
+export 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, options) {
+        return this._list(OPERATIONS.listDueNotices, [], params, options);
+    }
+    /**
+     * 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, options) {
+        return this._request(OPERATIONS.listNoticeTemplates, [], params, options);
+    }
+    /**
+     * 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, options) {
+        return this._request(OPERATIONS.checkNoticeTemplate, [], params, options);
+    }
+    /**
+     * 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, options) {
+        return this._request(OPERATIONS.retrieveDueNotice, [notice], undefined, options);
+    }
+    /**
+     * 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, params, options) {
+        return this._request(OPERATIONS.markNoticeSent, [notice], params, options);
+    }
+    /**
+     * 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, params, options) {
+        return this._request(OPERATIONS.markNoticeMissed, [notice], params, options);
+    }
+}
+/** `checkbox.lawUpdates` */
+export 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, options) {
+        return this._list(OPERATIONS.listLawUpdates, [], params, options);
+    }
+    /**
+     * 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, options) {
+        return this._request(OPERATIONS.retrieveLawUpdate, [lawUpdate], undefined, options);
+    }
+}
+/** `checkbox.checks` */
+export 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, options) {
+        return this._request(OPERATIONS.checkDisclosure, [], params, options);
+    }
+    /**
+     * 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, options) {
+        return this._request(OPERATIONS.checkStripeCheckoutSession, [], params, options);
+    }
+    /**
+     * 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, options) {
+        return this._request(OPERATIONS.checkStripePaymentLink, [], params, options);
+    }
+    /**
+     * 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, options) {
+        return this._request(OPERATIONS.checkEmail, [], params, options);
+    }
+    /**
+     * 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, options) {
+        return this._request(OPERATIONS.checkPage, [], params, options);
+    }
+    /**
+     * 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, options) {
+        return this._request(OPERATIONS.checkNoticeSchedule, [], params, options);
+    }
+}
+/** `checkbox.elements` */
+export 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) {
+        return this._request(OPERATIONS.getElementsBundle, [], undefined, options);
+    }
+    /**
+     * 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) {
+        return this._request(OPERATIONS.getElementsManifest, [], undefined, options);
+    }
+    /**
+     * 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, options) {
+        return this._request(OPERATIONS.getElementsBundleVersion, [versionId], undefined, options);
+    }
+}
+/** `checkbox.disclosures` */
+export 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, options) {
+        return this._request(OPERATIONS.createDisclosure, [], params, options);
+    }
+    /**
+     * 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, options) {
+        return this._request(OPERATIONS.retrieveDisclosure, [disclosure], undefined, options);
+    }
+}
+/** `checkbox.consents` */
+export 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, options) {
+        return this._request(OPERATIONS.createConsent, [], params, options);
+    }
+    /**
+     * 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, options) {
+        return this._list(OPERATIONS.listConsents, [], params, options);
+    }
+    /**
+     * 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, options) {
+        return this._request(OPERATIONS.retrieveConsent, [consent], undefined, options);
+    }
+    /**
+     * 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, params, options) {
+        return this._request(OPERATIONS.updateConsent, [consent], params, options);
+    }
+}
+/** `checkbox.receiptTokens` */
+export 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, options) {
+        return this._request(OPERATIONS.createReceiptToken, [], params, options);
+    }
+}
+/** `checkbox.receipts` */
+export 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, options) {
+        return this._request(OPERATIONS.createReceipt, [], params, options);
+    }
+    /**
+     * 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, options) {
+        return this._list(OPERATIONS.listReceipts, [], params, options);
+    }
+    /**
+     * 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, options) {
+        return this._request(OPERATIONS.eraseReceipts, [], params, options);
+    }
+    /**
+     * 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, options) {
+        return this._request(OPERATIONS.retrieveReceipt, [receipt], undefined, options);
+    }
+    /**
+     * 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, options) {
+        return this._request(OPERATIONS.renderReceipt, [receipt], undefined, options);
+    }
+    /**
+     * 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, options) {
+        return this._request(OPERATIONS.verifyReceipt, [receipt], undefined, options);
+    }
+    /**
+     * 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, options) {
+        return this._request(OPERATIONS.exportReceipt, [receipt], undefined, options);
+    }
+}
+/** `checkbox.receiptSettings` */
+export 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) {
+        return this._request(OPERATIONS.retrieveReceiptSettings, [], undefined, options);
+    }
+    /**
+     * 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, options) {
+        return this._request(OPERATIONS.updateReceiptSettings, [], params, options);
+    }
+}
+/** `checkbox.testCredentials` */
+export 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, params, options) {
+        return this._request(OPERATIONS.createTestCredential, [site], params, options);
+    }
+    /**
+     * 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, options) {
+        return this._request(OPERATIONS.listTestCredentials, [site], undefined, options);
+    }
+    /**
+     * 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, testCredential, options) {
+        return this._request(OPERATIONS.deleteTestCredential, [site, testCredential], undefined, options);
+    }
+    /** Alias of `del()`. */
+    delete(site, testCredential, options) {
+        return this.del(site, testCredential, options);
+    }
+}
+/** `checkbox.stripeCheckoutConfigs` */
+export 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, params, options) {
+        return this._request(OPERATIONS.createStripeCheckoutConfig, [site], params, options);
+    }
+    /**
+     * 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, params, options) {
+        return this._list(OPERATIONS.listStripeCheckoutConfigs, [site], params, options);
+    }
+    /**
+     * 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, options) {
+        return this._request(OPERATIONS.retrieveStripeCheckoutConfig, [stripeCheckoutConfig], undefined, options);
+    }
+    /**
+     * 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, options) {
+        return this._request(OPERATIONS.deleteStripeCheckoutConfig, [stripeCheckoutConfig], undefined, options);
+    }
+    /** Alias of `del()`. */
+    delete(stripeCheckoutConfig, options) {
+        return this.del(stripeCheckoutConfig, options);
+    }
+}
+/** `checkbox.testRuns` */
+export 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, params, options) {
+        return this._request(OPERATIONS.createTestRun, [site], params, options);
+    }
+    /**
+     * 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, params, options) {
+        return this._list(OPERATIONS.listTestRuns, [site], params, options);
+    }
+    /**
+     * 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, options) {
+        return this._request(OPERATIONS.retrieveTestRun, [testRun], undefined, options);
+    }
+    /**
+     * 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, options) {
+        return this._request(OPERATIONS.cancelTestRun, [testRun], undefined, options);
+    }
+}
+/** `checkbox.webhookEndpoints` */
+export 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, options) {
+        return this._request(OPERATIONS.createWebhookEndpoint, [], params, options);
+    }
+    /**
+     * List webhook endpoints.
+     *
+     * Webhook endpoints of this mode, newest first.
+     *
+     * @see GET /v1/webhook_endpoints (operation `listWebhookEndpoints`, scope `webhook_endpoints:read`)
+     */
+    list(params, options) {
+        return this._list(OPERATIONS.listWebhookEndpoints, [], params, options);
+    }
+    /**
+     * 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, options) {
+        return this._request(OPERATIONS.retrieveWebhookEndpoint, [webhookEndpoint], undefined, options);
+    }
+    /**
+     * 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, params, options) {
+        return this._request(OPERATIONS.updateWebhookEndpoint, [webhookEndpoint], params, options);
+    }
+    /**
+     * 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, options) {
+        return this._request(OPERATIONS.deleteWebhookEndpoint, [webhookEndpoint], undefined, options);
+    }
+    /** Alias of `del()`. */
+    delete(webhookEndpoint, options) {
+        return this.del(webhookEndpoint, options);
+    }
+    /**
+     * 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, params, options) {
+        return this._request(OPERATIONS.rollWebhookEndpointSecret, [webhookEndpoint], params, options);
+    }
+}
+/** `checkbox.events` */
+export 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, options) {
+        return this._list(OPERATIONS.listEvents, [], params, options);
+    }
+    /**
+     * 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, options) {
+        return this._request(OPERATIONS.retrieveEvent, [event], undefined, options);
+    }
+}
+/** `checkbox.feedbacks` */
+export 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, options) {
+        return this._request(OPERATIONS.createFeedback, [], params, options);
+    }
+}
+/** Resource namespaces of the client. */
+export const RESOURCES = {
+    device: DeviceResource,
+    setupSessions: SetupSessionsResource,
+    account: AccountResource,
+    sites: SitesResource,
+    domainVerifications: DomainVerificationsResource,
+    scans: ScansResource,
+    evaluations: EvaluationsResource,
+    findings: FindingsResource,
+    plans: PlansResource,
+    tasks: TasksResource,
+    verifications: VerificationsResource,
+    fixes: FixesResource,
+    evidence: EvidenceResource,
+    certificates: CertificatesResource,
+    noticeSettings: NoticeSettingsResource,
+    notices: NoticesResource,
+    lawUpdates: LawUpdatesResource,
+    checks: ChecksResource,
+    elements: ElementsResource,
+    disclosures: DisclosuresResource,
+    consents: ConsentsResource,
+    receiptTokens: ReceiptTokensResource,
+    receipts: ReceiptsResource,
+    receiptSettings: ReceiptSettingsResource,
+    testCredentials: TestCredentialsResource,
+    stripeCheckoutConfigs: StripeCheckoutConfigsResource,
+    testRuns: TestRunsResource,
+    webhookEndpoints: WebhookEndpointsResource,
+    events: EventsResource,
+    feedbacks: FeedbacksResource,
+};