verdifax 1.2.0 → 1.4.0

package/dist/index.d.ts

@@ -318,8 +318,13 @@ interface DeterminismRun {
     manifest_hash: string;
     bundle_hash: string;
     duration_ms: number;
+    /** `ok`, `stage_error`, or the refusal or halt kind, such as
+     *  `pepg_deny`. */
     status: string;
     error?: string;
+    /** The sealed receipt of a refused or halted run. The run's manifest
+     *  hash covers its hash. */
+    receipt?: Record<string, unknown>;
 }
 /** How the two runs of a determinism check compared. */
 interface DeterminismDiff {
@@ -327,9 +332,12 @@ interface DeterminismDiff {
     manifest_hash_differs: boolean;
     bundle_hash_differs: boolean;
     differing_fields?: string[];
+    /** Why there is no verdict, when neither run sealed a record. */
+    reason?: string;
 }
 /** Body returned by POST /execute/verify-determinism. `deterministic`
- *  means both runs ended ok with equal manifest hashes. */
+ *  means both runs ended the same way, completed or refused, with equal
+ *  manifest hashes. */
 interface VerifyDeterminismResponse {
     ok: boolean;
     deterministic: boolean;
@@ -476,6 +484,8 @@ interface ListRunsParams {
  *  for the full sealed manifest. */
 interface RunSummary {
     id: number;
+    /** The key that requested the run. */
+    api_key_id?: number;
     created_at: string;
     program_id: Hex64;
     route_id: string;
@@ -512,6 +522,9 @@ interface ExportRunsParams {
 /** One run in an evidence export: what the server stored, not a verdict. */
 interface ExportRow {
     run_id: number;
+    /** The key that requested the run, so an account's export can be
+     *  grouped by key. */
+    api_key_id?: number;
     created_at: string;
     status: RunStatus;
     error_stage: string;
@@ -541,6 +554,26 @@ interface RunsExport {
     /** Rows returned, counted by status. */
     by_status: Record<string, number>;
     runs: ExportRow[];
+    /** The key's policy documents, when it has loaded any. */
+    policy_documents?: PolicyWithDocument[];
+    /** The key's policy changes, oldest first, when it has loaded any. */
+    policy_history?: PolicyActivation[];
+    /** The key's account, as `account-N`. */
+    account_id?: string;
+    /** The account's policy documents, when it has loaded any. */
+    account_policy_documents?: PolicyWithDocument[];
+    /** The account's policy changes, oldest first, when it has loaded any. */
+    account_policy_history?: PolicyActivation[];
+}
+/** Returned by {@link VerdifaxClient.exportAccountRuns}: the runs of every
+ *  key in the account, with the account's policy documents and changes. */
+interface AccountRunsExport extends RunsExport {
+    account_id: string;
+    /** The account's whole chain of sign-offs, oldest first, as
+     *  {@link VerdifaxClient.getSignOffHistory} returns it. Only the owner
+     *  key's export carries it, and the SDK returns it as the server sent
+     *  it, without checking it: check it with `verdifax-verify`. */
+    signoffs?: SignOffRecord[];
 }
 /** Returned by {@link VerdifaxClient.exportRunsCSV}. */
 interface RunsExportCSV {
@@ -629,6 +662,93 @@ interface AdminCreateKeyResponse {
     name: string;
     secret: string;
     hint: string;
+    /** The key's account, as `account-N`. */
+    account_id?: string;
+}
+/** Options for {@link VerdifaxClient.adminCreateKey}. */
+interface AdminCreateKeyOptions {
+    /** Puts the customer key in this existing account, by its number. Without
+     *  it the key gets an account of its own. A key never changes account. */
+    accountId?: number;
+}
+/** A key's tier. */
+type KeyTier = "trial" | "production";
+/** An account, a company on Verdifax, as GET /admin/accounts lists it. The
+ *  account number is a label Verdifax assigned, not a verified company
+ *  identity. */
+interface Account {
+    /** `account-N`, as records seal it. */
+    account_id: string;
+    id: number;
+    name: string;
+    tier: string;
+    created_at: string;
+    /** Member keys not revoked. */
+    member_keys: number;
+    /** Owner keys not revoked. */
+    owner_keys: number;
+    /** The chain of the account's policy changes, `account-N`. */
+    chain_id: string;
+    identity?: string;
+    policy_scope?: string;
+}
+/** Returned by {@link VerdifaxClient.getAccount}. */
+interface AccountInfo extends Account {
+    ok: boolean;
+}
+/** One of an account's keys, without its secret. */
+interface AccountKey {
+    id: number;
+    name: string;
+    account_id: string;
+    /** True for an owner key, which manages the account and cannot run
+     *  anything. */
+    owner: boolean;
+    tier: string;
+    created_at: string;
+    last_used_at: string;
+    run_count: number;
+    revoked: boolean;
+    expires_at?: string;
+}
+/** Returned by {@link VerdifaxClient.listAccountKeys}. */
+interface AccountKeyList {
+    ok: boolean;
+    account_id: string;
+    keys: AccountKey[];
+}
+/** A new key with its secret, which is shown this once. */
+interface CreatedAccountKey extends AccountKey {
+    ok: boolean;
+    secret: string;
+    /** True when the key needs a request key before it can run. */
+    request_key_required: boolean;
+    hint: string;
+}
+/** Returned by {@link VerdifaxClient.revokeAccountKey}. */
+interface AccountKeyRevocation {
+    ok: boolean;
+    id: number;
+    revoked: boolean;
+}
+/** Options for {@link VerdifaxClient.createAccountKey}. */
+interface CreateAccountKeyOptions {
+    /** RFC 3339 or YYYY-MM-DD. */
+    expiresAt?: string;
+}
+/** Options for {@link VerdifaxClient.adminCreateAccount}. */
+interface AdminCreateAccountOptions {
+    /** `trial` when left out. */
+    tier?: KeyTier;
+    /** When the owner key expires: RFC 3339 or YYYY-MM-DD. */
+    expiresAt?: string;
+}
+/** Returned by {@link VerdifaxClient.adminCreateAccount}: the account and
+ *  its first owner key, with the secret. */
+interface AdminCreateAccountResponse {
+    ok: boolean;
+    account: Account;
+    owner_key: CreatedAccountKey;
 }
 /** Projection returned by {@link VerdifaxClient.adminListKeys}.
  *  Secrets are NEVER surfaced, only metadata. */
@@ -640,6 +760,127 @@ interface AdminAPIKey {
     run_count: number;
     revoked: boolean;
 }
+/** The kind of result a sign-off names: a completed run's record, a
+ *  refused or halted run's receipt, or a whole job by its final step. */
+type SignOffTargetKind = "record" | "receipt" | "job";
+/** An approver's decision on one result. */
+type SignOffDecision = "approve" | "reject";
+/** The exact result a sign-off names, by what its public-log entry
+ *  covers. */
+interface SignOffTarget {
+    kind: SignOffTargetKind;
+    /** The run: for a job, the run of its final step. */
+    run_id: number;
+    /** What the result's public-log entry covers. For a record, its
+     *  `bundle_anchor.anchored_digest` in the bundle
+     *  {@link VerdifaxClient.getRunArtifacts} returns. For a receipt, its
+     *  hash. For a job, the final step's record digest, read the same way
+     *  as a record's. 64 lowercase hex characters. */
+    digest: Hex64;
+    /** The job, for a job target only. */
+    job_id?: string;
+}
+/** One sign-off, verdifax.signoff.v1, as the server records it and
+ *  `verdifax-verify --signoff` and `--signoff-history` read it. */
+interface SignOffRecord {
+    format: string;
+    /** The account's chain, `account-N`. */
+    chain_id: string;
+    sequence: number;
+    /** The sign-off this one follows, or 64 zeros for the account's first. */
+    previous_signoff_hash: Hex64;
+    target: SignOffTarget;
+    decision: SignOffDecision;
+    /** SHA-256 of the approver's note, when there was one. The note's text
+     *  never reaches Verdifax. */
+    note_hash?: string;
+    /** The base64 Ed25519 public key of the approver who signed. */
+    approver_key: string;
+    /** Base64 Ed25519 signature by the approver key. */
+    signature: string;
+    signed_at: string;
+    nonce: string;
+    recorded_at: string;
+    signoff_hash: Hex64;
+    /** Where the sign-off was logged on the public log. */
+    anchor?: Record<string, unknown>;
+}
+/** What an approver signs against: the account's chain and its newest
+ *  sign-off. Returned by {@link VerdifaxClient.getNewestSignOff}. */
+interface NewestSignOff {
+    ok: boolean;
+    /** The account's chain, `account-N`. */
+    chain_id: string;
+    /** The newest sign-off's hash, or 64 zeros when there is none yet. */
+    newest_signoff_hash: Hex64;
+    /** The newest sign-off's place in the chain, 0 when there is none. */
+    sequence: number;
+}
+/** The approver key's part of a sign-off. */
+interface SignOffSignature {
+    /** The base64 Ed25519 public key of the approver. */
+    approver_key: string;
+    /** Base64 Ed25519 signature by the approver key. */
+    signature: string;
+    /** RFC 3339 UTC with whole seconds. */
+    signed_at: string;
+    /** 16 random bytes as 32 lowercase hex characters, fresh per sign-off. */
+    nonce: string;
+}
+/** Options for {@link VerdifaxClient.signOff}. */
+interface SignOffOptions {
+    /** The approver's note. It is hashed on this machine and only its
+     *  SHA-256 is sent and signed: the text never reaches Verdifax. Keep the
+     *  text yourself to show it matches the hash. */
+    note?: string;
+    /** Use the owner key's routes, /account/signoffs/newest and
+     *  /account/signoffs, instead of a member key's. */
+    asOwner?: boolean;
+}
+/** For a method that serves both a member key's route and the owner
+ *  key's /account route. */
+interface AsOwnerOptions {
+    /** Use the owner key's /account route. */
+    asOwner?: boolean;
+}
+/** An approver key's public key and the proof that its holder has the
+ *  private key, from {@link approverKeyProof}. */
+interface ApproverKeyProof {
+    /** Base64 of the raw 32-byte public key. */
+    public_key: string;
+    /** Base64 Ed25519 signature over verdifax.approver-key.v1, a zero byte
+     *  and the base64 public key. */
+    proof: string;
+}
+/** An approver key registered to an account. A key is not an identity:
+ *  `name` is the label the owner gave it. */
+interface Approver {
+    id: number;
+    public_key: string;
+    name: string;
+    /** The account, `account-N`. */
+    account_id: string;
+    registered_at: string;
+    revoked: boolean;
+    revoked_at?: string;
+}
+/** Returned by {@link VerdifaxClient.registerApprover}. */
+interface ApproverRegistration extends Approver {
+    ok: boolean;
+}
+/** Returned by {@link VerdifaxClient.listApprovers}: revoked keys
+ *  included. */
+interface ApproverList {
+    ok: boolean;
+    account_id: string;
+    approvers: Approver[];
+}
+/** Returned by {@link VerdifaxClient.revokeApprover}. */
+interface ApproverRevocation {
+    ok: boolean;
+    id: number;
+    revoked: boolean;
+}
 
 /**
  * The job helper: runs the steps of one job and keeps the map of step ids
@@ -722,10 +963,12 @@ declare const MAX_BATCH_ROWS = 1000;
  * | `listDeletionReceipts(id)` | GET /runs/{id}/deletion-receipts | required |
  * | `adminErase(req)` | POST /admin/erase | required |
  * | `dcaeVerify(bundle)` | POST /dcae/verify | none |
- * | `adminCreateKey(name)` | POST /admin/keys | required |
+ * | `adminCreateKey(name, options)` | POST /admin/keys | required |
  * | `adminListKeys()` | GET /admin/keys | required |
  * | `adminRevokeKey(id)` | DELETE /admin/keys/{id} | required |
  * | `adminClearRequestKey(id)` | DELETE /admin/keys/{id}/request-key | required |
+ * | `adminCreateAccount(name, options)` | POST /admin/accounts | required |
+ * | `adminListAccounts()` | GET /admin/accounts | required |
  * | `attestClaudeResponse(...)` | POST /execute (helper) | required |
  * | `attestOpenAIResponse(...)` | POST /execute (helper) | required |
  * | `registerRequestKey()` | POST /keys/request-key | required |
@@ -737,6 +980,28 @@ declare const MAX_BATCH_ROWS = 1000;
  * | `testPolicy(req)` | POST /policies/test | required |
  * | `getPolicyHistory()` | GET /policies/history | required |
  * | `activatePolicy(documentHash)` | POST /policies/{document_hash}/activate | required |
+ * | `getAccount()` | GET /account | owner key |
+ * | `createAccountKey(name, options)` | POST /account/keys | owner key |
+ * | `listAccountKeys()` | GET /account/keys | owner key |
+ * | `revokeAccountKey(id)` | DELETE /account/keys/{id} | owner key |
+ * | `registerAccountRequestKey()` | POST /account/request-key | owner key |
+ * | `clearAccountRequestKey()` | DELETE /account/request-key | owner key |
+ * | `listAccountRuns(params)` | GET /account/runs | owner key |
+ * | `exportAccountRuns(params)` | GET /account/runs/export | owner key |
+ * | `exportAccountRunsCSV(params)` | GET /account/runs/export?format=csv | owner key |
+ * | `uploadAccountPolicy(document)` | POST /account/policies | owner key |
+ * | `listAccountPolicies()` | GET /account/policies | owner key |
+ * | `getAccountPolicy(documentHash)` | GET /account/policies/{document_hash} | owner key |
+ * | `testAccountPolicy(req)` | POST /account/policies/test | owner key |
+ * | `getAccountPolicyHistory()` | GET /account/policies/history | owner key |
+ * | `activateAccountPolicy(documentHash)` | POST /account/policies/{document_hash}/activate | owner key |
+ * | `registerApprover(name, approver)` | POST /account/approvers | owner key |
+ * | `listApprovers()` | GET /account/approvers | owner key |
+ * | `revokeApprover(id)` | DELETE /account/approvers/{id} | owner key |
+ * | `signOff(target, decision, approverKey, options)` | POST /signoffs, or POST /account/signoffs with asOwner | required |
+ * | `getNewestSignOff(options)` | GET /signoffs/newest, or GET /account/signoffs/newest with asOwner | required |
+ * | `getSignOffs(runId, options)` | GET /runs/{id}/signoffs, or GET /account/runs/{id}/signoffs with asOwner | required |
+ * | `getSignOffHistory()` | GET /account/signoffs/history | owner key |
  * | `job(jobId)` | none, returns a {@link VerdifaxJob} | none |
  *
  * With the `signingKey` option set, every path to POST /execute carries
@@ -795,6 +1060,7 @@ declare class VerdifaxClient {
      *  that the client holds the private key. From then on the server
      *  refuses a run on this API key without a request signature. */
     registerRequestKey(): Promise<RequestKeyRegistration>;
+    private registerRequestKeyAt;
     /** Replaces the registered key with `newSigningKey`. The new key proves
      *  itself and this client's current key approves the change. After
      *  success this client signs with the new key. If the call fails it
@@ -808,6 +1074,7 @@ declare class VerdifaxClient {
      *  unsigned requests, because the server refuses a signed run on an API
      *  key with no registered key. If the call fails it keeps the key. */
     clearRequestKey(): Promise<void>;
+    private clearRequestKeyAt;
     /** Stores a policy document. Nothing changes until it is activated with
      *  {@link activatePolicy}. The server hashes the exact text, so this
      *  sends the string it is given unchanged and refuses anything that is
@@ -843,12 +1110,123 @@ declare class VerdifaxClient {
      *  {@link APIError} and is not retried: read the policies again and
      *  decide. */
     activatePolicy(documentHash: Hex64): Promise<PolicyActivation>;
+    private uploadPolicyAt;
+    private getPolicyAt;
+    private testPolicyAt;
+    /** Posts the change that follows the newest one in `chain`, signed by
+     *  the request key when the client has one. */
+    private activatePolicyAt;
+    /** The owner's account: its number, name, tier, key counts and the
+     *  chain of its policy changes. */
+    getAccount(): Promise<AccountInfo>;
+    /** Creates a member key in the account. It takes the account's tier and
+     *  stays in the account for life. The secret is in the result this once.
+     *  On a trial account the key needs a request key before it can run. */
+    createAccountKey(name: string, options?: CreateAccountKeyOptions): Promise<CreatedAccountKey>;
+    /** Every key in the account, owner keys included, without secrets. */
+    listAccountKeys(): Promise<AccountKeyList>;
+    /** Revokes one of the account's member keys. A key in another account,
+     *  or an owner key, throws {@link NotFoundError}. */
+    revokeAccountKey(keyId: number): Promise<AccountKeyRevocation>;
+    /** Registers this client's public key as the owner key's request key,
+     *  which must sign every change to the account's policy. It works as
+     *  {@link registerRequestKey} does. */
+    registerAccountRequestKey(): Promise<RequestKeyRegistration>;
+    /** Clears the owner key's request key, as {@link clearRequestKey} does
+     *  for a key's own. With none registered the account's policy cannot be
+     *  changed. A trial owner key's request key cannot be cleared. */
+    clearAccountRequestKey(): Promise<void>;
+    /** The runs of every key in the account, paged as {@link listRuns}. */
+    listAccountRuns(params?: ListRunsParams): Promise<{
+        runs: RunSummary[];
+        total: number;
+    }>;
+    /** The runs of every key in the account in a period, as
+     *  {@link exportRuns} lists a key's, with the account's number, its
+     *  policy documents and its chain of changes. The account's view covers
+     *  the runs its keys made through Verdifax, not runs made elsewhere. */
+    exportAccountRuns(params?: ExportRunsParams): Promise<AccountRunsExport>;
+    /** The same rows as {@link exportAccountRuns} as raw CSV text, checked
+     *  as {@link exportRunsCSV} checks a key's. */
+    exportAccountRunsCSV(params?: ExportRunsParams): Promise<RunsExportCSV>;
+    /** Stores an account policy document, as {@link uploadPolicy} stores a
+     *  key's. Every key in the account must pass the account's policy on top
+     *  of its own. Verdifax does not write, review or approve it. */
+    uploadAccountPolicy(document: string): Promise<Policy>;
+    /** The account's stored documents, its chain `account-N`, the newest
+     *  change in it and the document in force. */
+    listAccountPolicies(): Promise<PolicyList>;
+    /** One of the account's documents, with its exact text. */
+    getAccountPolicy(documentHash: Hex64): Promise<PolicyWithDocument>;
+    /** {@link testPolicy} for the account's documents. It seals nothing. */
+    testAccountPolicy(req: PolicyTestRequest): Promise<PolicyTestResult>;
+    /** The account's policy changes, oldest first, in the form
+     *  `verdifax-verify --policy-history FILE` reads. */
+    getAccountPolicyHistory(): Promise<PolicyActivation[]>;
+    /** Makes a stored document the account's policy in force, as
+     *  {@link activatePolicy} does for a key's. It reads
+     *  {@link listAccountPolicies} for the chain and its newest change, and
+     *  the owner key's request key signs the change over that chain,
+     *  `account-N`. The server refuses an unsigned account change, so this
+     *  needs the `signingKey` option and refuses to send without it. */
+    activateAccountPolicy(documentHash: Hex64): Promise<PolicyActivation>;
+    /** Registers an approver key to the owner's account. `approver` is the
+     *  approver's signing key, from which the proof is made on this machine,
+     *  or the `{ public_key, proof }` that {@link approverKeyProof} made on
+     *  the approver's own machine, so the owner need not hold the private
+     *  key. A proof that does not verify is refused before sending. The
+     *  server refuses a key that is a request key in the same account.
+     *  `name` is a label, not an identity. */
+    registerApprover(name: string, approver: Uint8Array | KeyObject | ApproverKeyProof): Promise<ApproverRegistration>;
+    /** The account's approver keys, revoked ones included. */
+    listApprovers(): Promise<ApproverList>;
+    /** Revokes one of the account's approver keys. Its earlier sign-offs
+     *  stay on the record. A key that is not an active approver in the
+     *  account throws {@link NotFoundError}. */
+    revokeApprover(approverId: number): Promise<ApproverRevocation>;
+    /** What an approver signs against: the account's chain `account-N` and
+     *  its newest sign-off (64 zeros when there is none yet). With
+     *  `asOwner` it reads the owner key's route. */
+    getNewestSignOff(options?: AsOwnerOptions): Promise<NewestSignOff>;
+    /** Signs an approver's decision, approve or reject, on one exact result
+     *  and submits it. It first reads {@link getNewestSignOff} for the
+     *  account's chain and its newest sign-off, then signs over them with
+     *  `approverKey` on this machine. The approver's private key is never
+     *  sent.
+     *
+     *  `target.digest` is what the result's public-log entry covers: for a
+     *  record, the `bundle_anchor.anchored_digest` of the bundle
+     *  {@link getRunArtifacts} returns; for a receipt, its hash; for a job,
+     *  the final step's record digest, read as a record's, with `job_id`.
+     *
+     *  `note` is hashed here and only its SHA-256 is sent and signed: the
+     *  text never reaches Verdifax. With `asOwner` it uses the owner key's
+     *  routes. Bad input is refused before anything is sent.
+     *
+     *  The record the server returns must carry the signature,
+     *  approver_key, decision, previous_signoff_hash and target that were
+     *  sent, or this throws {@link VerdifaxError}.
+     *
+     *  A later sign-off on the same result supersedes this one, and neither
+     *  is deleted. An HTTP 409 means the chain moved or the target is not
+     *  this account's result: it throws the usual {@link APIError} and is
+     *  not retried. */
+    signOff(target: SignOffTarget, decision: SignOffDecision, approverKey: Uint8Array | KeyObject, options?: SignOffOptions): Promise<SignOffRecord>;
+    /** The sign-offs on one run, oldest first, in the form
+     *  `verdifax-verify --signoff FILE` reads: for a member key, a run it
+     *  made; with `asOwner`, any run of the account. The latest is the
+     *  decision in force. */
+    getSignOffs(runId: number, options?: AsOwnerOptions): Promise<SignOffRecord[]>;
+    /** The account's whole chain of sign-offs, oldest first, in the form
+     *  `verdifax-verify --signoff-history FILE` reads. Needs the owner key. */
+    getSignOffHistory(): Promise<SignOffRecord[]>;
     getRun(runId: number): Promise<Run>;
     verifyRun(runId: number): Promise<VerifyResponse>;
     listRuns(params?: ListRunsParams): Promise<{
         runs: RunSummary[];
         total: number;
     }>;
+    private listRunsAt;
     /** Searches this key's runs. `manifest_hash` matches a prefix. The
      *  server ignores a `from` or `to` it cannot parse here, unlike
      *  {@link exportRuns}, which refuses one. */
@@ -867,6 +1245,7 @@ declare class VerdifaxClient {
      *  does not send those headers, so that a cut-off export cannot pass
      *  for a complete one. */
     exportRunsCSV(params?: ExportRunsParams): Promise<RunsExportCSV>;
+    private exportCSVAt;
     private exportPath;
     listAttestations(params?: ListAttestationsParams): Promise<AttestationList>;
     getAttestation(attestationId: number): Promise<Record<string, unknown>>;
@@ -897,7 +1276,16 @@ declare class VerdifaxClient {
     listDeletionReceipts(runId: number): Promise<DeletionReceipt[]>;
     adminErase(req: AdminEraseRequest): Promise<DeletionReceipt>;
     dcaeVerify(bundle: DCAEProofBundle): Promise<DCAEVerdict>;
-    adminCreateKey(name: string): Promise<AdminCreateKeyResponse>;
+    /** Creates a customer key. With `accountId` the key joins that existing
+     *  account; without it the key gets an account of its own. A key never
+     *  changes account. */
+    adminCreateKey(name: string, options?: AdminCreateKeyOptions): Promise<AdminCreateKeyResponse>;
+    /** Creates an account and its first owner key, whose secret is in the
+     *  result this once. The owner key creates the member keys. The account
+     *  number is a label Verdifax assigned, not a verified company identity. */
+    adminCreateAccount(name: string, options?: AdminCreateAccountOptions): Promise<AdminCreateAccountResponse>;
+    /** Every account, with its key counts. */
+    adminListAccounts(): Promise<Account[]>;
     adminListKeys(): Promise<AdminAPIKey[]>;
     adminRevokeKey(keyId: number): Promise<void>;
     /** Clears the request key on an API key whose holder lost it, after a
@@ -1144,6 +1532,29 @@ declare function policyActivationApproval(signingKey: Uint8Array | KeyObject, fi
     signedAt?: string;
     nonce?: string;
 }): PolicyActivationSignature;
+/** The bytes an approver key signs for one sign-off, matching the
+ *  orchestrator's SignOffPreimage: the fields joined with single zero
+ *  bytes. `chain_id` and `previous_signoff_hash` come from GET
+ *  /signoffs/newest (or /account/signoffs/newest for the owner key), so a
+ *  signature cannot be moved to another account, another result or
+ *  another point in the chain. `target.job_id` is empty unless the target
+ *  is a job, and `note_hash` is empty when there is no note. */
+declare function signOffPreimage(fields: {
+    chain_id: string;
+    previous_signoff_hash: string;
+    target: SignOffTarget;
+    decision: SignOffDecision;
+    note_hash: string;
+    signed_at: string;
+    nonce: string;
+}): Buffer;
+/** The approver key's base64 public key and its proof: its signature over
+ *  verdifax.approver-key.v1, a zero byte and the base64 public key, which
+ *  shows its holder has the private key. The approver can run this on
+ *  their own machine and give the result to the account's owner, who
+ *  registers it with {@link VerdifaxClient.registerApprover}, so the owner
+ *  never holds the approver's private key. */
+declare function approverKeyProof(approverKey: Uint8Array | KeyObject): ApproverKeyProof;
 
 /**
  * Input-validation helpers, mirrors the Python SDK's
@@ -1229,4 +1640,4 @@ declare class APIKeyRequiredError extends VerdifaxError {
     constructor();
 }
 
-export { APIError, APIKeyRequiredError, type AdminAPIKey, type AdminCreateKeyResponse, type AdminEraseRequest, type AttestRequest, type AttestationList, AuthError, CRES_ENGINE_VERSION, CRES_PREIMAGE_VERSION, type ClientConfig, type DCAEProofBundle, type DCAEVerdict, DCAE_PREIMAGE_VERSION, DSE_FORMULA_VERSION, type DeletionReceipt, type DeterminismDiff, type DeterminismRun, EXECUTE_FIELDS, type ExecuteBatchResponse, type ExecuteBatchResult, type ExecuteRequest, type ExecuteResponse, type ExecutionManifest, type ExportRow, type ExportRunsParams, type FormulaEra, type Health, type Hex64, type JobLink, type JobStepOptions, type ListAttestationsParams, type ListRunsParams, MAX_BATCH_ROWS, NotFoundError, type PDFFormat, type Policy, type PolicyActivation, type PolicyActivationSignature, type PolicyActorType, type PolicyClassification, type PolicyContext, type PolicyList, type PolicyObjectType, type PolicyTestRequest, type PolicyTestResult, type PolicyWithDocument, RUN_STATUSES, type ReproducibilityContext, type RequestKeyChange, type RequestKeyPair, type RequestKeyRegistration, type RequestKeyRegistrationBody, type RequestSignature, type RequestSignatureV2, type Run, type RunStats, type RunStatus, type RunSummary, type RunsExport, type RunsExportCSV, type SearchRunsParams, type SignedRequestBody, VerdifaxClient, VerdifaxError, VerdifaxJob, type VerdifaxVersion, type VerifyDeterminismResponse, type VerifyResponse, captureEnvironment, cresReceiptHash, dcaeClosureHash, dseDispatchHash, formatProviderPayload, fromEnv, generateRequestKeyPair, policyActivationApproval, policyActivationPreimage, requestKeyChangeApproval, requestKeyChangePreimage, requestKeyRegistrationBody, requestSignaturePreimage, requestSignaturePreimageV2, signRequest, signRequestV2, validateHex64, validateJobName, validateRouteId };
+export { APIError, APIKeyRequiredError, type Account, type AccountInfo, type AccountKey, type AccountKeyList, type AccountKeyRevocation, type AccountRunsExport, type AdminAPIKey, type AdminCreateAccountOptions, type AdminCreateAccountResponse, type AdminCreateKeyOptions, type AdminCreateKeyResponse, type AdminEraseRequest, type Approver, type ApproverKeyProof, type ApproverList, type ApproverRegistration, type ApproverRevocation, type AsOwnerOptions, type AttestRequest, type AttestationList, AuthError, CRES_ENGINE_VERSION, CRES_PREIMAGE_VERSION, type ClientConfig, type CreateAccountKeyOptions, type CreatedAccountKey, type DCAEProofBundle, type DCAEVerdict, DCAE_PREIMAGE_VERSION, DSE_FORMULA_VERSION, type DeletionReceipt, type DeterminismDiff, type DeterminismRun, EXECUTE_FIELDS, type ExecuteBatchResponse, type ExecuteBatchResult, type ExecuteRequest, type ExecuteResponse, type ExecutionManifest, type ExportRow, type ExportRunsParams, type FormulaEra, type Health, type Hex64, type JobLink, type JobStepOptions, type KeyTier, type ListAttestationsParams, type ListRunsParams, MAX_BATCH_ROWS, type NewestSignOff, NotFoundError, type PDFFormat, type Policy, type PolicyActivation, type PolicyActivationSignature, type PolicyActorType, type PolicyClassification, type PolicyContext, type PolicyList, type PolicyObjectType, type PolicyTestRequest, type PolicyTestResult, type PolicyWithDocument, RUN_STATUSES, type ReproducibilityContext, type RequestKeyChange, type RequestKeyPair, type RequestKeyRegistration, type RequestKeyRegistrationBody, type RequestSignature, type RequestSignatureV2, type Run, type RunStats, type RunStatus, type RunSummary, type RunsExport, type RunsExportCSV, type SearchRunsParams, type SignOffDecision, type SignOffOptions, type SignOffRecord, type SignOffSignature, type SignOffTarget, type SignOffTargetKind, type SignedRequestBody, VerdifaxClient, VerdifaxError, VerdifaxJob, type VerdifaxVersion, type VerifyDeterminismResponse, type VerifyResponse, approverKeyProof, captureEnvironment, cresReceiptHash, dcaeClosureHash, dseDispatchHash, formatProviderPayload, fromEnv, generateRequestKeyPair, policyActivationApproval, policyActivationPreimage, requestKeyChangeApproval, requestKeyChangePreimage, requestKeyRegistrationBody, requestSignaturePreimage, requestSignaturePreimageV2, signOffPreimage, signRequest, signRequestV2, validateHex64, validateJobName, validateRouteId };