@axtary/actionpass 0.0.1 → 0.2.0

package/dist/index.d.ts

@@ -0,0 +1,1670 @@
+import { type CryptoKey, type JWK, type KeyObject } from "jose";
+import { z } from "zod";
+import { type ActionPassStatusClaim } from "./status-list.js";
+import { type ActionProvenance } from "./provenance.js";
+import { type PolicyDecisionExplanation } from "./explain.js";
+export * from "./caep.js";
+export * from "./dev-key.js";
+export * from "./explain.js";
+export * from "./postgres.js";
+export * from "./provenance.js";
+export * from "./status-list.js";
+export declare const ACTION_SCHEMA_VERSION = "axtary.action.v0";
+export declare const ACTIONPASS_V0_VERSION = "axtary.actionpass.v0";
+export declare const ACTIONPASS_V1_VERSION = "axtary.actionpass.v1";
+export declare const ACTIONPASS_V2_VERSION = "axtary.actionpass.v2";
+export declare const ACTIONPASS_VERSION = "axtary.actionpass.v0";
+export declare const APPROVAL_ARTIFACT_VERSION = "axtary.approval.v0";
+export declare const ACTIONPASS_REVOCATION_VERSION = "axtary.actionpass_revocation.v0";
+export declare const ACTIONPASS_TRUST_STORE_VERSION = "axtary.actionpass_trust_store.v0";
+export declare const LEDGER_SCHEMA_VERSION = "axtary.ledger.v0";
+export declare const LEDGER_PROVIDER_EVIDENCE_VERSION = "axtary.ledger_provider_evidence.v0";
+export declare const LEDGER_EXECUTION_OUTCOME_VERSION = "axtary.ledger_execution_outcome.v0";
+export declare const DEFAULT_EXPIRES_IN_SECONDS = 600;
+export declare const DEFAULT_SIGNING_ALGORITHM = "ES256";
+export declare const DPOP_PROOF_TYP = "dpop+jwt";
+export declare const DEFAULT_DPOP_MAX_AGE_SECONDS = 60;
+export declare const DEFAULT_DPOP_CLOCK_SKEW_SECONDS = 5;
+export type JsonValue = string | number | boolean | null | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+export declare const BudgetAmountSchema: z.ZodRecord<z.ZodString, z.ZodNumber>;
+export type BudgetAmount = z.infer<typeof BudgetAmountSchema>;
+export declare const ActionBudgetSchema: z.ZodObject<{
+    reservationId: z.ZodString;
+    cost: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    limit: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    commitStatus: z.ZodEnum<{
+        pending: "pending";
+        committed: "committed";
+        rolled_back: "rolled_back";
+    }>;
+}, z.core.$strip>;
+export type ActionBudget = z.infer<typeof ActionBudgetSchema>;
+export declare const AxtaryDecisionSchema: z.ZodEnum<{
+    allow: "allow";
+    deny: "deny";
+    step_up: "step_up";
+}>;
+export type AxtaryDecision = z.infer<typeof AxtaryDecisionSchema>;
+export declare const NormalizedActionSchema: z.ZodObject<{
+    schemaVersion: z.ZodDefault<z.ZodLiteral<"axtary.action.v0">>;
+    actor: z.ZodObject<{
+        agentId: z.ZodString;
+        humanOwner: z.ZodString;
+        runtime: z.ZodString;
+        tenant: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    intent: z.ZodObject<{
+        taskId: z.ZodString;
+        declaredGoal: z.ZodString;
+        maxDelegationDepth: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+    capability: z.ZodObject<{
+        tool: z.ZodString;
+        resource: z.ZodString;
+        payload: z.ZodRecord<z.ZodString, z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>;
+        constraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>>;
+    }, z.core.$strip>;
+    toolDefinition: z.ZodOptional<z.ZodObject<{
+        serverIdentity: z.ZodString;
+        schemaVersion: z.ZodString;
+        definitionHash: z.ZodString;
+        publisher: z.ZodOptional<z.ZodString>;
+        publisherKeyId: z.ZodOptional<z.ZodString>;
+        semver: z.ZodOptional<z.ZodString>;
+        priorDefinitionHash: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    provenance: z.ZodOptional<z.ZodObject<{
+        schemaVersion: z.ZodDefault<z.ZodLiteral<"axtary.provenance.v0">>;
+        sources: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            kind: z.ZodEnum<{
+                unknown: "unknown";
+                task: "task";
+                operator: "operator";
+                document: "document";
+                tool_output: "tool_output";
+                connector: "connector";
+            }>;
+            integrity: z.ZodEnum<{
+                unknown: "unknown";
+                trusted: "trusted";
+                untrusted: "untrusted";
+            }>;
+            resource: z.ZodOptional<z.ZodString>;
+            observedAt: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        bindings: z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            sourceIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    budget: z.ZodOptional<z.ZodObject<{
+        reservationId: z.ZodString;
+        cost: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        limit: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        commitStatus: z.ZodEnum<{
+            pending: "pending";
+            committed: "committed";
+            rolled_back: "rolled_back";
+        }>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type NormalizedAction = z.infer<typeof NormalizedActionSchema>;
+export declare const PolicyDecisionSchema: z.ZodObject<{
+    decision: z.ZodEnum<{
+        allow: "allow";
+        deny: "deny";
+        step_up: "step_up";
+    }>;
+    reasons: z.ZodArray<z.ZodString>;
+    policy: z.ZodObject<{
+        nativeRule: z.ZodString;
+        version: z.ZodString;
+        cedarCompatible: z.ZodBoolean;
+        opaCompatible: z.ZodBoolean;
+    }, z.core.$strip>;
+    constraints: z.ZodObject<{
+        expiresInSeconds: z.ZodNumber;
+        maxFilesChanged: z.ZodNumber;
+        blockedPaths: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>;
+    rule: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        matchedRuleIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+    obligations: z.ZodOptional<z.ZodObject<{
+        requiredApproverRoles: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        timeWindow: z.ZodOptional<z.ZodObject<{
+            startHourUtc: z.ZodNumber;
+            endHourUtc: z.ZodNumber;
+            daysOfWeek: z.ZodDefault<z.ZodArray<z.ZodNumber>>;
+        }, z.core.$strip>>;
+        rateLimit: z.ZodOptional<z.ZodObject<{
+            ruleId: z.ZodString;
+            maxActions: z.ZodNumber;
+            windowSeconds: z.ZodNumber;
+            scope: z.ZodEnum<{
+                resource: "resource";
+                actor: "actor";
+                tenant: "tenant";
+                tool: "tool";
+            }>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type PolicyDecision = z.infer<typeof PolicyDecisionSchema>;
+export type ActionPassDecision = PolicyDecision;
+export declare const ApprovalSchema: z.ZodObject<{
+    mode: z.ZodEnum<{
+        none: "none";
+        human: "human";
+        policy_override: "policy_override";
+    }>;
+    approvedBy: z.ZodOptional<z.ZodString>;
+    approverRoles: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    approvalArtifact: z.ZodOptional<z.ZodString>;
+    approvalArtifactHash: z.ZodOptional<z.ZodString>;
+    actionHash: z.ZodOptional<z.ZodString>;
+    payloadHash: z.ZodOptional<z.ZodString>;
+    approvedAt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type Approval = z.infer<typeof ApprovalSchema>;
+export declare const ApprovalArtifactSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"axtary.approval.v0">;
+    id: z.ZodString;
+    mode: z.ZodEnum<{
+        human: "human";
+        policy_override: "policy_override";
+    }>;
+    approvedBy: z.ZodString;
+    approverRoles: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    approvedAt: z.ZodString;
+    actionHash: z.ZodString;
+    payloadHash: z.ZodString;
+    taskId: z.ZodString;
+    tool: z.ZodString;
+    resource: z.ZodString;
+    reason: z.ZodOptional<z.ZodString>;
+    expiresAt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ApprovalArtifact = z.infer<typeof ApprovalArtifactSchema>;
+export declare const ActionPassV0ClaimsSchema: z.ZodObject<{
+    iss: z.ZodString;
+    sub: z.ZodString;
+    aud: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
+    exp: z.ZodNumber;
+    nbf: z.ZodNumber;
+    iat: z.ZodNumber;
+    jti: z.ZodString;
+    tenant: z.ZodString;
+    humanOwner: z.ZodString;
+    agentRuntime: z.ZodString;
+    intent: z.ZodObject<{
+        taskId: z.ZodString;
+        declaredGoal: z.ZodString;
+        maxDelegationDepth: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+    capability: z.ZodObject<{
+        tool: z.ZodString;
+        resource: z.ZodString;
+        constraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>>;
+    }, z.core.$strip>;
+    decision: z.ZodEnum<{
+        allow: "allow";
+        deny: "deny";
+        step_up: "step_up";
+    }>;
+    reasons: z.ZodArray<z.ZodString>;
+    policy: z.ZodObject<{
+        nativeRule: z.ZodString;
+        version: z.ZodString;
+        cedarCompatible: z.ZodBoolean;
+        opaCompatible: z.ZodBoolean;
+    }, z.core.$strip>;
+    payloadHash: z.ZodString;
+    provenanceHash: z.ZodOptional<z.ZodString>;
+    budget: z.ZodOptional<z.ZodObject<{
+        reservationId: z.ZodString;
+        cost: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        limit: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        commitStatus: z.ZodEnum<{
+            pending: "pending";
+            committed: "committed";
+            rolled_back: "rolled_back";
+        }>;
+    }, z.core.$strip>>;
+    approval: z.ZodOptional<z.ZodObject<{
+        mode: z.ZodEnum<{
+            none: "none";
+            human: "human";
+            policy_override: "policy_override";
+        }>;
+        approvedBy: z.ZodOptional<z.ZodString>;
+        approverRoles: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        approvalArtifact: z.ZodOptional<z.ZodString>;
+        approvalArtifactHash: z.ZodOptional<z.ZodString>;
+        actionHash: z.ZodOptional<z.ZodString>;
+        payloadHash: z.ZodOptional<z.ZodString>;
+        approvedAt: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    audit: z.ZodObject<{
+        traceId: z.ZodString;
+        parentPassId: z.ZodNullable<z.ZodString>;
+        ledgerHash: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+    apv: z.ZodLiteral<"axtary.actionpass.v0">;
+}, z.core.$strip>;
+export declare const ActionPassV1ClaimsSchema: z.ZodObject<{
+    cnf: z.ZodObject<{
+        jkt: z.ZodString;
+    }, z.core.$strip>;
+    delegation: z.ZodOptional<z.ZodObject<{
+        depth: z.ZodNumber;
+        rootPassId: z.ZodString;
+    }, z.core.$strip>>;
+    iss: z.ZodString;
+    sub: z.ZodString;
+    aud: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
+    exp: z.ZodNumber;
+    nbf: z.ZodNumber;
+    iat: z.ZodNumber;
+    jti: z.ZodString;
+    tenant: z.ZodString;
+    humanOwner: z.ZodString;
+    agentRuntime: z.ZodString;
+    intent: z.ZodObject<{
+        taskId: z.ZodString;
+        declaredGoal: z.ZodString;
+        maxDelegationDepth: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+    capability: z.ZodObject<{
+        tool: z.ZodString;
+        resource: z.ZodString;
+        constraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>>;
+    }, z.core.$strip>;
+    decision: z.ZodEnum<{
+        allow: "allow";
+        deny: "deny";
+        step_up: "step_up";
+    }>;
+    reasons: z.ZodArray<z.ZodString>;
+    policy: z.ZodObject<{
+        nativeRule: z.ZodString;
+        version: z.ZodString;
+        cedarCompatible: z.ZodBoolean;
+        opaCompatible: z.ZodBoolean;
+    }, z.core.$strip>;
+    payloadHash: z.ZodString;
+    provenanceHash: z.ZodOptional<z.ZodString>;
+    budget: z.ZodOptional<z.ZodObject<{
+        reservationId: z.ZodString;
+        cost: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        limit: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        commitStatus: z.ZodEnum<{
+            pending: "pending";
+            committed: "committed";
+            rolled_back: "rolled_back";
+        }>;
+    }, z.core.$strip>>;
+    approval: z.ZodOptional<z.ZodObject<{
+        mode: z.ZodEnum<{
+            none: "none";
+            human: "human";
+            policy_override: "policy_override";
+        }>;
+        approvedBy: z.ZodOptional<z.ZodString>;
+        approverRoles: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        approvalArtifact: z.ZodOptional<z.ZodString>;
+        approvalArtifactHash: z.ZodOptional<z.ZodString>;
+        actionHash: z.ZodOptional<z.ZodString>;
+        payloadHash: z.ZodOptional<z.ZodString>;
+        approvedAt: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    audit: z.ZodObject<{
+        traceId: z.ZodString;
+        parentPassId: z.ZodNullable<z.ZodString>;
+        ledgerHash: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+    apv: z.ZodLiteral<"axtary.actionpass.v1">;
+}, z.core.$strip>;
+export declare const ActionPassV2ClaimsSchema: z.ZodObject<{
+    cnf: z.ZodObject<{
+        jkt: z.ZodString;
+    }, z.core.$strip>;
+    delegation: z.ZodOptional<z.ZodObject<{
+        depth: z.ZodNumber;
+        rootPassId: z.ZodString;
+    }, z.core.$strip>>;
+    status: z.ZodObject<{
+        status_list: z.ZodObject<{
+            idx: z.ZodNumber;
+            uri: z.ZodString;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+    iss: z.ZodString;
+    sub: z.ZodString;
+    aud: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
+    exp: z.ZodNumber;
+    nbf: z.ZodNumber;
+    iat: z.ZodNumber;
+    jti: z.ZodString;
+    tenant: z.ZodString;
+    humanOwner: z.ZodString;
+    agentRuntime: z.ZodString;
+    intent: z.ZodObject<{
+        taskId: z.ZodString;
+        declaredGoal: z.ZodString;
+        maxDelegationDepth: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+    capability: z.ZodObject<{
+        tool: z.ZodString;
+        resource: z.ZodString;
+        constraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>>;
+    }, z.core.$strip>;
+    decision: z.ZodEnum<{
+        allow: "allow";
+        deny: "deny";
+        step_up: "step_up";
+    }>;
+    reasons: z.ZodArray<z.ZodString>;
+    policy: z.ZodObject<{
+        nativeRule: z.ZodString;
+        version: z.ZodString;
+        cedarCompatible: z.ZodBoolean;
+        opaCompatible: z.ZodBoolean;
+    }, z.core.$strip>;
+    payloadHash: z.ZodString;
+    provenanceHash: z.ZodOptional<z.ZodString>;
+    budget: z.ZodOptional<z.ZodObject<{
+        reservationId: z.ZodString;
+        cost: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        limit: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        commitStatus: z.ZodEnum<{
+            pending: "pending";
+            committed: "committed";
+            rolled_back: "rolled_back";
+        }>;
+    }, z.core.$strip>>;
+    approval: z.ZodOptional<z.ZodObject<{
+        mode: z.ZodEnum<{
+            none: "none";
+            human: "human";
+            policy_override: "policy_override";
+        }>;
+        approvedBy: z.ZodOptional<z.ZodString>;
+        approverRoles: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        approvalArtifact: z.ZodOptional<z.ZodString>;
+        approvalArtifactHash: z.ZodOptional<z.ZodString>;
+        actionHash: z.ZodOptional<z.ZodString>;
+        payloadHash: z.ZodOptional<z.ZodString>;
+        approvedAt: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    audit: z.ZodObject<{
+        traceId: z.ZodString;
+        parentPassId: z.ZodNullable<z.ZodString>;
+        ledgerHash: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+    apv: z.ZodLiteral<"axtary.actionpass.v2">;
+}, z.core.$strip>;
+export declare const ActionPassClaimsSchema: z.ZodUnion<readonly [z.ZodObject<{
+    iss: z.ZodString;
+    sub: z.ZodString;
+    aud: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
+    exp: z.ZodNumber;
+    nbf: z.ZodNumber;
+    iat: z.ZodNumber;
+    jti: z.ZodString;
+    tenant: z.ZodString;
+    humanOwner: z.ZodString;
+    agentRuntime: z.ZodString;
+    intent: z.ZodObject<{
+        taskId: z.ZodString;
+        declaredGoal: z.ZodString;
+        maxDelegationDepth: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+    capability: z.ZodObject<{
+        tool: z.ZodString;
+        resource: z.ZodString;
+        constraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>>;
+    }, z.core.$strip>;
+    decision: z.ZodEnum<{
+        allow: "allow";
+        deny: "deny";
+        step_up: "step_up";
+    }>;
+    reasons: z.ZodArray<z.ZodString>;
+    policy: z.ZodObject<{
+        nativeRule: z.ZodString;
+        version: z.ZodString;
+        cedarCompatible: z.ZodBoolean;
+        opaCompatible: z.ZodBoolean;
+    }, z.core.$strip>;
+    payloadHash: z.ZodString;
+    provenanceHash: z.ZodOptional<z.ZodString>;
+    budget: z.ZodOptional<z.ZodObject<{
+        reservationId: z.ZodString;
+        cost: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        limit: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        commitStatus: z.ZodEnum<{
+            pending: "pending";
+            committed: "committed";
+            rolled_back: "rolled_back";
+        }>;
+    }, z.core.$strip>>;
+    approval: z.ZodOptional<z.ZodObject<{
+        mode: z.ZodEnum<{
+            none: "none";
+            human: "human";
+            policy_override: "policy_override";
+        }>;
+        approvedBy: z.ZodOptional<z.ZodString>;
+        approverRoles: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        approvalArtifact: z.ZodOptional<z.ZodString>;
+        approvalArtifactHash: z.ZodOptional<z.ZodString>;
+        actionHash: z.ZodOptional<z.ZodString>;
+        payloadHash: z.ZodOptional<z.ZodString>;
+        approvedAt: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    audit: z.ZodObject<{
+        traceId: z.ZodString;
+        parentPassId: z.ZodNullable<z.ZodString>;
+        ledgerHash: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+    apv: z.ZodLiteral<"axtary.actionpass.v0">;
+}, z.core.$strip>, z.ZodObject<{
+    cnf: z.ZodObject<{
+        jkt: z.ZodString;
+    }, z.core.$strip>;
+    delegation: z.ZodOptional<z.ZodObject<{
+        depth: z.ZodNumber;
+        rootPassId: z.ZodString;
+    }, z.core.$strip>>;
+    iss: z.ZodString;
+    sub: z.ZodString;
+    aud: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
+    exp: z.ZodNumber;
+    nbf: z.ZodNumber;
+    iat: z.ZodNumber;
+    jti: z.ZodString;
+    tenant: z.ZodString;
+    humanOwner: z.ZodString;
+    agentRuntime: z.ZodString;
+    intent: z.ZodObject<{
+        taskId: z.ZodString;
+        declaredGoal: z.ZodString;
+        maxDelegationDepth: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+    capability: z.ZodObject<{
+        tool: z.ZodString;
+        resource: z.ZodString;
+        constraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>>;
+    }, z.core.$strip>;
+    decision: z.ZodEnum<{
+        allow: "allow";
+        deny: "deny";
+        step_up: "step_up";
+    }>;
+    reasons: z.ZodArray<z.ZodString>;
+    policy: z.ZodObject<{
+        nativeRule: z.ZodString;
+        version: z.ZodString;
+        cedarCompatible: z.ZodBoolean;
+        opaCompatible: z.ZodBoolean;
+    }, z.core.$strip>;
+    payloadHash: z.ZodString;
+    provenanceHash: z.ZodOptional<z.ZodString>;
+    budget: z.ZodOptional<z.ZodObject<{
+        reservationId: z.ZodString;
+        cost: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        limit: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        commitStatus: z.ZodEnum<{
+            pending: "pending";
+            committed: "committed";
+            rolled_back: "rolled_back";
+        }>;
+    }, z.core.$strip>>;
+    approval: z.ZodOptional<z.ZodObject<{
+        mode: z.ZodEnum<{
+            none: "none";
+            human: "human";
+            policy_override: "policy_override";
+        }>;
+        approvedBy: z.ZodOptional<z.ZodString>;
+        approverRoles: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        approvalArtifact: z.ZodOptional<z.ZodString>;
+        approvalArtifactHash: z.ZodOptional<z.ZodString>;
+        actionHash: z.ZodOptional<z.ZodString>;
+        payloadHash: z.ZodOptional<z.ZodString>;
+        approvedAt: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    audit: z.ZodObject<{
+        traceId: z.ZodString;
+        parentPassId: z.ZodNullable<z.ZodString>;
+        ledgerHash: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+    apv: z.ZodLiteral<"axtary.actionpass.v1">;
+}, z.core.$strip>, z.ZodObject<{
+    cnf: z.ZodObject<{
+        jkt: z.ZodString;
+    }, z.core.$strip>;
+    delegation: z.ZodOptional<z.ZodObject<{
+        depth: z.ZodNumber;
+        rootPassId: z.ZodString;
+    }, z.core.$strip>>;
+    status: z.ZodObject<{
+        status_list: z.ZodObject<{
+            idx: z.ZodNumber;
+            uri: z.ZodString;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+    iss: z.ZodString;
+    sub: z.ZodString;
+    aud: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
+    exp: z.ZodNumber;
+    nbf: z.ZodNumber;
+    iat: z.ZodNumber;
+    jti: z.ZodString;
+    tenant: z.ZodString;
+    humanOwner: z.ZodString;
+    agentRuntime: z.ZodString;
+    intent: z.ZodObject<{
+        taskId: z.ZodString;
+        declaredGoal: z.ZodString;
+        maxDelegationDepth: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+    capability: z.ZodObject<{
+        tool: z.ZodString;
+        resource: z.ZodString;
+        constraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>>;
+    }, z.core.$strip>;
+    decision: z.ZodEnum<{
+        allow: "allow";
+        deny: "deny";
+        step_up: "step_up";
+    }>;
+    reasons: z.ZodArray<z.ZodString>;
+    policy: z.ZodObject<{
+        nativeRule: z.ZodString;
+        version: z.ZodString;
+        cedarCompatible: z.ZodBoolean;
+        opaCompatible: z.ZodBoolean;
+    }, z.core.$strip>;
+    payloadHash: z.ZodString;
+    provenanceHash: z.ZodOptional<z.ZodString>;
+    budget: z.ZodOptional<z.ZodObject<{
+        reservationId: z.ZodString;
+        cost: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        limit: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        commitStatus: z.ZodEnum<{
+            pending: "pending";
+            committed: "committed";
+            rolled_back: "rolled_back";
+        }>;
+    }, z.core.$strip>>;
+    approval: z.ZodOptional<z.ZodObject<{
+        mode: z.ZodEnum<{
+            none: "none";
+            human: "human";
+            policy_override: "policy_override";
+        }>;
+        approvedBy: z.ZodOptional<z.ZodString>;
+        approverRoles: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        approvalArtifact: z.ZodOptional<z.ZodString>;
+        approvalArtifactHash: z.ZodOptional<z.ZodString>;
+        actionHash: z.ZodOptional<z.ZodString>;
+        payloadHash: z.ZodOptional<z.ZodString>;
+        approvedAt: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    audit: z.ZodObject<{
+        traceId: z.ZodString;
+        parentPassId: z.ZodNullable<z.ZodString>;
+        ledgerHash: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+    apv: z.ZodLiteral<"axtary.actionpass.v2">;
+}, z.core.$strip>]>;
+export type ActionPassClaims = z.infer<typeof ActionPassClaimsSchema>;
+export type ActionPassV1Claims = z.infer<typeof ActionPassV1ClaimsSchema>;
+export type ActionPassV2Claims = z.infer<typeof ActionPassV2ClaimsSchema>;
+export declare const DpopProofClaimsSchema: z.ZodObject<{
+    htm: z.ZodString;
+    htu: z.ZodString;
+    iat: z.ZodNumber;
+    jti: z.ZodString;
+    ath: z.ZodString;
+    nonce: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type DpopProofClaims = z.infer<typeof DpopProofClaimsSchema>;
+export declare const ActionPassRevocationSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"axtary.actionpass_revocation.v0">;
+    passId: z.ZodString;
+    revokedAt: z.ZodString;
+    revokedBy: z.ZodOptional<z.ZodString>;
+    reason: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ActionPassRevocation = z.infer<typeof ActionPassRevocationSchema>;
+export declare const ActionPassVerificationKeyRecordSchema: z.ZodObject<{
+    kid: z.ZodString;
+    publicJwk: z.ZodRecord<z.ZodString, z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>;
+    algorithm: z.ZodOptional<z.ZodString>;
+    status: z.ZodDefault<z.ZodEnum<{
+        active: "active";
+        retired: "retired";
+        revoked: "revoked";
+    }>>;
+    notBefore: z.ZodOptional<z.ZodString>;
+    expiresAt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ActionPassVerificationKeyRecord = z.infer<typeof ActionPassVerificationKeyRecordSchema>;
+export type ActionPassVerificationKeyRecordInput = Omit<z.input<typeof ActionPassVerificationKeyRecordSchema>, "publicJwk"> & {
+    publicJwk: Record<string, JsonValue> | JWK;
+};
+export declare const ActionPassTrustStoreSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"axtary.actionpass_trust_store.v0">;
+    keys: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        kid: z.ZodString;
+        publicJwk: z.ZodRecord<z.ZodString, z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>;
+        algorithm: z.ZodOptional<z.ZodString>;
+        status: z.ZodDefault<z.ZodEnum<{
+            active: "active";
+            retired: "retired";
+            revoked: "revoked";
+        }>>;
+        notBefore: z.ZodOptional<z.ZodString>;
+        expiresAt: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    revocations: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"axtary.actionpass_revocation.v0">;
+        passId: z.ZodString;
+        revokedAt: z.ZodString;
+        revokedBy: z.ZodOptional<z.ZodString>;
+        reason: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type ActionPassTrustStoreData = z.infer<typeof ActionPassTrustStoreSchema>;
+export declare const LedgerProviderEvidenceDiffLineSchema: z.ZodObject<{
+    type: z.ZodEnum<{
+        context: "context";
+        addition: "addition";
+        deletion: "deletion";
+    }>;
+    content: z.ZodString;
+    oldLine: z.ZodOptional<z.ZodNumber>;
+    newLine: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type LedgerProviderEvidenceDiffLine = z.infer<typeof LedgerProviderEvidenceDiffLineSchema>;
+export declare const LedgerProviderEvidenceDiffFileSchema: z.ZodObject<{
+    path: z.ZodString;
+    oldPath: z.ZodOptional<z.ZodString>;
+    status: z.ZodEnum<{
+        added: "added";
+        modified: "modified";
+        deleted: "deleted";
+        renamed: "renamed";
+    }>;
+    additions: z.ZodDefault<z.ZodNumber>;
+    deletions: z.ZodDefault<z.ZodNumber>;
+    hunks: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        header: z.ZodString;
+        lines: z.ZodArray<z.ZodObject<{
+            type: z.ZodEnum<{
+                context: "context";
+                addition: "addition";
+                deletion: "deletion";
+            }>;
+            content: z.ZodString;
+            oldLine: z.ZodOptional<z.ZodNumber>;
+            newLine: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type LedgerProviderEvidenceDiffFile = z.infer<typeof LedgerProviderEvidenceDiffFileSchema>;
+export declare const LedgerProviderSchema: z.ZodEnum<{
+    github: "github";
+    slack: "slack";
+    linear: "linear";
+    docs: "docs";
+    drive: "drive";
+    mcp: "mcp";
+    aws: "aws";
+    gcp: "gcp";
+    jira: "jira";
+    postgres: "postgres";
+}>;
+export type LedgerProvider = z.infer<typeof LedgerProviderSchema>;
+export declare const LedgerProviderEvidenceDiffSchema: z.ZodObject<{
+    provider: z.ZodEnum<{
+        github: "github";
+        slack: "slack";
+        linear: "linear";
+        docs: "docs";
+        drive: "drive";
+        mcp: "mcp";
+        aws: "aws";
+        gcp: "gcp";
+        jira: "jira";
+        postgres: "postgres";
+    }>;
+    summary: z.ZodOptional<z.ZodString>;
+    files: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        oldPath: z.ZodOptional<z.ZodString>;
+        status: z.ZodEnum<{
+            added: "added";
+            modified: "modified";
+            deleted: "deleted";
+            renamed: "renamed";
+        }>;
+        additions: z.ZodDefault<z.ZodNumber>;
+        deletions: z.ZodDefault<z.ZodNumber>;
+        hunks: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            header: z.ZodString;
+            lines: z.ZodArray<z.ZodObject<{
+                type: z.ZodEnum<{
+                    context: "context";
+                    addition: "addition";
+                    deletion: "deletion";
+                }>;
+                content: z.ZodString;
+                oldLine: z.ZodOptional<z.ZodNumber>;
+                newLine: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type LedgerProviderEvidenceDiff = z.infer<typeof LedgerProviderEvidenceDiffSchema>;
+export declare const LedgerProviderEvidenceFieldChangeSchema: z.ZodObject<{
+    field: z.ZodString;
+    before: z.ZodOptional<z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>;
+    after: z.ZodOptional<z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>;
+}, z.core.$strip>;
+export type LedgerProviderEvidenceFieldChange = z.infer<typeof LedgerProviderEvidenceFieldChangeSchema>;
+export declare const LedgerProviderEvidenceSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"axtary.ledger_provider_evidence.v0">;
+    provider: z.ZodEnum<{
+        github: "github";
+        slack: "slack";
+        linear: "linear";
+        docs: "docs";
+        drive: "drive";
+        mcp: "mcp";
+        aws: "aws";
+        gcp: "gcp";
+        jira: "jira";
+        postgres: "postgres";
+    }>;
+    tool: z.ZodString;
+    operation: z.ZodString;
+    resource: z.ZodObject<{
+        provider: z.ZodEnum<{
+            github: "github";
+            slack: "slack";
+            linear: "linear";
+            docs: "docs";
+            drive: "drive";
+            mcp: "mcp";
+            aws: "aws";
+            gcp: "gcp";
+            jira: "jira";
+            postgres: "postgres";
+        }>;
+        kind: z.ZodString;
+        id: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        url: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    normalized: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>>;
+    fieldChanges: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        field: z.ZodString;
+        before: z.ZodOptional<z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>;
+        after: z.ZodOptional<z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>;
+    }, z.core.$strip>>>;
+    diff: z.ZodOptional<z.ZodObject<{
+        provider: z.ZodEnum<{
+            github: "github";
+            slack: "slack";
+            linear: "linear";
+            docs: "docs";
+            drive: "drive";
+            mcp: "mcp";
+            aws: "aws";
+            gcp: "gcp";
+            jira: "jira";
+            postgres: "postgres";
+        }>;
+        summary: z.ZodOptional<z.ZodString>;
+        files: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            oldPath: z.ZodOptional<z.ZodString>;
+            status: z.ZodEnum<{
+                added: "added";
+                modified: "modified";
+                deleted: "deleted";
+                renamed: "renamed";
+            }>;
+            additions: z.ZodDefault<z.ZodNumber>;
+            deletions: z.ZodDefault<z.ZodNumber>;
+            hunks: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                header: z.ZodString;
+                lines: z.ZodArray<z.ZodObject<{
+                    type: z.ZodEnum<{
+                        context: "context";
+                        addition: "addition";
+                        deletion: "deletion";
+                    }>;
+                    content: z.ZodString;
+                    oldLine: z.ZodOptional<z.ZodNumber>;
+                    newLine: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type LedgerProviderEvidence = z.infer<typeof LedgerProviderEvidenceSchema>;
+export type ConnectorProvider = "github" | "slack" | "linear" | "jira" | "aws" | "gcp" | "mcp" | "docs" | "drive" | "postgres";
+export type ConnectorCapabilityOperation = "read" | "write" | "external_message" | "identity_read" | "identity_mutation";
+export type ConnectorCapabilityStatus = "supported" | "demo_only" | "planned";
+export type ConnectorCapability = {
+    id: string;
+    provider: ConnectorProvider;
+    connector: string;
+    label: string;
+    tool: string;
+    operation: ConnectorCapabilityOperation;
+    status: ConnectorCapabilityStatus;
+    supportedModes: string[];
+    requiresActionPass: boolean;
+    defaultPolicy: "allow" | "deny" | "step_up" | "deny_until_scoped";
+    payloadFields: string[];
+    approvalTriggers: string[];
+    credentialBoundary: string;
+    smokeCheck: string | null;
+};
+export type ConnectorProviderMode = "fake" | "rest" | "app" | "web" | "graphql" | "local" | "local-wrapper" | "postgres" | "off" | "planned";
+export declare const GitHubNativeConnectorConfigSchema: z.ZodObject<{
+    mode: z.ZodDefault<z.ZodEnum<{
+        fake: "fake";
+        rest: "rest";
+        app: "app";
+    }>>;
+    tokenEnv: z.ZodDefault<z.ZodString>;
+    apiBaseUrl: z.ZodDefault<z.ZodString>;
+    userAgent: z.ZodDefault<z.ZodString>;
+    appId: z.ZodOptional<z.ZodString>;
+    appIdEnv: z.ZodDefault<z.ZodString>;
+    installationId: z.ZodOptional<z.ZodString>;
+    installationIdEnv: z.ZodDefault<z.ZodString>;
+    privateKeyEnv: z.ZodDefault<z.ZodString>;
+}, z.core.$strip>;
+export type GitHubNativeConnectorConfig = z.infer<typeof GitHubNativeConnectorConfigSchema>;
+export declare const DEFAULT_GITHUB_NATIVE_CONNECTOR_CONFIG: GitHubNativeConnectorConfig;
+export declare const LinearNativeConnectorConfigSchema: z.ZodObject<{
+    mode: z.ZodDefault<z.ZodEnum<{
+        fake: "fake";
+        graphql: "graphql";
+    }>>;
+    tokenEnv: z.ZodDefault<z.ZodString>;
+    apiUrl: z.ZodDefault<z.ZodString>;
+}, z.core.$strip>;
+export type LinearNativeConnectorConfig = z.infer<typeof LinearNativeConnectorConfigSchema>;
+export declare const DEFAULT_LINEAR_NATIVE_CONNECTOR_CONFIG: LinearNativeConnectorConfig;
+export declare const JiraNativeConnectorConfigSchema: z.ZodObject<{
+    mode: z.ZodDefault<z.ZodEnum<{
+        fake: "fake";
+        rest: "rest";
+    }>>;
+    auth: z.ZodDefault<z.ZodEnum<{
+        api_token: "api_token";
+        oauth: "oauth";
+    }>>;
+    tokenEnv: z.ZodDefault<z.ZodString>;
+    emailEnv: z.ZodDefault<z.ZodString>;
+    siteUrl: z.ZodDefault<z.ZodString>;
+    cloudId: z.ZodOptional<z.ZodString>;
+    cloudIdEnv: z.ZodDefault<z.ZodString>;
+}, z.core.$strip>;
+export type JiraNativeConnectorConfig = z.infer<typeof JiraNativeConnectorConfigSchema>;
+export declare const DEFAULT_JIRA_NATIVE_CONNECTOR_CONFIG: JiraNativeConnectorConfig;
+export declare const PostgresNativeConnectorConfigSchema: z.ZodObject<{
+    mode: z.ZodDefault<z.ZodEnum<{
+        postgres: "postgres";
+        off: "off";
+    }>>;
+    dsnEnv: z.ZodDefault<z.ZodString>;
+    allowedTables: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    allowedFunctions: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    requireRls: z.ZodDefault<z.ZodBoolean>;
+    maxRows: z.ZodDefault<z.ZodNumber>;
+    statementTimeoutMs: z.ZodDefault<z.ZodNumber>;
+    lockTimeoutMs: z.ZodDefault<z.ZodNumber>;
+    idleTransactionTimeoutMs: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export type PostgresNativeConnectorConfig = z.infer<typeof PostgresNativeConnectorConfigSchema>;
+export declare const DEFAULT_POSTGRES_NATIVE_CONNECTOR_CONFIG: PostgresNativeConnectorConfig;
+export declare const DriveNativeConnectorConfigSchema: z.ZodObject<{
+    mode: z.ZodDefault<z.ZodEnum<{
+        rest: "rest";
+        off: "off";
+    }>>;
+    tokenEnv: z.ZodDefault<z.ZodString>;
+    selectedFileId: z.ZodOptional<z.ZodString>;
+    apiBaseUrl: z.ZodDefault<z.ZodString>;
+    allowedMimeTypes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    maxReadBytes: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export type DriveNativeConnectorConfig = z.infer<typeof DriveNativeConnectorConfigSchema>;
+export declare const DEFAULT_DRIVE_NATIVE_CONNECTOR_CONFIG: DriveNativeConnectorConfig;
+export type NativeConnectorToolDescriptor = {
+    capability: ConnectorCapability;
+    normalizeEvidence: (action: NormalizedAction, payload: Record<string, JsonValue>) => LedgerProviderEvidence;
+};
+export type NativeConnectorGovernanceDescriptor<TConfig> = {
+    provider: ConnectorProvider;
+    connector: string;
+    mode: ConnectorProviderMode;
+    configSchema: z.ZodType<TConfig>;
+    defaultConfig: TConfig;
+    requiredScopes: readonly string[];
+    smokeCheck: string;
+    tools: readonly NativeConnectorToolDescriptor[];
+};
+export declare const LedgerExecutionOutcomeSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"axtary.ledger_execution_outcome.v0">;
+    status: z.ZodEnum<{
+        succeeded: "succeeded";
+        failed: "failed";
+    }>;
+    provider: z.ZodOptional<z.ZodEnum<{
+        github: "github";
+        slack: "slack";
+        linear: "linear";
+        docs: "docs";
+        drive: "drive";
+        mcp: "mcp";
+        aws: "aws";
+        gcp: "gcp";
+        jira: "jira";
+        postgres: "postgres";
+    }>>;
+    resultId: z.ZodOptional<z.ZodString>;
+    resultUrl: z.ZodOptional<z.ZodString>;
+    resourceId: z.ZodOptional<z.ZodString>;
+    resourceLabel: z.ZodOptional<z.ZodString>;
+    failureReason: z.ZodOptional<z.ZodString>;
+    errorClass: z.ZodOptional<z.ZodString>;
+    sideEffectProof: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>>;
+}, z.core.$strict>;
+export type LedgerExecutionOutcome = z.infer<typeof LedgerExecutionOutcomeSchema>;
+export declare const DelegationLedgerEdgeSchema: z.ZodObject<{
+    parentPassId: z.ZodString;
+    childPassId: z.ZodString;
+    depth: z.ZodNumber;
+    rootPassId: z.ZodString;
+}, z.core.$strip>;
+export type DelegationLedgerEdge = z.infer<typeof DelegationLedgerEdgeSchema>;
+export declare const BudgetLedgerEventSchema: z.ZodObject<{
+    reservationId: z.ZodNullable<z.ZodString>;
+    scope: z.ZodString;
+    status: z.ZodEnum<{
+        pending: "pending";
+        committed: "committed";
+        rolled_back: "rolled_back";
+        denied: "denied";
+    }>;
+    expiresAt: z.ZodNullable<z.ZodString>;
+    cost: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    limit: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    committedBefore: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    committedAfter: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    reservedAfter: z.ZodRecord<z.ZodString, z.ZodNumber>;
+}, z.core.$strip>;
+export type BudgetLedgerEvent = z.infer<typeof BudgetLedgerEventSchema>;
+export declare const LedgerAuditContextSchema: z.ZodObject<{
+    tenant: z.ZodNullable<z.ZodString>;
+    agentId: z.ZodString;
+    humanOwner: z.ZodString;
+    taskId: z.ZodString;
+    tool: z.ZodString;
+    resource: z.ZodString;
+}, z.core.$strip>;
+export type LedgerAuditContext = z.infer<typeof LedgerAuditContextSchema>;
+export declare const LedgerRecordSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"axtary.ledger.v0">;
+    id: z.ZodString;
+    occurredAt: z.ZodString;
+    auditContext: z.ZodOptional<z.ZodObject<{
+        tenant: z.ZodNullable<z.ZodString>;
+        agentId: z.ZodString;
+        humanOwner: z.ZodString;
+        taskId: z.ZodString;
+        tool: z.ZodString;
+        resource: z.ZodString;
+    }, z.core.$strip>>;
+    actionHash: z.ZodString;
+    payloadHash: z.ZodString;
+    provenanceHash: z.ZodOptional<z.ZodString>;
+    decision: z.ZodEnum<{
+        allow: "allow";
+        deny: "deny";
+        step_up: "step_up";
+    }>;
+    reasons: z.ZodArray<z.ZodString>;
+    policy: z.ZodObject<{
+        nativeRule: z.ZodString;
+        version: z.ZodString;
+        cedarCompatible: z.ZodBoolean;
+        opaCompatible: z.ZodBoolean;
+    }, z.core.$strip>;
+    providerEvidence: z.ZodOptional<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"axtary.ledger_provider_evidence.v0">;
+        provider: z.ZodEnum<{
+            github: "github";
+            slack: "slack";
+            linear: "linear";
+            docs: "docs";
+            drive: "drive";
+            mcp: "mcp";
+            aws: "aws";
+            gcp: "gcp";
+            jira: "jira";
+            postgres: "postgres";
+        }>;
+        tool: z.ZodString;
+        operation: z.ZodString;
+        resource: z.ZodObject<{
+            provider: z.ZodEnum<{
+                github: "github";
+                slack: "slack";
+                linear: "linear";
+                docs: "docs";
+                drive: "drive";
+                mcp: "mcp";
+                aws: "aws";
+                gcp: "gcp";
+                jira: "jira";
+                postgres: "postgres";
+            }>;
+            kind: z.ZodString;
+            id: z.ZodString;
+            label: z.ZodOptional<z.ZodString>;
+            url: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        normalized: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>>;
+        fieldChanges: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            field: z.ZodString;
+            before: z.ZodOptional<z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>;
+            after: z.ZodOptional<z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>;
+        }, z.core.$strip>>>;
+        diff: z.ZodOptional<z.ZodObject<{
+            provider: z.ZodEnum<{
+                github: "github";
+                slack: "slack";
+                linear: "linear";
+                docs: "docs";
+                drive: "drive";
+                mcp: "mcp";
+                aws: "aws";
+                gcp: "gcp";
+                jira: "jira";
+                postgres: "postgres";
+            }>;
+            summary: z.ZodOptional<z.ZodString>;
+            files: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                path: z.ZodString;
+                oldPath: z.ZodOptional<z.ZodString>;
+                status: z.ZodEnum<{
+                    added: "added";
+                    modified: "modified";
+                    deleted: "deleted";
+                    renamed: "renamed";
+                }>;
+                additions: z.ZodDefault<z.ZodNumber>;
+                deletions: z.ZodDefault<z.ZodNumber>;
+                hunks: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                    header: z.ZodString;
+                    lines: z.ZodArray<z.ZodObject<{
+                        type: z.ZodEnum<{
+                            context: "context";
+                            addition: "addition";
+                            deletion: "deletion";
+                        }>;
+                        content: z.ZodString;
+                        oldLine: z.ZodOptional<z.ZodNumber>;
+                        newLine: z.ZodOptional<z.ZodNumber>;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>>>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    executionOutcome: z.ZodOptional<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"axtary.ledger_execution_outcome.v0">;
+        status: z.ZodEnum<{
+            succeeded: "succeeded";
+            failed: "failed";
+        }>;
+        provider: z.ZodOptional<z.ZodEnum<{
+            github: "github";
+            slack: "slack";
+            linear: "linear";
+            docs: "docs";
+            drive: "drive";
+            mcp: "mcp";
+            aws: "aws";
+            gcp: "gcp";
+            jira: "jira";
+            postgres: "postgres";
+        }>>;
+        resultId: z.ZodOptional<z.ZodString>;
+        resultUrl: z.ZodOptional<z.ZodString>;
+        resourceId: z.ZodOptional<z.ZodString>;
+        resourceLabel: z.ZodOptional<z.ZodString>;
+        failureReason: z.ZodOptional<z.ZodString>;
+        errorClass: z.ZodOptional<z.ZodString>;
+        sideEffectProof: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>>;
+    }, z.core.$strict>>;
+    traceId: z.ZodOptional<z.ZodString>;
+    actionPassId: z.ZodNullable<z.ZodString>;
+    delegation: z.ZodOptional<z.ZodObject<{
+        parentPassId: z.ZodString;
+        childPassId: z.ZodString;
+        depth: z.ZodNumber;
+        rootPassId: z.ZodString;
+    }, z.core.$strip>>;
+    budget: z.ZodOptional<z.ZodObject<{
+        reservationId: z.ZodNullable<z.ZodString>;
+        scope: z.ZodString;
+        status: z.ZodEnum<{
+            pending: "pending";
+            committed: "committed";
+            rolled_back: "rolled_back";
+            denied: "denied";
+        }>;
+        expiresAt: z.ZodNullable<z.ZodString>;
+        cost: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        limit: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        committedBefore: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        committedAfter: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        reservedAfter: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    }, z.core.$strip>>;
+    correlationId: z.ZodOptional<z.ZodString>;
+    previousLedgerHash: z.ZodNullable<z.ZodString>;
+    ledgerHash: z.ZodString;
+}, z.core.$strip>;
+export type LedgerRecord = z.infer<typeof LedgerRecordSchema>;
+export type SigningKey = CryptoKey | KeyObject | JWK | Uint8Array;
+export type VerificationKey = CryptoKey | KeyObject | JWK | Uint8Array;
+export type VerificationKeySet = Readonly<Record<string, VerificationKey>>;
+export type VerificationKeyResolver = (keyId: string | undefined) => VerificationKey | undefined | Promise<VerificationKey | undefined>;
+export type SigningAlgorithm = "ES256" | "EdDSA";
+export type PolicyOptions = {
+    allowedTool?: string;
+    requiredBaseBranch?: string;
+    maxFilesChanged?: number;
+    blockedPathPrefixes?: string[];
+    policyVersion?: string;
+};
+export type IssueActionPassInput = {
+    action: unknown;
+    decision: PolicyDecision;
+    issuer: string;
+    tenant: string;
+    signingKey: SigningKey;
+    keyId?: string;
+    algorithm?: SigningAlgorithm;
+    now?: Date;
+    expiresInSeconds?: number;
+    approval?: Approval;
+    approvalArtifact?: ApprovalArtifact;
+    parentPassId?: string | null;
+    ledgerHash?: string | null;
+    traceId?: string;
+    passId?: string;
+};
+export type IssueActionPassV1Input = IssueActionPassInput & {
+    holderPublicJwk: JWK;
+    delegation?: {
+        depth: number;
+        rootPassId: string;
+    };
+};
+export type IssueActionPassV2Input = IssueActionPassV1Input & {
+    status: ActionPassStatusClaim;
+};
+export type IssueActionPassResult = {
+    token: string;
+    claims: ActionPassClaims;
+};
+export type IssueActionPassV1Result = {
+    token: string;
+    claims: ActionPassV1Claims;
+};
+export type IssueActionPassV2Result = {
+    token: string;
+    claims: ActionPassV2Claims;
+};
+export type AuthorizeInput = {
+    action: unknown;
+    issuer: string;
+    tenant: string;
+    signingKey: SigningKey;
+    keyId?: string;
+    algorithm?: SigningAlgorithm;
+    now?: Date;
+    policy?: PolicyOptions;
+    approval?: Approval;
+    approvalArtifact?: ApprovalArtifact;
+    previousLedgerHash?: string | null;
+    traceId?: string;
+};
+export type AuthorizeResult = {
+    action: NormalizedAction;
+    decision: PolicyDecision;
+    payloadHash: string;
+    actionPass: IssueActionPassResult | null;
+    ledger: LedgerRecord;
+};
+export type VerifyActionPassInput = {
+    token: string;
+    action: unknown;
+    verificationKey?: VerificationKey;
+    verificationKeys?: VerificationKeySet | VerificationKeyResolver;
+    issuer?: string;
+    audience?: string | string[];
+    algorithms?: SigningAlgorithm[];
+    clockTolerance?: string | number;
+    currentDate?: Date;
+    dpopProof?: string;
+    dpopMethod?: string;
+    dpopUri?: string;
+    dpopNonce?: string;
+    dpopAlgorithms?: SigningAlgorithm[];
+    dpopMaxAgeSeconds?: number;
+    dpopClockSkewSeconds?: number;
+    dpopReplayStore?: DpopReplayStore;
+    revokedPassIds?: Iterable<string>;
+    revocations?: Iterable<ActionPassRevocation>;
+    isRevoked?: (claims: ActionPassClaims) => boolean | string | Promise<boolean | string>;
+    getStatus?: (claims: ActionPassV2Claims) => number | string | Promise<number | string>;
+};
+export type ActionPassRevocationSource = Pick<VerifyActionPassInput, "revokedPassIds" | "revocations" | "isRevoked" | "getStatus">;
+export type CreateDpopProofInput = {
+    actionPass: string;
+    method: string;
+    uri: string;
+    signingKey: SigningKey;
+    publicJwk: JWK;
+    algorithm?: SigningAlgorithm;
+    now?: Date;
+    proofId?: string;
+    nonce?: string;
+};
+export type CreateDpopProofResult = {
+    proof: string;
+    claims: DpopProofClaims;
+    jkt: string;
+};
+export type DpopReplayStore = {
+    consume(proofId: string, expiresAt: Date, now?: Date): boolean | Promise<boolean>;
+};
+export type VerifyActionPassResult = {
+    valid: true;
+    claims: ActionPassClaims;
+    payloadHash: string;
+} | {
+    valid: false;
+    reason: string;
+};
+export type VerifyDelegationChainInput = {
+    /**
+     * Root-to-leaf chain. Every entry is signature/content verified; the leaf
+     * entry must additionally carry a fresh DPoP proof.
+     */
+    chain: VerifyActionPassInput[];
+    currentDate?: Date;
+    /**
+     * One authority-owned source applied to every root-to-leaf member. This is
+     * what makes revoking any ancestor invalidate all descendant presentations.
+     */
+    revocation?: ActionPassRevocationSource;
+};
+export type VerifyDelegationChainResult = {
+    valid: true;
+    claims: Array<ActionPassV1Claims | ActionPassV2Claims>;
+    actions: NormalizedAction[];
+} | {
+    valid: false;
+    reason: string;
+};
+export type DelegateActionPassV1Input = Omit<IssueActionPassV1Input, "action" | "decision" | "holderPublicJwk" | "parentPassId" | "delegation"> & {
+    parentChain: VerifyActionPassInput[];
+    childAction: unknown;
+    childDecision: PolicyDecision;
+    childHolderPublicJwk: JWK;
+    revocation?: ActionPassRevocationSource;
+};
+export type DelegateActionPassV1Result = IssueActionPassV1Result & {
+    delegation: DelegationLedgerEdge;
+};
+export type DelegateActionPassV2Input = Omit<IssueActionPassV2Input, "action" | "decision" | "holderPublicJwk" | "parentPassId" | "delegation" | "status"> & {
+    parentChain: VerifyActionPassInput[];
+    childAction: unknown;
+    childDecision: PolicyDecision;
+    childHolderPublicJwk: JWK;
+    childStatus: ActionPassStatusClaim;
+    revocation?: ActionPassRevocationSource;
+};
+export type DelegateActionPassV2Result = IssueActionPassV2Result & {
+    delegation: DelegationLedgerEdge;
+};
+export type CreateApprovalArtifactInput = {
+    action: unknown;
+    mode: "human" | "policy_override";
+    approvedBy: string;
+    approverRoles?: string[];
+    approvedAt?: Date;
+    reason?: string;
+    expiresAt?: Date;
+    id?: string;
+};
+export type CreateApprovalArtifactResult = {
+    artifact: ApprovalArtifact;
+    artifactHash: string;
+    approval: Approval;
+};
+export type RevokeActionPassInput = {
+    passId: string;
+    revokedAt?: Date;
+    revokedBy?: string;
+    reason?: string;
+};
+export type ActionPassTrustStore = {
+    getVerificationKey: (keyId: string | undefined) => VerificationKey | undefined | Promise<VerificationKey | undefined>;
+    isPassRevoked: (passId: string) => boolean | string | Promise<boolean | string>;
+};
+export type VerifyActionPassWithTrustStoreInput = Omit<VerifyActionPassInput, "verificationKey" | "verificationKeys" | "revokedPassIds" | "revocations" | "isRevoked"> & {
+    trustStore: ActionPassTrustStore | string;
+};
+export declare const demoAction: NormalizedAction;
+export declare function parseNormalizedAction(action: unknown): NormalizedAction;
+export declare function evaluateAction(actionInput: unknown, options?: PolicyOptions): PolicyDecision;
+export declare function authorize(input: AuthorizeInput): Promise<AuthorizeResult>;
+export declare function createApprovalArtifact(input: CreateApprovalArtifactInput): CreateApprovalArtifactResult;
+export declare function issueActionPass(input: IssueActionPassInput): Promise<IssueActionPassResult>;
+export declare function issueActionPassV1(input: IssueActionPassV1Input): Promise<IssueActionPassV1Result>;
+export declare function issueActionPassV2(input: IssueActionPassV2Input): Promise<IssueActionPassV2Result>;
+export declare function delegateActionPassV1(input: DelegateActionPassV1Input): Promise<DelegateActionPassV1Result>;
+export declare function delegateActionPassV2(input: DelegateActionPassV2Input): Promise<DelegateActionPassV2Result>;
+export declare function createDpopProof(input: CreateDpopProofInput): Promise<CreateDpopProofResult>;
+export declare class InMemoryDpopReplayStore implements DpopReplayStore {
+    private readonly entries;
+    consume(proofId: string, expiresAt: Date, currentDate?: Date): boolean;
+}
+export type FileDpopReplayStoreOptions = {
+    lock?: {
+        staleMs?: number;
+        updateMs?: number;
+        retries?: number;
+        minTimeoutMs?: number;
+        maxTimeoutMs?: number;
+    };
+};
+/**
+ * Durable, inter-process replay store for DPoP proof `jti`s. A proof captured
+ * before a restart stays rejected after restart, for as long as it remains
+ * inside its own time window. Entries live only until their proof expires, so
+ * the on-disk set stays bounded to the in-flight window rather than growing
+ * unboundedly.
+ *
+ * This is a single-file local store, not a cross-host distributed one: it
+ * defends one machine's verifiers (shared across handlers/processes on that
+ * host). Authenticated cross-host distribution is out of scope here.
+ *
+ * Durability mirrors the local ledger: a `proper-lockfile` lease serializes the
+ * read-modify-write so `consume` is atomic across processes, appended lines are
+ * `fsync`ed before the lease releases, and the file is compacted in place once
+ * expired lines outnumber live ones so it cannot grow without bound.
+ */
+export declare class FileDpopReplayStore implements DpopReplayStore {
+    readonly filePath: string;
+    private readonly options;
+    constructor(filePath: string, options?: FileDpopReplayStoreOptions);
+    consume(proofId: string, expiresAt: Date, currentDate?: Date): Promise<boolean>;
+    private acquireLock;
+    private readLiveEntries;
+    private append;
+    private compact;
+}
+export declare function verifyActionPass(input: VerifyActionPassInput): Promise<VerifyActionPassResult>;
+export declare function verifyDelegationChain(input: VerifyDelegationChainInput): Promise<VerifyDelegationChainResult>;
+export declare function revokeActionPass(input: RevokeActionPassInput): ActionPassRevocation;
+export declare class LocalActionPassTrustStore implements ActionPassTrustStore {
+    readonly filePath: string;
+    constructor(filePath: string);
+    read(): Promise<ActionPassTrustStoreData>;
+    write(dataInput: Partial<ActionPassTrustStoreData>): Promise<ActionPassTrustStoreData>;
+    putVerificationKey(keyInput: ActionPassVerificationKeyRecordInput): Promise<ActionPassVerificationKeyRecord>;
+    revokeActionPass(input: RevokeActionPassInput | ActionPassRevocation): Promise<ActionPassRevocation>;
+    getVerificationKey(keyId: string | undefined, now?: Date): Promise<VerificationKey | undefined>;
+    isPassRevoked(passId: string): Promise<boolean>;
+}
+export declare function verifyActionPassWithTrustStore(input: VerifyActionPassWithTrustStoreInput): Promise<VerifyActionPassResult>;
+export declare function recordDecision(input: {
+    action: unknown;
+    decision: PolicyDecision;
+    actionPassId?: string | null;
+    delegation?: DelegationLedgerEdge;
+    budget?: BudgetLedgerEvent;
+    previousLedgerHash?: string | null;
+    occurredAt?: Date;
+    traceId?: string;
+    providerEvidence?: LedgerProviderEvidence;
+    executionOutcome?: LedgerExecutionOutcome;
+    correlationId?: string | null;
+}): LedgerRecord;
+/**
+ * Canonical reason token marking a ledger record as the tamper-evident
+ * revocation event for its pass. Matches the forensics `cascade_containment`
+ * convention (spec §9.5) and the trust-store revocation authority (spec §7).
+ */
+export declare const REVOCATION_LEDGER_REASON = "actionpass_revoked";
+/**
+ * Build a tamper-evident revocation event for a previously recorded pass. The
+ * event is a `deny` record naming the pass with `actionpass_revoked`, reusing
+ * the revoked record's action/payload hashes, policy, and audit context so the
+ * revocation is bound to the exact action it cancels. It carries no delegation
+ * edge or budget event (those describe the original action, not the
+ * revocation). The durable enforcement authority remains the trust store (§7);
+ * this record is the auditable logbook entry, not the enforcement source.
+ */
+export declare function recordActionPassRevocationEvent(input: {
+    revokedRecord: LedgerRecord;
+    revokedBy?: string;
+    reason?: string;
+    occurredAt?: Date;
+    previousLedgerHash?: string | null;
+}): LedgerRecord;
+export declare function hashPayload(payload: unknown): string;
+export declare function hashProvenance(provenance: ActionProvenance): string;
+export declare function hashAction(action: unknown): string;
+export declare const GITHUB_NATIVE_CONNECTOR_GOVERNANCE: NativeConnectorGovernanceDescriptor<GitHubNativeConnectorConfig>;
+export declare const LINEAR_NATIVE_CONNECTOR_GOVERNANCE: NativeConnectorGovernanceDescriptor<LinearNativeConnectorConfig>;
+export declare const JIRA_NATIVE_CONNECTOR_GOVERNANCE: NativeConnectorGovernanceDescriptor<JiraNativeConnectorConfig>;
+export declare const POSTGRES_NATIVE_CONNECTOR_GOVERNANCE: NativeConnectorGovernanceDescriptor<PostgresNativeConnectorConfig>;
+export declare const DRIVE_NATIVE_CONNECTOR_GOVERNANCE: NativeConnectorGovernanceDescriptor<DriveNativeConnectorConfig>;
+export declare const NATIVE_CONNECTOR_GOVERNANCE_REGISTRY: readonly [NativeConnectorGovernanceDescriptor<{
+    mode: "fake" | "rest" | "app";
+    tokenEnv: string;
+    apiBaseUrl: string;
+    userAgent: string;
+    appIdEnv: string;
+    installationIdEnv: string;
+    privateKeyEnv: string;
+    appId?: string | undefined;
+    installationId?: string | undefined;
+}>, NativeConnectorGovernanceDescriptor<{
+    mode: "fake" | "graphql";
+    tokenEnv: string;
+    apiUrl: string;
+}>, NativeConnectorGovernanceDescriptor<{
+    mode: "fake" | "rest";
+    auth: "api_token" | "oauth";
+    tokenEnv: string;
+    emailEnv: string;
+    siteUrl: string;
+    cloudIdEnv: string;
+    cloudId?: string | undefined;
+}>, NativeConnectorGovernanceDescriptor<{
+    mode: "postgres" | "off";
+    dsnEnv: string;
+    allowedTables: string[];
+    allowedFunctions: string[];
+    requireRls: boolean;
+    maxRows: number;
+    statementTimeoutMs: number;
+    lockTimeoutMs: number;
+    idleTransactionTimeoutMs: number;
+}>, NativeConnectorGovernanceDescriptor<{
+    mode: "rest" | "off";
+    tokenEnv: string;
+    apiBaseUrl: string;
+    allowedMimeTypes: string[];
+    maxReadBytes: number;
+    selectedFileId?: string | undefined;
+}>];
+export declare function providerEvidenceForAction(actionInput: unknown): LedgerProviderEvidence | undefined;
+export declare function hashJson(value: unknown): string;
+export declare function stableStringify(value: unknown): string;
+export declare function computeDpopAccessTokenHash(token: string): string;
+export declare function normalizeDpopMethod(method: string): string;
+export declare function normalizeDpopUri(uri: string): string;
+export declare function actionPassDpopTarget(actionInput: unknown): {
+    method: "POST";
+    uri: string;
+};
+export declare function validateApprovalArtifact(artifactInput: unknown, actionInput: unknown, now?: Date): string | null;
+export declare const AXTARY_DEFAULT_ISSUER = "axtary-dev";
+export declare const AXTARY_DEFAULT_TENANT = "local";
+export declare const AXTARY_DEFAULT_RUNTIME = "sdk";
+/** Flat authorization request — the shape from PRD §8.2. */
+export type AxtaryAuthorizeRequest = {
+    agent: string;
+    human: string;
+    intent: string;
+    tool: string;
+    resource: string;
+    payload?: Record<string, JsonValue>;
+    /** Agent runtime label; defaults to the instance runtime ("sdk"). */
+    runtime?: string;
+    /** Stable task id for ledger correlation; generated when omitted. */
+    task?: string;
+    /** Tenant; defaults to the instance tenant. */
+    tenant?: string;
+    constraints?: Record<string, JsonValue>;
+    budget?: ActionBudget;
+    toolDefinition?: NormalizedAction["toolDefinition"];
+    provenance?: ActionProvenance;
+    maxDelegationDepth?: number;
+};
+export type AxtaryPass = IssueActionPassResult;
+export type AxtaryAuthorizeResult = {
+    /** Alias of `decision.decision` so `result.status === "allow"` reads cleanly. */
+    status: AxtaryDecision;
+    decision: PolicyDecision;
+    reasons: string[];
+    explanation: PolicyDecisionExplanation;
+    payloadHash: string;
+    action: NormalizedAction;
+    pass: AxtaryPass | null;
+    ledger: LedgerRecord;
+};
+export type AxtaryAuthorizeOptions = {
+    policy?: PolicyOptions;
+    approval?: Approval;
+    approvalArtifact?: ApprovalArtifact;
+    now?: Date;
+};
+export type AxtaryExecutionOutcome = Omit<LedgerExecutionOutcome, "schemaVersion" | "sideEffectProof"> & {
+    sideEffectProof?: Record<string, JsonValue>;
+};
+export type AxtaryRecordInput = {
+    action: AxtaryAuthorizeRequest | NormalizedAction;
+    decision: PolicyDecision;
+    pass?: AxtaryPass | string | null;
+    outcome?: AxtaryExecutionOutcome;
+    correlationId?: string | null;
+    previousLedgerHash?: string | null;
+};
+export type AxtaryRevokeOptions = {
+    revokedBy?: string;
+    reason?: string;
+    revokedAt?: Date;
+};
+export type AxtaryConfig = {
+    issuer?: string;
+    tenant?: string;
+    runtime?: string;
+    /** Issuer signing key. Omit to use a persistent local dev key (see devKeypair). */
+    signingKey?: SigningKey;
+    signingKeyId?: string;
+    /** Public verification key matching `signingKey`; required for `verify`. */
+    verificationKey?: VerificationKey;
+    algorithm?: SigningAlgorithm;
+    /** Default policy options applied to every authorize call. */
+    policy?: PolicyOptions;
+    /** Override the dev keyring file path used when no signing key is configured. */
+    keyPath?: string;
+    /** Suppress the one-time dev-key warning. */
+    quiet?: boolean;
+};
+export declare class Axtary {
+    readonly issuer: string;
+    readonly tenant: string;
+    readonly runtime: string;
+    private readonly defaultPolicy?;
+    private readonly algorithm;
+    private readonly quiet;
+    private readonly configuredSigningKey?;
+    private readonly configuredKeyId?;
+    private readonly configuredVerificationKey?;
+    private readonly keyPath?;
+    private signerPromise?;
+    private ledgerHead;
+    private readonly revocations;
+    constructor(config?: AxtaryConfig);
+    /** Current local ledger head (hash of the last record this instance wrote). */
+    get ledgerHash(): string | null;
+    private resolveSigner;
+    private toNormalizedAction;
+    /**
+     * Decide an action and, for an allow, issue an ActionPass. Always returns a
+     * decision (the policy evaluation is keyless); a deny/step-up returns
+     * `pass: null`. Threads the local ledger head so successive calls chain.
+     */
+    authorize(request: AxtaryAuthorizeRequest | NormalizedAction, options?: AxtaryAuthorizeOptions): Promise<AxtaryAuthorizeResult>;
+    /**
+     * Verify a previously issued pass against an action. Accepts an authorize
+     * result, a pass object, or a raw token; the action defaults to the result's
+     * action when one is supplied. Fails closed for a pass this instance revoked.
+     */
+    verify(pass: AxtaryAuthorizeResult | AxtaryPass | string, action?: AxtaryAuthorizeRequest | NormalizedAction): Promise<VerifyActionPassResult>;
+    /**
+     * Append an execution result to the local ledger, chained after the decision
+     * record from `authorize`. Returns the tamper-evident record; durable
+     * persistence is the proxy/CLI's responsibility.
+     */
+    record(input: AxtaryRecordInput): LedgerRecord;
+    /**
+     * Revoke a pass by id. The revocation is held in this instance so a later
+     * `verify` of that pass fails closed. Durable cross-process revocation is the
+     * CLI/trust-store path (`axtary revoke`).
+     */
+    revoke(passId: string, options?: AxtaryRevokeOptions): ActionPassRevocation;
+    /** Deterministic, human-readable explanation of a decision (no model call). */
+    explain(decision: PolicyDecision | AxtaryAuthorizeResult): PolicyDecisionExplanation;
+}
+/** Create an Axtary SDK instance. */
+export declare function createAxtary(config?: AxtaryConfig): Axtary;
+/** Default Axtary SDK instance (PRD §8.2 `import { axtary }`). */
+export declare const axtary: Axtary;
+//# sourceMappingURL=index.d.ts.map