verdifax 1.1.0 → 1.3.0

package/dist/index.d.ts

@@ -71,10 +71,117 @@ interface ExecuteRequest {
     /** Places this run in a job map. Not accepted by a determinism check,
      *  which runs twice. */
     job?: JobLink;
+    /** What this request declares for the rules of an active customer policy
+     *  to read. Unknown keys and values outside the lists are refused before
+     *  sending. */
+    policy_context?: PolicyContext;
+    /** The policy hash this request expects to run under. When another policy
+     *  is active the server refuses the run with HTTP 409. */
+    expected_policy_hash?: Hex64;
     /** A version 1 signature for an unsigned client to send. A client with
      *  the `signingKey` option sends version 2 and drops this field. */
     request_signature?: RequestSignature;
 }
+/** Who the attested actor is, for a policy rule to read. */
+type PolicyActorType = "agent" | "user" | "service" | "system";
+/** What the request acts on, for a policy rule to read. */
+type PolicyObjectType = "text" | "transaction" | "code" | "data" | "model" | "file";
+/** A classification level, for a policy rule to read. */
+type PolicyClassification = "PUBLIC" | "INTERNAL" | "CONFIDENTIAL" | "RESTRICTED" | "TOP_SECRET" | "TS_SCI";
+/** The facts a request declares for the rules of a customer policy. These
+ *  are the caller's own statements: a rule on them judges what was
+ *  declared, and cannot show that it is true. Every key is optional, and
+ *  the client refuses any other key before sending, because a misspelt key
+ *  would be dropped and a rule on it would read its zero value.
+ *
+ *  `actor_type`, `mfa_satisfied` and `session_age_seconds` describe the
+ *  attested actor, so a request that sets one of them must also carry an
+ *  `attested_context` naming the actor, for example its `actor_id`. */
+interface PolicyContext {
+    actor_type?: PolicyActorType;
+    mfa_satisfied?: boolean;
+    /** A non-negative whole number of seconds. */
+    session_age_seconds?: number;
+    object_type?: PolicyObjectType;
+    /** At most 256 bytes of UTF-8. */
+    object_id?: string;
+    classification?: PolicyClassification;
+}
+/** A stored policy document, as POST /policies and GET /policies return
+ *  it. */
+interface Policy {
+    policy_id: string;
+    policy_version: string;
+    policy_hash: Hex64;
+    /** SHA-256 of the exact text that was uploaded. */
+    document_hash: Hex64;
+    created_at: string;
+}
+/** Returned by {@link VerdifaxClient.getPolicy}: the stored policy and its
+ *  exact text. */
+interface PolicyWithDocument extends Policy {
+    document: string;
+}
+/** Returned by {@link VerdifaxClient.listPolicies}. */
+interface PolicyList {
+    ok: boolean;
+    /** The chain of this key's policy changes, for example `api-key-7`. */
+    chain_id?: string;
+    /** The newest change, or 64 zeros when there is none yet. */
+    newest_activation_hash: Hex64;
+    /** The document in force, or empty under the built-in policy. */
+    active_document_hash: string;
+    policies: Policy[];
+}
+/** The argument of {@link VerdifaxClient.testPolicy}: sample inputs and
+ *  exactly one of `document` or `documentHash`. */
+interface PolicyTestRequest {
+    /** Sample inputs for the rules, passed through as given. */
+    inputs: Record<string, unknown>;
+    /** The exact text of a policy to test. */
+    document?: string;
+    /** The document hash of a policy already uploaded under this key. */
+    documentHash?: Hex64;
+}
+/** Returned by {@link VerdifaxClient.testPolicy}. A test seals nothing. */
+interface PolicyTestResult {
+    ok: boolean;
+    /** Always false. */
+    sealed: boolean;
+    outcome: string;
+    fired_rule_id: string;
+    reason_code: string;
+}
+/** The signature of a policy activation: the request key's approval of
+ *  the change. */
+interface PolicyActivationSignature {
+    /** Base64 Ed25519 signature by the request key. */
+    signature: string;
+    /** RFC 3339 UTC with whole seconds. */
+    signed_at: string;
+    /** 16 random bytes as 32 lowercase hex characters, fresh per change. */
+    nonce: string;
+}
+/** One policy change, as {@link VerdifaxClient.activatePolicy} and
+ *  {@link VerdifaxClient.getPolicyHistory} return it. */
+interface PolicyActivation {
+    format: string;
+    chain_id: string;
+    sequence: number;
+    previous_activation_hash: Hex64;
+    policy_id: string;
+    policy_version: string;
+    policy_hash: Hex64;
+    document_hash: Hex64;
+    activated_at: string;
+    /** Present when the request key signed the change. */
+    signature?: PolicyActivationSignature & {
+        public_key: string;
+    };
+    activation_hash: Hex64;
+    /** Where the change was logged on the public log. */
+    anchor?: Record<string, unknown>;
+}
 /** Places one run in a job. `job_id` and `step_id` are 1 to 128 letters,
  *  digits, dots, underscores, colons or dashes. The client sorts both
  *  lists, removes repeats and leaves out an empty list and a false
@@ -211,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 {
@@ -220,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;
@@ -341,6 +456,10 @@ interface AttestRequest {
     causal_graph?: Record<string, unknown>;
     /** Places this run in a job map. {@link VerdifaxJob.step} fills it in. */
     job?: JobLink;
+    /** What this request declares for the rules of a customer policy. */
+    policy_context?: PolicyContext;
+    /** The policy hash this request expects to run under. */
+    expected_policy_hash?: Hex64;
 }
 /** The second argument of {@link VerdifaxJob.step}: everything
  *  {@link VerdifaxClient.attest} takes except `job`, which the helper
@@ -365,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;
@@ -401,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;
@@ -430,6 +554,21 @@ 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;
 }
 /** Returned by {@link VerdifaxClient.exportRunsCSV}. */
 interface RunsExportCSV {
@@ -518,6 +657,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. */
@@ -611,15 +837,38 @@ 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 |
  * | `rotateRequestKey(newSigningKey)` | POST /keys/request-key | required |
  * | `clearRequestKey()` | DELETE /keys/request-key | required |
+ * | `uploadPolicy(document)` | POST /policies | required |
+ * | `listPolicies()` | GET /policies | required |
+ * | `getPolicy(documentHash)` | GET /policies/{document_hash} | required |
+ * | `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 |
  * | `job(jobId)` | none, returns a {@link VerdifaxJob} | none |
  *
  * With the `signingKey` option set, every path to POST /execute carries
@@ -658,8 +907,9 @@ declare class VerdifaxClient {
      *  signing key each row carries its own signature and nonce. A row
      *  that fails comes back in `results` with `ok: false`, so the call
      *  does not throw for it. The rows are not checked here, except a job
-     *  block, which is refused before anything is sent: the server reports
-     *  any other bad row in that row's result.
+     *  block, a `policy_context` and an `expected_policy_hash`, which are
+     *  refused before anything is sent: the server reports any other bad row
+     *  in that row's result.
      *
      *  This is one POST and it is never retried. After a timeout the
      *  server may have run some or all of the rows. */
@@ -677,6 +927,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
@@ -690,12 +941,109 @@ 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
+     *  not a string: serializing an object here would change the hash.
+     *  Verdifax does not write, review or approve a customer's policy. */
+    uploadPolicy(document: string): Promise<Policy>;
+    /** This key's stored documents, with the chain its changes belong to,
+     *  the newest change in it (64 zeros when there is none yet) and the
+     *  document in force (empty under the built-in policy). */
+    listPolicies(): Promise<PolicyList>;
+    /** One stored document, with its exact text as `document`. */
+    getPolicy(documentHash: Hex64): Promise<PolicyWithDocument>;
+    /** Shows which rule would fire on sample inputs, for a document given as
+     *  text or one already stored, named by its hash: exactly one of the two.
+     *  It seals nothing. */
+    testPolicy(req: PolicyTestRequest): Promise<PolicyTestResult>;
+    /** This key's policy changes, oldest first, as the list the server sends.
+     *  Save it as JSON, for example with
+     *  `writeFileSync("policy-history.json", JSON.stringify(history))`, and
+     *  check it with `verdifax-verify --policy-history policy-history.json`. */
+    getPolicyHistory(): Promise<PolicyActivation[]>;
+    /** Makes a stored document the policy in force and returns the change
+     *  record. It first reads GET /policies for the chain and its newest
+     *  change, then names that change as the one this follows. With the
+     *  `signingKey` option the request key signs the change, which the server
+     *  requires while a request key is registered.
+     *
+     *  Rolling back is activating an earlier document: it is one more change
+     *  in the chain, so the change it undoes stays on the record.
+     *
+     *  An HTTP 409 means the chain moved because another change came first,
+     *  or the document is not yet effective. It throws the usual
+     *  {@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>;
     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. */
@@ -714,6 +1062,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>>;
@@ -744,7 +1093,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
@@ -763,6 +1121,8 @@ declare class VerdifaxClient {
         response: string;
         govern?: boolean;
         job?: JobLink;
+        policy_context?: PolicyContext;
+        expected_policy_hash?: Hex64;
     }): Promise<ExecuteResponse>;
     /** Convenience for attesting an OpenAI API response. `govern` works as
      *  in {@link attestClaudeResponse}. */
@@ -774,6 +1134,8 @@ declare class VerdifaxClient {
         response: string;
         govern?: boolean;
         job?: JobLink;
+        policy_context?: PolicyContext;
+        expected_policy_hash?: Hex64;
     }): Promise<ExecuteResponse>;
     private attestProviderResponse;
     private request;
@@ -838,6 +1200,9 @@ declare function captureEnvironment(options?: CaptureEnvironmentOptions): Reprod
  * Text with an unpaired surrogate has no UTF-8 form and is refused.
  */
 declare function formatProviderPayload(provider: string, prompt: string, response: string): string;
+/** Every top-level key a run request may hold. Any other key is refused
+ *  before sending, so a misspelt field cannot be silently dropped. */
+declare const EXECUTE_FIELDS: readonly string[];
 
 /**
  * The three canonical hash formulas from the Verdifax orchestrator, so a
@@ -961,6 +1326,29 @@ declare function requestKeyChangeApproval(currentSigningKey: Uint8Array | KeyObj
     signedAt?: string;
     nonce?: string;
 }): RequestKeyChange;
+/** The bytes the request key signs to make a stored policy document the
+ *  one in force, matching the orchestrator's PolicyActivationPreimage.
+ *  `chain_id` and `previous_activation_hash` come from GET /policies, so a
+ *  signature cannot be used on another key's chain, another document or
+ *  another point in the chain. */
+declare function policyActivationPreimage(fields: {
+    chain_id: string;
+    document_hash: string;
+    previous_activation_hash: string;
+    signed_at: string;
+    nonce: string;
+}): Buffer;
+/** The request key's approval of a policy change, the `signature` value of
+ *  POST /policies/{document_hash}/activate. `signedAt` and `nonce` default
+ *  to the current time and fresh random bytes. */
+declare function policyActivationApproval(signingKey: Uint8Array | KeyObject, fields: {
+    chain_id: string;
+    document_hash: string;
+    previous_activation_hash: string;
+}, options?: {
+    signedAt?: string;
+    nonce?: string;
+}): PolicyActivationSignature;
 
 /**
  * Input-validation helpers, mirrors the Python SDK's
@@ -1046,4 +1434,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, 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, 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, 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 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, 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 };