@kya-os/contracts 1.2.1 → 1.2.2

package/dist/delegation/schemas.d.ts

@@ -0,0 +1,3787 @@
+/**
+ * Delegation Record Schemas
+ *
+ * Types and schemas for delegation records that link VCs with CRISP constraints.
+ * Delegations represent the transfer of authority from one DID to another.
+ *
+ * Related Spec: MCP-I §4.1, §4.2
+ * Python Reference: Delegation-Documentation.md, Delegation-Service.md
+ */
+import { z } from 'zod';
+/**
+ * Delegation Status
+ *
+ * Lifecycle status of a delegation
+ */
+export declare const DelegationStatusSchema: z.ZodEnum<["active", "revoked", "expired"]>;
+export type DelegationStatus = z.infer<typeof DelegationStatusSchema>;
+/**
+ * Delegation Record Schema
+ *
+ * Complete delegation record linking issuer (delegator) to subject (delegatee)
+ * with backing VC and CRISP constraints.
+ *
+ * **Key Invariants:**
+ * - Delegation MUST reference a live VC via `vcId`
+ * - Revocation of VC invalidates all linked delegations
+ * - Chain: no cycles allowed
+ * - Child `notAfter` ≤ parent `notAfter`
+ * - Child scopes ⊆ parent scopes
+ * - Child budgets ≤ parent budgets (same unit)
+ */
+export declare const DelegationRecordSchema: z.ZodObject<{
+    /** Unique identifier for the delegation */
+    id: z.ZodString;
+    /** DID of the delegator (issuer, e.g., merchant/user) */
+    issuerDid: z.ZodString;
+    /** DID of the delegatee (subject, e.g., agent) */
+    subjectDid: z.ZodString;
+    /** Optional controller (user account ID or DID) */
+    controller: z.ZodOptional<z.ZodString>;
+    /** ID of the backing Verifiable Credential */
+    vcId: z.ZodString;
+    /** Optional parent delegation ID for chain tracking */
+    parentId: z.ZodOptional<z.ZodString>;
+    /** CRISP constraints on this delegation */
+    constraints: z.ZodObject<{
+        notBefore: z.ZodOptional<z.ZodNumber>;
+        notAfter: z.ZodOptional<z.ZodNumber>;
+        crisp: z.ZodObject<{
+            budget: z.ZodOptional<z.ZodObject<{
+                unit: z.ZodEnum<["USD", "ops", "points"]>;
+                cap: z.ZodNumber;
+                window: z.ZodOptional<z.ZodObject<{
+                    kind: z.ZodEnum<["rolling", "fixed"]>;
+                    durationSec: z.ZodNumber;
+                }, "strip", z.ZodTypeAny, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }>>;
+            }, "strip", z.ZodTypeAny, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }>>;
+            scopes: z.ZodArray<z.ZodObject<{
+                resource: z.ZodString;
+                matcher: z.ZodEnum<["exact", "prefix", "regex"]>;
+                constraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+            }, "strip", z.ZodTypeAny, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }>, "many">;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            budget: z.ZodOptional<z.ZodObject<{
+                unit: z.ZodEnum<["USD", "ops", "points"]>;
+                cap: z.ZodNumber;
+                window: z.ZodOptional<z.ZodObject<{
+                    kind: z.ZodEnum<["rolling", "fixed"]>;
+                    durationSec: z.ZodNumber;
+                }, "strip", z.ZodTypeAny, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }>>;
+            }, "strip", z.ZodTypeAny, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }>>;
+            scopes: z.ZodArray<z.ZodObject<{
+                resource: z.ZodString;
+                matcher: z.ZodEnum<["exact", "prefix", "regex"]>;
+                constraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+            }, "strip", z.ZodTypeAny, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }>, "many">;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            budget: z.ZodOptional<z.ZodObject<{
+                unit: z.ZodEnum<["USD", "ops", "points"]>;
+                cap: z.ZodNumber;
+                window: z.ZodOptional<z.ZodObject<{
+                    kind: z.ZodEnum<["rolling", "fixed"]>;
+                    durationSec: z.ZodNumber;
+                }, "strip", z.ZodTypeAny, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }>>;
+            }, "strip", z.ZodTypeAny, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }>>;
+            scopes: z.ZodArray<z.ZodObject<{
+                resource: z.ZodString;
+                matcher: z.ZodEnum<["exact", "prefix", "regex"]>;
+                constraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+            }, "strip", z.ZodTypeAny, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }>, "many">;
+        }, z.ZodTypeAny, "passthrough">>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        notBefore: z.ZodOptional<z.ZodNumber>;
+        notAfter: z.ZodOptional<z.ZodNumber>;
+        crisp: z.ZodObject<{
+            budget: z.ZodOptional<z.ZodObject<{
+                unit: z.ZodEnum<["USD", "ops", "points"]>;
+                cap: z.ZodNumber;
+                window: z.ZodOptional<z.ZodObject<{
+                    kind: z.ZodEnum<["rolling", "fixed"]>;
+                    durationSec: z.ZodNumber;
+                }, "strip", z.ZodTypeAny, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }>>;
+            }, "strip", z.ZodTypeAny, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }>>;
+            scopes: z.ZodArray<z.ZodObject<{
+                resource: z.ZodString;
+                matcher: z.ZodEnum<["exact", "prefix", "regex"]>;
+                constraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+            }, "strip", z.ZodTypeAny, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }>, "many">;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            budget: z.ZodOptional<z.ZodObject<{
+                unit: z.ZodEnum<["USD", "ops", "points"]>;
+                cap: z.ZodNumber;
+                window: z.ZodOptional<z.ZodObject<{
+                    kind: z.ZodEnum<["rolling", "fixed"]>;
+                    durationSec: z.ZodNumber;
+                }, "strip", z.ZodTypeAny, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }>>;
+            }, "strip", z.ZodTypeAny, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }>>;
+            scopes: z.ZodArray<z.ZodObject<{
+                resource: z.ZodString;
+                matcher: z.ZodEnum<["exact", "prefix", "regex"]>;
+                constraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+            }, "strip", z.ZodTypeAny, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }>, "many">;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            budget: z.ZodOptional<z.ZodObject<{
+                unit: z.ZodEnum<["USD", "ops", "points"]>;
+                cap: z.ZodNumber;
+                window: z.ZodOptional<z.ZodObject<{
+                    kind: z.ZodEnum<["rolling", "fixed"]>;
+                    durationSec: z.ZodNumber;
+                }, "strip", z.ZodTypeAny, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }>>;
+            }, "strip", z.ZodTypeAny, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }>>;
+            scopes: z.ZodArray<z.ZodObject<{
+                resource: z.ZodString;
+                matcher: z.ZodEnum<["exact", "prefix", "regex"]>;
+                constraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+            }, "strip", z.ZodTypeAny, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }>, "many">;
+        }, z.ZodTypeAny, "passthrough">>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        notBefore: z.ZodOptional<z.ZodNumber>;
+        notAfter: z.ZodOptional<z.ZodNumber>;
+        crisp: z.ZodObject<{
+            budget: z.ZodOptional<z.ZodObject<{
+                unit: z.ZodEnum<["USD", "ops", "points"]>;
+                cap: z.ZodNumber;
+                window: z.ZodOptional<z.ZodObject<{
+                    kind: z.ZodEnum<["rolling", "fixed"]>;
+                    durationSec: z.ZodNumber;
+                }, "strip", z.ZodTypeAny, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }>>;
+            }, "strip", z.ZodTypeAny, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }>>;
+            scopes: z.ZodArray<z.ZodObject<{
+                resource: z.ZodString;
+                matcher: z.ZodEnum<["exact", "prefix", "regex"]>;
+                constraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+            }, "strip", z.ZodTypeAny, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }>, "many">;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            budget: z.ZodOptional<z.ZodObject<{
+                unit: z.ZodEnum<["USD", "ops", "points"]>;
+                cap: z.ZodNumber;
+                window: z.ZodOptional<z.ZodObject<{
+                    kind: z.ZodEnum<["rolling", "fixed"]>;
+                    durationSec: z.ZodNumber;
+                }, "strip", z.ZodTypeAny, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }>>;
+            }, "strip", z.ZodTypeAny, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }>>;
+            scopes: z.ZodArray<z.ZodObject<{
+                resource: z.ZodString;
+                matcher: z.ZodEnum<["exact", "prefix", "regex"]>;
+                constraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+            }, "strip", z.ZodTypeAny, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }>, "many">;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            budget: z.ZodOptional<z.ZodObject<{
+                unit: z.ZodEnum<["USD", "ops", "points"]>;
+                cap: z.ZodNumber;
+                window: z.ZodOptional<z.ZodObject<{
+                    kind: z.ZodEnum<["rolling", "fixed"]>;
+                    durationSec: z.ZodNumber;
+                }, "strip", z.ZodTypeAny, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }>>;
+            }, "strip", z.ZodTypeAny, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }>>;
+            scopes: z.ZodArray<z.ZodObject<{
+                resource: z.ZodString;
+                matcher: z.ZodEnum<["exact", "prefix", "regex"]>;
+                constraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+            }, "strip", z.ZodTypeAny, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }>, "many">;
+        }, z.ZodTypeAny, "passthrough">>;
+    }, z.ZodTypeAny, "passthrough">>;
+    /** Detached JWS signature over canonical delegation document */
+    signature: z.ZodString;
+    /** Current status of the delegation */
+    status: z.ZodEnum<["active", "revoked", "expired"]>;
+    /** Timestamp when created (milliseconds since epoch) */
+    createdAt: z.ZodOptional<z.ZodNumber>;
+    /** Timestamp when revoked (if status is revoked) */
+    revokedAt: z.ZodOptional<z.ZodNumber>;
+    /** Optional reason for revocation */
+    revokedReason: z.ZodOptional<z.ZodString>;
+    /** Optional metadata */
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    /** Unique identifier for the delegation */
+    id: z.ZodString;
+    /** DID of the delegator (issuer, e.g., merchant/user) */
+    issuerDid: z.ZodString;
+    /** DID of the delegatee (subject, e.g., agent) */
+    subjectDid: z.ZodString;
+    /** Optional controller (user account ID or DID) */
+    controller: z.ZodOptional<z.ZodString>;
+    /** ID of the backing Verifiable Credential */
+    vcId: z.ZodString;
+    /** Optional parent delegation ID for chain tracking */
+    parentId: z.ZodOptional<z.ZodString>;
+    /** CRISP constraints on this delegation */
+    constraints: z.ZodObject<{
+        notBefore: z.ZodOptional<z.ZodNumber>;
+        notAfter: z.ZodOptional<z.ZodNumber>;
+        crisp: z.ZodObject<{
+            budget: z.ZodOptional<z.ZodObject<{
+                unit: z.ZodEnum<["USD", "ops", "points"]>;
+                cap: z.ZodNumber;
+                window: z.ZodOptional<z.ZodObject<{
+                    kind: z.ZodEnum<["rolling", "fixed"]>;
+                    durationSec: z.ZodNumber;
+                }, "strip", z.ZodTypeAny, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }>>;
+            }, "strip", z.ZodTypeAny, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }>>;
+            scopes: z.ZodArray<z.ZodObject<{
+                resource: z.ZodString;
+                matcher: z.ZodEnum<["exact", "prefix", "regex"]>;
+                constraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+            }, "strip", z.ZodTypeAny, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }>, "many">;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            budget: z.ZodOptional<z.ZodObject<{
+                unit: z.ZodEnum<["USD", "ops", "points"]>;
+                cap: z.ZodNumber;
+                window: z.ZodOptional<z.ZodObject<{
+                    kind: z.ZodEnum<["rolling", "fixed"]>;
+                    durationSec: z.ZodNumber;
+                }, "strip", z.ZodTypeAny, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }>>;
+            }, "strip", z.ZodTypeAny, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }>>;
+            scopes: z.ZodArray<z.ZodObject<{
+                resource: z.ZodString;
+                matcher: z.ZodEnum<["exact", "prefix", "regex"]>;
+                constraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+            }, "strip", z.ZodTypeAny, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }>, "many">;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            budget: z.ZodOptional<z.ZodObject<{
+                unit: z.ZodEnum<["USD", "ops", "points"]>;
+                cap: z.ZodNumber;
+                window: z.ZodOptional<z.ZodObject<{
+                    kind: z.ZodEnum<["rolling", "fixed"]>;
+                    durationSec: z.ZodNumber;
+                }, "strip", z.ZodTypeAny, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }>>;
+            }, "strip", z.ZodTypeAny, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }>>;
+            scopes: z.ZodArray<z.ZodObject<{
+                resource: z.ZodString;
+                matcher: z.ZodEnum<["exact", "prefix", "regex"]>;
+                constraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+            }, "strip", z.ZodTypeAny, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }>, "many">;
+        }, z.ZodTypeAny, "passthrough">>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        notBefore: z.ZodOptional<z.ZodNumber>;
+        notAfter: z.ZodOptional<z.ZodNumber>;
+        crisp: z.ZodObject<{
+            budget: z.ZodOptional<z.ZodObject<{
+                unit: z.ZodEnum<["USD", "ops", "points"]>;
+                cap: z.ZodNumber;
+                window: z.ZodOptional<z.ZodObject<{
+                    kind: z.ZodEnum<["rolling", "fixed"]>;
+                    durationSec: z.ZodNumber;
+                }, "strip", z.ZodTypeAny, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }>>;
+            }, "strip", z.ZodTypeAny, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }>>;
+            scopes: z.ZodArray<z.ZodObject<{
+                resource: z.ZodString;
+                matcher: z.ZodEnum<["exact", "prefix", "regex"]>;
+                constraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+            }, "strip", z.ZodTypeAny, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }>, "many">;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            budget: z.ZodOptional<z.ZodObject<{
+                unit: z.ZodEnum<["USD", "ops", "points"]>;
+                cap: z.ZodNumber;
+                window: z.ZodOptional<z.ZodObject<{
+                    kind: z.ZodEnum<["rolling", "fixed"]>;
+                    durationSec: z.ZodNumber;
+                }, "strip", z.ZodTypeAny, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }>>;
+            }, "strip", z.ZodTypeAny, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }>>;
+            scopes: z.ZodArray<z.ZodObject<{
+                resource: z.ZodString;
+                matcher: z.ZodEnum<["exact", "prefix", "regex"]>;
+                constraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+            }, "strip", z.ZodTypeAny, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }>, "many">;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            budget: z.ZodOptional<z.ZodObject<{
+                unit: z.ZodEnum<["USD", "ops", "points"]>;
+                cap: z.ZodNumber;
+                window: z.ZodOptional<z.ZodObject<{
+                    kind: z.ZodEnum<["rolling", "fixed"]>;
+                    durationSec: z.ZodNumber;
+                }, "strip", z.ZodTypeAny, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }>>;
+            }, "strip", z.ZodTypeAny, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }>>;
+            scopes: z.ZodArray<z.ZodObject<{
+                resource: z.ZodString;
+                matcher: z.ZodEnum<["exact", "prefix", "regex"]>;
+                constraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+            }, "strip", z.ZodTypeAny, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }>, "many">;
+        }, z.ZodTypeAny, "passthrough">>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        notBefore: z.ZodOptional<z.ZodNumber>;
+        notAfter: z.ZodOptional<z.ZodNumber>;
+        crisp: z.ZodObject<{
+            budget: z.ZodOptional<z.ZodObject<{
+                unit: z.ZodEnum<["USD", "ops", "points"]>;
+                cap: z.ZodNumber;
+                window: z.ZodOptional<z.ZodObject<{
+                    kind: z.ZodEnum<["rolling", "fixed"]>;
+                    durationSec: z.ZodNumber;
+                }, "strip", z.ZodTypeAny, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }>>;
+            }, "strip", z.ZodTypeAny, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }>>;
+            scopes: z.ZodArray<z.ZodObject<{
+                resource: z.ZodString;
+                matcher: z.ZodEnum<["exact", "prefix", "regex"]>;
+                constraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+            }, "strip", z.ZodTypeAny, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }>, "many">;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            budget: z.ZodOptional<z.ZodObject<{
+                unit: z.ZodEnum<["USD", "ops", "points"]>;
+                cap: z.ZodNumber;
+                window: z.ZodOptional<z.ZodObject<{
+                    kind: z.ZodEnum<["rolling", "fixed"]>;
+                    durationSec: z.ZodNumber;
+                }, "strip", z.ZodTypeAny, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }>>;
+            }, "strip", z.ZodTypeAny, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }>>;
+            scopes: z.ZodArray<z.ZodObject<{
+                resource: z.ZodString;
+                matcher: z.ZodEnum<["exact", "prefix", "regex"]>;
+                constraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+            }, "strip", z.ZodTypeAny, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }>, "many">;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            budget: z.ZodOptional<z.ZodObject<{
+                unit: z.ZodEnum<["USD", "ops", "points"]>;
+                cap: z.ZodNumber;
+                window: z.ZodOptional<z.ZodObject<{
+                    kind: z.ZodEnum<["rolling", "fixed"]>;
+                    durationSec: z.ZodNumber;
+                }, "strip", z.ZodTypeAny, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }>>;
+            }, "strip", z.ZodTypeAny, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }>>;
+            scopes: z.ZodArray<z.ZodObject<{
+                resource: z.ZodString;
+                matcher: z.ZodEnum<["exact", "prefix", "regex"]>;
+                constraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+            }, "strip", z.ZodTypeAny, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }>, "many">;
+        }, z.ZodTypeAny, "passthrough">>;
+    }, z.ZodTypeAny, "passthrough">>;
+    /** Detached JWS signature over canonical delegation document */
+    signature: z.ZodString;
+    /** Current status of the delegation */
+    status: z.ZodEnum<["active", "revoked", "expired"]>;
+    /** Timestamp when created (milliseconds since epoch) */
+    createdAt: z.ZodOptional<z.ZodNumber>;
+    /** Timestamp when revoked (if status is revoked) */
+    revokedAt: z.ZodOptional<z.ZodNumber>;
+    /** Optional reason for revocation */
+    revokedReason: z.ZodOptional<z.ZodString>;
+    /** Optional metadata */
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    /** Unique identifier for the delegation */
+    id: z.ZodString;
+    /** DID of the delegator (issuer, e.g., merchant/user) */
+    issuerDid: z.ZodString;
+    /** DID of the delegatee (subject, e.g., agent) */
+    subjectDid: z.ZodString;
+    /** Optional controller (user account ID or DID) */
+    controller: z.ZodOptional<z.ZodString>;
+    /** ID of the backing Verifiable Credential */
+    vcId: z.ZodString;
+    /** Optional parent delegation ID for chain tracking */
+    parentId: z.ZodOptional<z.ZodString>;
+    /** CRISP constraints on this delegation */
+    constraints: z.ZodObject<{
+        notBefore: z.ZodOptional<z.ZodNumber>;
+        notAfter: z.ZodOptional<z.ZodNumber>;
+        crisp: z.ZodObject<{
+            budget: z.ZodOptional<z.ZodObject<{
+                unit: z.ZodEnum<["USD", "ops", "points"]>;
+                cap: z.ZodNumber;
+                window: z.ZodOptional<z.ZodObject<{
+                    kind: z.ZodEnum<["rolling", "fixed"]>;
+                    durationSec: z.ZodNumber;
+                }, "strip", z.ZodTypeAny, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }>>;
+            }, "strip", z.ZodTypeAny, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }>>;
+            scopes: z.ZodArray<z.ZodObject<{
+                resource: z.ZodString;
+                matcher: z.ZodEnum<["exact", "prefix", "regex"]>;
+                constraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+            }, "strip", z.ZodTypeAny, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }>, "many">;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            budget: z.ZodOptional<z.ZodObject<{
+                unit: z.ZodEnum<["USD", "ops", "points"]>;
+                cap: z.ZodNumber;
+                window: z.ZodOptional<z.ZodObject<{
+                    kind: z.ZodEnum<["rolling", "fixed"]>;
+                    durationSec: z.ZodNumber;
+                }, "strip", z.ZodTypeAny, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }>>;
+            }, "strip", z.ZodTypeAny, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }>>;
+            scopes: z.ZodArray<z.ZodObject<{
+                resource: z.ZodString;
+                matcher: z.ZodEnum<["exact", "prefix", "regex"]>;
+                constraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+            }, "strip", z.ZodTypeAny, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }>, "many">;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            budget: z.ZodOptional<z.ZodObject<{
+                unit: z.ZodEnum<["USD", "ops", "points"]>;
+                cap: z.ZodNumber;
+                window: z.ZodOptional<z.ZodObject<{
+                    kind: z.ZodEnum<["rolling", "fixed"]>;
+                    durationSec: z.ZodNumber;
+                }, "strip", z.ZodTypeAny, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }>>;
+            }, "strip", z.ZodTypeAny, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }>>;
+            scopes: z.ZodArray<z.ZodObject<{
+                resource: z.ZodString;
+                matcher: z.ZodEnum<["exact", "prefix", "regex"]>;
+                constraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+            }, "strip", z.ZodTypeAny, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }>, "many">;
+        }, z.ZodTypeAny, "passthrough">>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        notBefore: z.ZodOptional<z.ZodNumber>;
+        notAfter: z.ZodOptional<z.ZodNumber>;
+        crisp: z.ZodObject<{
+            budget: z.ZodOptional<z.ZodObject<{
+                unit: z.ZodEnum<["USD", "ops", "points"]>;
+                cap: z.ZodNumber;
+                window: z.ZodOptional<z.ZodObject<{
+                    kind: z.ZodEnum<["rolling", "fixed"]>;
+                    durationSec: z.ZodNumber;
+                }, "strip", z.ZodTypeAny, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }>>;
+            }, "strip", z.ZodTypeAny, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }>>;
+            scopes: z.ZodArray<z.ZodObject<{
+                resource: z.ZodString;
+                matcher: z.ZodEnum<["exact", "prefix", "regex"]>;
+                constraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+            }, "strip", z.ZodTypeAny, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }>, "many">;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            budget: z.ZodOptional<z.ZodObject<{
+                unit: z.ZodEnum<["USD", "ops", "points"]>;
+                cap: z.ZodNumber;
+                window: z.ZodOptional<z.ZodObject<{
+                    kind: z.ZodEnum<["rolling", "fixed"]>;
+                    durationSec: z.ZodNumber;
+                }, "strip", z.ZodTypeAny, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }>>;
+            }, "strip", z.ZodTypeAny, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }>>;
+            scopes: z.ZodArray<z.ZodObject<{
+                resource: z.ZodString;
+                matcher: z.ZodEnum<["exact", "prefix", "regex"]>;
+                constraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+            }, "strip", z.ZodTypeAny, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }>, "many">;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            budget: z.ZodOptional<z.ZodObject<{
+                unit: z.ZodEnum<["USD", "ops", "points"]>;
+                cap: z.ZodNumber;
+                window: z.ZodOptional<z.ZodObject<{
+                    kind: z.ZodEnum<["rolling", "fixed"]>;
+                    durationSec: z.ZodNumber;
+                }, "strip", z.ZodTypeAny, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }>>;
+            }, "strip", z.ZodTypeAny, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }>>;
+            scopes: z.ZodArray<z.ZodObject<{
+                resource: z.ZodString;
+                matcher: z.ZodEnum<["exact", "prefix", "regex"]>;
+                constraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+            }, "strip", z.ZodTypeAny, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }>, "many">;
+        }, z.ZodTypeAny, "passthrough">>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        notBefore: z.ZodOptional<z.ZodNumber>;
+        notAfter: z.ZodOptional<z.ZodNumber>;
+        crisp: z.ZodObject<{
+            budget: z.ZodOptional<z.ZodObject<{
+                unit: z.ZodEnum<["USD", "ops", "points"]>;
+                cap: z.ZodNumber;
+                window: z.ZodOptional<z.ZodObject<{
+                    kind: z.ZodEnum<["rolling", "fixed"]>;
+                    durationSec: z.ZodNumber;
+                }, "strip", z.ZodTypeAny, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }>>;
+            }, "strip", z.ZodTypeAny, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }>>;
+            scopes: z.ZodArray<z.ZodObject<{
+                resource: z.ZodString;
+                matcher: z.ZodEnum<["exact", "prefix", "regex"]>;
+                constraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+            }, "strip", z.ZodTypeAny, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }>, "many">;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            budget: z.ZodOptional<z.ZodObject<{
+                unit: z.ZodEnum<["USD", "ops", "points"]>;
+                cap: z.ZodNumber;
+                window: z.ZodOptional<z.ZodObject<{
+                    kind: z.ZodEnum<["rolling", "fixed"]>;
+                    durationSec: z.ZodNumber;
+                }, "strip", z.ZodTypeAny, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }>>;
+            }, "strip", z.ZodTypeAny, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }>>;
+            scopes: z.ZodArray<z.ZodObject<{
+                resource: z.ZodString;
+                matcher: z.ZodEnum<["exact", "prefix", "regex"]>;
+                constraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+            }, "strip", z.ZodTypeAny, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }>, "many">;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            budget: z.ZodOptional<z.ZodObject<{
+                unit: z.ZodEnum<["USD", "ops", "points"]>;
+                cap: z.ZodNumber;
+                window: z.ZodOptional<z.ZodObject<{
+                    kind: z.ZodEnum<["rolling", "fixed"]>;
+                    durationSec: z.ZodNumber;
+                }, "strip", z.ZodTypeAny, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }>>;
+            }, "strip", z.ZodTypeAny, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }>>;
+            scopes: z.ZodArray<z.ZodObject<{
+                resource: z.ZodString;
+                matcher: z.ZodEnum<["exact", "prefix", "regex"]>;
+                constraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+            }, "strip", z.ZodTypeAny, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }>, "many">;
+        }, z.ZodTypeAny, "passthrough">>;
+    }, z.ZodTypeAny, "passthrough">>;
+    /** Detached JWS signature over canonical delegation document */
+    signature: z.ZodString;
+    /** Current status of the delegation */
+    status: z.ZodEnum<["active", "revoked", "expired"]>;
+    /** Timestamp when created (milliseconds since epoch) */
+    createdAt: z.ZodOptional<z.ZodNumber>;
+    /** Timestamp when revoked (if status is revoked) */
+    revokedAt: z.ZodOptional<z.ZodNumber>;
+    /** Optional reason for revocation */
+    revokedReason: z.ZodOptional<z.ZodString>;
+    /** Optional metadata */
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+}, z.ZodTypeAny, "passthrough">>;
+export type DelegationRecord = z.infer<typeof DelegationRecordSchema>;
+/**
+ * Delegation Chain Entry
+ *
+ * Represents a single link in a delegation chain
+ */
+export declare const DelegationChainEntrySchema: z.ZodObject<{
+    /** Delegation ID */
+    delegationId: z.ZodString;
+    /** Issuer DID */
+    issuerDid: z.ZodString;
+    /** Subject DID */
+    subjectDid: z.ZodString;
+    /** VC ID */
+    vcId: z.ZodString;
+    /** Depth in chain (0 = root) */
+    depth: z.ZodNumber;
+    /** Constraints */
+    constraints: z.ZodObject<{
+        notBefore: z.ZodOptional<z.ZodNumber>;
+        notAfter: z.ZodOptional<z.ZodNumber>;
+        crisp: z.ZodObject<{
+            budget: z.ZodOptional<z.ZodObject<{
+                unit: z.ZodEnum<["USD", "ops", "points"]>;
+                cap: z.ZodNumber;
+                window: z.ZodOptional<z.ZodObject<{
+                    kind: z.ZodEnum<["rolling", "fixed"]>;
+                    durationSec: z.ZodNumber;
+                }, "strip", z.ZodTypeAny, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }>>;
+            }, "strip", z.ZodTypeAny, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }>>;
+            scopes: z.ZodArray<z.ZodObject<{
+                resource: z.ZodString;
+                matcher: z.ZodEnum<["exact", "prefix", "regex"]>;
+                constraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+            }, "strip", z.ZodTypeAny, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }>, "many">;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            budget: z.ZodOptional<z.ZodObject<{
+                unit: z.ZodEnum<["USD", "ops", "points"]>;
+                cap: z.ZodNumber;
+                window: z.ZodOptional<z.ZodObject<{
+                    kind: z.ZodEnum<["rolling", "fixed"]>;
+                    durationSec: z.ZodNumber;
+                }, "strip", z.ZodTypeAny, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }>>;
+            }, "strip", z.ZodTypeAny, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }>>;
+            scopes: z.ZodArray<z.ZodObject<{
+                resource: z.ZodString;
+                matcher: z.ZodEnum<["exact", "prefix", "regex"]>;
+                constraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+            }, "strip", z.ZodTypeAny, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }>, "many">;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            budget: z.ZodOptional<z.ZodObject<{
+                unit: z.ZodEnum<["USD", "ops", "points"]>;
+                cap: z.ZodNumber;
+                window: z.ZodOptional<z.ZodObject<{
+                    kind: z.ZodEnum<["rolling", "fixed"]>;
+                    durationSec: z.ZodNumber;
+                }, "strip", z.ZodTypeAny, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }>>;
+            }, "strip", z.ZodTypeAny, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }>>;
+            scopes: z.ZodArray<z.ZodObject<{
+                resource: z.ZodString;
+                matcher: z.ZodEnum<["exact", "prefix", "regex"]>;
+                constraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+            }, "strip", z.ZodTypeAny, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }>, "many">;
+        }, z.ZodTypeAny, "passthrough">>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        notBefore: z.ZodOptional<z.ZodNumber>;
+        notAfter: z.ZodOptional<z.ZodNumber>;
+        crisp: z.ZodObject<{
+            budget: z.ZodOptional<z.ZodObject<{
+                unit: z.ZodEnum<["USD", "ops", "points"]>;
+                cap: z.ZodNumber;
+                window: z.ZodOptional<z.ZodObject<{
+                    kind: z.ZodEnum<["rolling", "fixed"]>;
+                    durationSec: z.ZodNumber;
+                }, "strip", z.ZodTypeAny, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }>>;
+            }, "strip", z.ZodTypeAny, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }>>;
+            scopes: z.ZodArray<z.ZodObject<{
+                resource: z.ZodString;
+                matcher: z.ZodEnum<["exact", "prefix", "regex"]>;
+                constraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+            }, "strip", z.ZodTypeAny, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }>, "many">;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            budget: z.ZodOptional<z.ZodObject<{
+                unit: z.ZodEnum<["USD", "ops", "points"]>;
+                cap: z.ZodNumber;
+                window: z.ZodOptional<z.ZodObject<{
+                    kind: z.ZodEnum<["rolling", "fixed"]>;
+                    durationSec: z.ZodNumber;
+                }, "strip", z.ZodTypeAny, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }>>;
+            }, "strip", z.ZodTypeAny, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }>>;
+            scopes: z.ZodArray<z.ZodObject<{
+                resource: z.ZodString;
+                matcher: z.ZodEnum<["exact", "prefix", "regex"]>;
+                constraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+            }, "strip", z.ZodTypeAny, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }>, "many">;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            budget: z.ZodOptional<z.ZodObject<{
+                unit: z.ZodEnum<["USD", "ops", "points"]>;
+                cap: z.ZodNumber;
+                window: z.ZodOptional<z.ZodObject<{
+                    kind: z.ZodEnum<["rolling", "fixed"]>;
+                    durationSec: z.ZodNumber;
+                }, "strip", z.ZodTypeAny, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }>>;
+            }, "strip", z.ZodTypeAny, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }>>;
+            scopes: z.ZodArray<z.ZodObject<{
+                resource: z.ZodString;
+                matcher: z.ZodEnum<["exact", "prefix", "regex"]>;
+                constraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+            }, "strip", z.ZodTypeAny, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }>, "many">;
+        }, z.ZodTypeAny, "passthrough">>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        notBefore: z.ZodOptional<z.ZodNumber>;
+        notAfter: z.ZodOptional<z.ZodNumber>;
+        crisp: z.ZodObject<{
+            budget: z.ZodOptional<z.ZodObject<{
+                unit: z.ZodEnum<["USD", "ops", "points"]>;
+                cap: z.ZodNumber;
+                window: z.ZodOptional<z.ZodObject<{
+                    kind: z.ZodEnum<["rolling", "fixed"]>;
+                    durationSec: z.ZodNumber;
+                }, "strip", z.ZodTypeAny, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }>>;
+            }, "strip", z.ZodTypeAny, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }>>;
+            scopes: z.ZodArray<z.ZodObject<{
+                resource: z.ZodString;
+                matcher: z.ZodEnum<["exact", "prefix", "regex"]>;
+                constraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+            }, "strip", z.ZodTypeAny, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }>, "many">;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            budget: z.ZodOptional<z.ZodObject<{
+                unit: z.ZodEnum<["USD", "ops", "points"]>;
+                cap: z.ZodNumber;
+                window: z.ZodOptional<z.ZodObject<{
+                    kind: z.ZodEnum<["rolling", "fixed"]>;
+                    durationSec: z.ZodNumber;
+                }, "strip", z.ZodTypeAny, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }>>;
+            }, "strip", z.ZodTypeAny, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }>>;
+            scopes: z.ZodArray<z.ZodObject<{
+                resource: z.ZodString;
+                matcher: z.ZodEnum<["exact", "prefix", "regex"]>;
+                constraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+            }, "strip", z.ZodTypeAny, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }>, "many">;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            budget: z.ZodOptional<z.ZodObject<{
+                unit: z.ZodEnum<["USD", "ops", "points"]>;
+                cap: z.ZodNumber;
+                window: z.ZodOptional<z.ZodObject<{
+                    kind: z.ZodEnum<["rolling", "fixed"]>;
+                    durationSec: z.ZodNumber;
+                }, "strip", z.ZodTypeAny, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }>>;
+            }, "strip", z.ZodTypeAny, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }>>;
+            scopes: z.ZodArray<z.ZodObject<{
+                resource: z.ZodString;
+                matcher: z.ZodEnum<["exact", "prefix", "regex"]>;
+                constraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+            }, "strip", z.ZodTypeAny, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }>, "many">;
+        }, z.ZodTypeAny, "passthrough">>;
+    }, z.ZodTypeAny, "passthrough">>;
+    /** Status */
+    status: z.ZodEnum<["active", "revoked", "expired"]>;
+}, "strip", z.ZodTypeAny, {
+    issuerDid: string;
+    subjectDid: string;
+    vcId: string;
+    status: "active" | "revoked" | "expired";
+    constraints: {
+        crisp: {
+            scopes: {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }[];
+            budget?: {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            } | undefined;
+        } & {
+            [k: string]: unknown;
+        };
+        notBefore?: number | undefined;
+        notAfter?: number | undefined;
+    } & {
+        [k: string]: unknown;
+    };
+    delegationId: string;
+    depth: number;
+}, {
+    issuerDid: string;
+    subjectDid: string;
+    vcId: string;
+    status: "active" | "revoked" | "expired";
+    constraints: {
+        crisp: {
+            scopes: {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }[];
+            budget?: {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            } | undefined;
+        } & {
+            [k: string]: unknown;
+        };
+        notBefore?: number | undefined;
+        notAfter?: number | undefined;
+    } & {
+        [k: string]: unknown;
+    };
+    delegationId: string;
+    depth: number;
+}>;
+export type DelegationChainEntry = z.infer<typeof DelegationChainEntrySchema>;
+/**
+ * Delegation Chain
+ *
+ * Represents a complete delegation chain from root to leaf
+ */
+export declare const DelegationChainSchema: z.ZodObject<{
+    /** Root issuer DID */
+    rootIssuer: z.ZodString;
+    /** Leaf subject DID */
+    leafSubject: z.ZodString;
+    /** All delegations in the chain, ordered root to leaf */
+    chain: z.ZodArray<z.ZodObject<{
+        /** Delegation ID */
+        delegationId: z.ZodString;
+        /** Issuer DID */
+        issuerDid: z.ZodString;
+        /** Subject DID */
+        subjectDid: z.ZodString;
+        /** VC ID */
+        vcId: z.ZodString;
+        /** Depth in chain (0 = root) */
+        depth: z.ZodNumber;
+        /** Constraints */
+        constraints: z.ZodObject<{
+            notBefore: z.ZodOptional<z.ZodNumber>;
+            notAfter: z.ZodOptional<z.ZodNumber>;
+            crisp: z.ZodObject<{
+                budget: z.ZodOptional<z.ZodObject<{
+                    unit: z.ZodEnum<["USD", "ops", "points"]>;
+                    cap: z.ZodNumber;
+                    window: z.ZodOptional<z.ZodObject<{
+                        kind: z.ZodEnum<["rolling", "fixed"]>;
+                        durationSec: z.ZodNumber;
+                    }, "strip", z.ZodTypeAny, {
+                        kind: "rolling" | "fixed";
+                        durationSec: number;
+                    }, {
+                        kind: "rolling" | "fixed";
+                        durationSec: number;
+                    }>>;
+                }, "strip", z.ZodTypeAny, {
+                    unit: "USD" | "ops" | "points";
+                    cap: number;
+                    window?: {
+                        kind: "rolling" | "fixed";
+                        durationSec: number;
+                    } | undefined;
+                }, {
+                    unit: "USD" | "ops" | "points";
+                    cap: number;
+                    window?: {
+                        kind: "rolling" | "fixed";
+                        durationSec: number;
+                    } | undefined;
+                }>>;
+                scopes: z.ZodArray<z.ZodObject<{
+                    resource: z.ZodString;
+                    matcher: z.ZodEnum<["exact", "prefix", "regex"]>;
+                    constraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+                }, "strip", z.ZodTypeAny, {
+                    resource: string;
+                    matcher: "exact" | "prefix" | "regex";
+                    constraints?: Record<string, any> | undefined;
+                }, {
+                    resource: string;
+                    matcher: "exact" | "prefix" | "regex";
+                    constraints?: Record<string, any> | undefined;
+                }>, "many">;
+            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+                budget: z.ZodOptional<z.ZodObject<{
+                    unit: z.ZodEnum<["USD", "ops", "points"]>;
+                    cap: z.ZodNumber;
+                    window: z.ZodOptional<z.ZodObject<{
+                        kind: z.ZodEnum<["rolling", "fixed"]>;
+                        durationSec: z.ZodNumber;
+                    }, "strip", z.ZodTypeAny, {
+                        kind: "rolling" | "fixed";
+                        durationSec: number;
+                    }, {
+                        kind: "rolling" | "fixed";
+                        durationSec: number;
+                    }>>;
+                }, "strip", z.ZodTypeAny, {
+                    unit: "USD" | "ops" | "points";
+                    cap: number;
+                    window?: {
+                        kind: "rolling" | "fixed";
+                        durationSec: number;
+                    } | undefined;
+                }, {
+                    unit: "USD" | "ops" | "points";
+                    cap: number;
+                    window?: {
+                        kind: "rolling" | "fixed";
+                        durationSec: number;
+                    } | undefined;
+                }>>;
+                scopes: z.ZodArray<z.ZodObject<{
+                    resource: z.ZodString;
+                    matcher: z.ZodEnum<["exact", "prefix", "regex"]>;
+                    constraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+                }, "strip", z.ZodTypeAny, {
+                    resource: string;
+                    matcher: "exact" | "prefix" | "regex";
+                    constraints?: Record<string, any> | undefined;
+                }, {
+                    resource: string;
+                    matcher: "exact" | "prefix" | "regex";
+                    constraints?: Record<string, any> | undefined;
+                }>, "many">;
+            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+                budget: z.ZodOptional<z.ZodObject<{
+                    unit: z.ZodEnum<["USD", "ops", "points"]>;
+                    cap: z.ZodNumber;
+                    window: z.ZodOptional<z.ZodObject<{
+                        kind: z.ZodEnum<["rolling", "fixed"]>;
+                        durationSec: z.ZodNumber;
+                    }, "strip", z.ZodTypeAny, {
+                        kind: "rolling" | "fixed";
+                        durationSec: number;
+                    }, {
+                        kind: "rolling" | "fixed";
+                        durationSec: number;
+                    }>>;
+                }, "strip", z.ZodTypeAny, {
+                    unit: "USD" | "ops" | "points";
+                    cap: number;
+                    window?: {
+                        kind: "rolling" | "fixed";
+                        durationSec: number;
+                    } | undefined;
+                }, {
+                    unit: "USD" | "ops" | "points";
+                    cap: number;
+                    window?: {
+                        kind: "rolling" | "fixed";
+                        durationSec: number;
+                    } | undefined;
+                }>>;
+                scopes: z.ZodArray<z.ZodObject<{
+                    resource: z.ZodString;
+                    matcher: z.ZodEnum<["exact", "prefix", "regex"]>;
+                    constraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+                }, "strip", z.ZodTypeAny, {
+                    resource: string;
+                    matcher: "exact" | "prefix" | "regex";
+                    constraints?: Record<string, any> | undefined;
+                }, {
+                    resource: string;
+                    matcher: "exact" | "prefix" | "regex";
+                    constraints?: Record<string, any> | undefined;
+                }>, "many">;
+            }, z.ZodTypeAny, "passthrough">>;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            notBefore: z.ZodOptional<z.ZodNumber>;
+            notAfter: z.ZodOptional<z.ZodNumber>;
+            crisp: z.ZodObject<{
+                budget: z.ZodOptional<z.ZodObject<{
+                    unit: z.ZodEnum<["USD", "ops", "points"]>;
+                    cap: z.ZodNumber;
+                    window: z.ZodOptional<z.ZodObject<{
+                        kind: z.ZodEnum<["rolling", "fixed"]>;
+                        durationSec: z.ZodNumber;
+                    }, "strip", z.ZodTypeAny, {
+                        kind: "rolling" | "fixed";
+                        durationSec: number;
+                    }, {
+                        kind: "rolling" | "fixed";
+                        durationSec: number;
+                    }>>;
+                }, "strip", z.ZodTypeAny, {
+                    unit: "USD" | "ops" | "points";
+                    cap: number;
+                    window?: {
+                        kind: "rolling" | "fixed";
+                        durationSec: number;
+                    } | undefined;
+                }, {
+                    unit: "USD" | "ops" | "points";
+                    cap: number;
+                    window?: {
+                        kind: "rolling" | "fixed";
+                        durationSec: number;
+                    } | undefined;
+                }>>;
+                scopes: z.ZodArray<z.ZodObject<{
+                    resource: z.ZodString;
+                    matcher: z.ZodEnum<["exact", "prefix", "regex"]>;
+                    constraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+                }, "strip", z.ZodTypeAny, {
+                    resource: string;
+                    matcher: "exact" | "prefix" | "regex";
+                    constraints?: Record<string, any> | undefined;
+                }, {
+                    resource: string;
+                    matcher: "exact" | "prefix" | "regex";
+                    constraints?: Record<string, any> | undefined;
+                }>, "many">;
+            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+                budget: z.ZodOptional<z.ZodObject<{
+                    unit: z.ZodEnum<["USD", "ops", "points"]>;
+                    cap: z.ZodNumber;
+                    window: z.ZodOptional<z.ZodObject<{
+                        kind: z.ZodEnum<["rolling", "fixed"]>;
+                        durationSec: z.ZodNumber;
+                    }, "strip", z.ZodTypeAny, {
+                        kind: "rolling" | "fixed";
+                        durationSec: number;
+                    }, {
+                        kind: "rolling" | "fixed";
+                        durationSec: number;
+                    }>>;
+                }, "strip", z.ZodTypeAny, {
+                    unit: "USD" | "ops" | "points";
+                    cap: number;
+                    window?: {
+                        kind: "rolling" | "fixed";
+                        durationSec: number;
+                    } | undefined;
+                }, {
+                    unit: "USD" | "ops" | "points";
+                    cap: number;
+                    window?: {
+                        kind: "rolling" | "fixed";
+                        durationSec: number;
+                    } | undefined;
+                }>>;
+                scopes: z.ZodArray<z.ZodObject<{
+                    resource: z.ZodString;
+                    matcher: z.ZodEnum<["exact", "prefix", "regex"]>;
+                    constraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+                }, "strip", z.ZodTypeAny, {
+                    resource: string;
+                    matcher: "exact" | "prefix" | "regex";
+                    constraints?: Record<string, any> | undefined;
+                }, {
+                    resource: string;
+                    matcher: "exact" | "prefix" | "regex";
+                    constraints?: Record<string, any> | undefined;
+                }>, "many">;
+            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+                budget: z.ZodOptional<z.ZodObject<{
+                    unit: z.ZodEnum<["USD", "ops", "points"]>;
+                    cap: z.ZodNumber;
+                    window: z.ZodOptional<z.ZodObject<{
+                        kind: z.ZodEnum<["rolling", "fixed"]>;
+                        durationSec: z.ZodNumber;
+                    }, "strip", z.ZodTypeAny, {
+                        kind: "rolling" | "fixed";
+                        durationSec: number;
+                    }, {
+                        kind: "rolling" | "fixed";
+                        durationSec: number;
+                    }>>;
+                }, "strip", z.ZodTypeAny, {
+                    unit: "USD" | "ops" | "points";
+                    cap: number;
+                    window?: {
+                        kind: "rolling" | "fixed";
+                        durationSec: number;
+                    } | undefined;
+                }, {
+                    unit: "USD" | "ops" | "points";
+                    cap: number;
+                    window?: {
+                        kind: "rolling" | "fixed";
+                        durationSec: number;
+                    } | undefined;
+                }>>;
+                scopes: z.ZodArray<z.ZodObject<{
+                    resource: z.ZodString;
+                    matcher: z.ZodEnum<["exact", "prefix", "regex"]>;
+                    constraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+                }, "strip", z.ZodTypeAny, {
+                    resource: string;
+                    matcher: "exact" | "prefix" | "regex";
+                    constraints?: Record<string, any> | undefined;
+                }, {
+                    resource: string;
+                    matcher: "exact" | "prefix" | "regex";
+                    constraints?: Record<string, any> | undefined;
+                }>, "many">;
+            }, z.ZodTypeAny, "passthrough">>;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            notBefore: z.ZodOptional<z.ZodNumber>;
+            notAfter: z.ZodOptional<z.ZodNumber>;
+            crisp: z.ZodObject<{
+                budget: z.ZodOptional<z.ZodObject<{
+                    unit: z.ZodEnum<["USD", "ops", "points"]>;
+                    cap: z.ZodNumber;
+                    window: z.ZodOptional<z.ZodObject<{
+                        kind: z.ZodEnum<["rolling", "fixed"]>;
+                        durationSec: z.ZodNumber;
+                    }, "strip", z.ZodTypeAny, {
+                        kind: "rolling" | "fixed";
+                        durationSec: number;
+                    }, {
+                        kind: "rolling" | "fixed";
+                        durationSec: number;
+                    }>>;
+                }, "strip", z.ZodTypeAny, {
+                    unit: "USD" | "ops" | "points";
+                    cap: number;
+                    window?: {
+                        kind: "rolling" | "fixed";
+                        durationSec: number;
+                    } | undefined;
+                }, {
+                    unit: "USD" | "ops" | "points";
+                    cap: number;
+                    window?: {
+                        kind: "rolling" | "fixed";
+                        durationSec: number;
+                    } | undefined;
+                }>>;
+                scopes: z.ZodArray<z.ZodObject<{
+                    resource: z.ZodString;
+                    matcher: z.ZodEnum<["exact", "prefix", "regex"]>;
+                    constraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+                }, "strip", z.ZodTypeAny, {
+                    resource: string;
+                    matcher: "exact" | "prefix" | "regex";
+                    constraints?: Record<string, any> | undefined;
+                }, {
+                    resource: string;
+                    matcher: "exact" | "prefix" | "regex";
+                    constraints?: Record<string, any> | undefined;
+                }>, "many">;
+            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+                budget: z.ZodOptional<z.ZodObject<{
+                    unit: z.ZodEnum<["USD", "ops", "points"]>;
+                    cap: z.ZodNumber;
+                    window: z.ZodOptional<z.ZodObject<{
+                        kind: z.ZodEnum<["rolling", "fixed"]>;
+                        durationSec: z.ZodNumber;
+                    }, "strip", z.ZodTypeAny, {
+                        kind: "rolling" | "fixed";
+                        durationSec: number;
+                    }, {
+                        kind: "rolling" | "fixed";
+                        durationSec: number;
+                    }>>;
+                }, "strip", z.ZodTypeAny, {
+                    unit: "USD" | "ops" | "points";
+                    cap: number;
+                    window?: {
+                        kind: "rolling" | "fixed";
+                        durationSec: number;
+                    } | undefined;
+                }, {
+                    unit: "USD" | "ops" | "points";
+                    cap: number;
+                    window?: {
+                        kind: "rolling" | "fixed";
+                        durationSec: number;
+                    } | undefined;
+                }>>;
+                scopes: z.ZodArray<z.ZodObject<{
+                    resource: z.ZodString;
+                    matcher: z.ZodEnum<["exact", "prefix", "regex"]>;
+                    constraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+                }, "strip", z.ZodTypeAny, {
+                    resource: string;
+                    matcher: "exact" | "prefix" | "regex";
+                    constraints?: Record<string, any> | undefined;
+                }, {
+                    resource: string;
+                    matcher: "exact" | "prefix" | "regex";
+                    constraints?: Record<string, any> | undefined;
+                }>, "many">;
+            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+                budget: z.ZodOptional<z.ZodObject<{
+                    unit: z.ZodEnum<["USD", "ops", "points"]>;
+                    cap: z.ZodNumber;
+                    window: z.ZodOptional<z.ZodObject<{
+                        kind: z.ZodEnum<["rolling", "fixed"]>;
+                        durationSec: z.ZodNumber;
+                    }, "strip", z.ZodTypeAny, {
+                        kind: "rolling" | "fixed";
+                        durationSec: number;
+                    }, {
+                        kind: "rolling" | "fixed";
+                        durationSec: number;
+                    }>>;
+                }, "strip", z.ZodTypeAny, {
+                    unit: "USD" | "ops" | "points";
+                    cap: number;
+                    window?: {
+                        kind: "rolling" | "fixed";
+                        durationSec: number;
+                    } | undefined;
+                }, {
+                    unit: "USD" | "ops" | "points";
+                    cap: number;
+                    window?: {
+                        kind: "rolling" | "fixed";
+                        durationSec: number;
+                    } | undefined;
+                }>>;
+                scopes: z.ZodArray<z.ZodObject<{
+                    resource: z.ZodString;
+                    matcher: z.ZodEnum<["exact", "prefix", "regex"]>;
+                    constraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+                }, "strip", z.ZodTypeAny, {
+                    resource: string;
+                    matcher: "exact" | "prefix" | "regex";
+                    constraints?: Record<string, any> | undefined;
+                }, {
+                    resource: string;
+                    matcher: "exact" | "prefix" | "regex";
+                    constraints?: Record<string, any> | undefined;
+                }>, "many">;
+            }, z.ZodTypeAny, "passthrough">>;
+        }, z.ZodTypeAny, "passthrough">>;
+        /** Status */
+        status: z.ZodEnum<["active", "revoked", "expired"]>;
+    }, "strip", z.ZodTypeAny, {
+        issuerDid: string;
+        subjectDid: string;
+        vcId: string;
+        status: "active" | "revoked" | "expired";
+        constraints: {
+            crisp: {
+                scopes: {
+                    resource: string;
+                    matcher: "exact" | "prefix" | "regex";
+                    constraints?: Record<string, any> | undefined;
+                }[];
+                budget?: {
+                    unit: "USD" | "ops" | "points";
+                    cap: number;
+                    window?: {
+                        kind: "rolling" | "fixed";
+                        durationSec: number;
+                    } | undefined;
+                } | undefined;
+            } & {
+                [k: string]: unknown;
+            };
+            notBefore?: number | undefined;
+            notAfter?: number | undefined;
+        } & {
+            [k: string]: unknown;
+        };
+        delegationId: string;
+        depth: number;
+    }, {
+        issuerDid: string;
+        subjectDid: string;
+        vcId: string;
+        status: "active" | "revoked" | "expired";
+        constraints: {
+            crisp: {
+                scopes: {
+                    resource: string;
+                    matcher: "exact" | "prefix" | "regex";
+                    constraints?: Record<string, any> | undefined;
+                }[];
+                budget?: {
+                    unit: "USD" | "ops" | "points";
+                    cap: number;
+                    window?: {
+                        kind: "rolling" | "fixed";
+                        durationSec: number;
+                    } | undefined;
+                } | undefined;
+            } & {
+                [k: string]: unknown;
+            };
+            notBefore?: number | undefined;
+            notAfter?: number | undefined;
+        } & {
+            [k: string]: unknown;
+        };
+        delegationId: string;
+        depth: number;
+    }>, "many">;
+    /** Total chain depth */
+    depth: z.ZodNumber;
+    /** Whether the entire chain is valid */
+    valid: z.ZodBoolean;
+    /** Optional validation errors */
+    errors: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    valid: boolean;
+    depth: number;
+    rootIssuer: string;
+    leafSubject: string;
+    chain: {
+        issuerDid: string;
+        subjectDid: string;
+        vcId: string;
+        status: "active" | "revoked" | "expired";
+        constraints: {
+            crisp: {
+                scopes: {
+                    resource: string;
+                    matcher: "exact" | "prefix" | "regex";
+                    constraints?: Record<string, any> | undefined;
+                }[];
+                budget?: {
+                    unit: "USD" | "ops" | "points";
+                    cap: number;
+                    window?: {
+                        kind: "rolling" | "fixed";
+                        durationSec: number;
+                    } | undefined;
+                } | undefined;
+            } & {
+                [k: string]: unknown;
+            };
+            notBefore?: number | undefined;
+            notAfter?: number | undefined;
+        } & {
+            [k: string]: unknown;
+        };
+        delegationId: string;
+        depth: number;
+    }[];
+    errors?: string[] | undefined;
+}, {
+    valid: boolean;
+    depth: number;
+    rootIssuer: string;
+    leafSubject: string;
+    chain: {
+        issuerDid: string;
+        subjectDid: string;
+        vcId: string;
+        status: "active" | "revoked" | "expired";
+        constraints: {
+            crisp: {
+                scopes: {
+                    resource: string;
+                    matcher: "exact" | "prefix" | "regex";
+                    constraints?: Record<string, any> | undefined;
+                }[];
+                budget?: {
+                    unit: "USD" | "ops" | "points";
+                    cap: number;
+                    window?: {
+                        kind: "rolling" | "fixed";
+                        durationSec: number;
+                    } | undefined;
+                } | undefined;
+            } & {
+                [k: string]: unknown;
+            };
+            notBefore?: number | undefined;
+            notAfter?: number | undefined;
+        } & {
+            [k: string]: unknown;
+        };
+        delegationId: string;
+        depth: number;
+    }[];
+    errors?: string[] | undefined;
+}>;
+export type DelegationChain = z.infer<typeof DelegationChainSchema>;
+/**
+ * Delegation Creation Request
+ *
+ * Input for creating a new delegation
+ */
+export declare const DelegationCreationRequestSchema: z.ZodObject<{
+    /** Delegator DID */
+    issuerDid: z.ZodString;
+    /** Delegatee DID */
+    subjectDid: z.ZodString;
+    /** Optional controller */
+    controller: z.ZodOptional<z.ZodString>;
+    /** Constraints */
+    constraints: z.ZodObject<{
+        notBefore: z.ZodOptional<z.ZodNumber>;
+        notAfter: z.ZodOptional<z.ZodNumber>;
+        crisp: z.ZodObject<{
+            budget: z.ZodOptional<z.ZodObject<{
+                unit: z.ZodEnum<["USD", "ops", "points"]>;
+                cap: z.ZodNumber;
+                window: z.ZodOptional<z.ZodObject<{
+                    kind: z.ZodEnum<["rolling", "fixed"]>;
+                    durationSec: z.ZodNumber;
+                }, "strip", z.ZodTypeAny, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }>>;
+            }, "strip", z.ZodTypeAny, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }>>;
+            scopes: z.ZodArray<z.ZodObject<{
+                resource: z.ZodString;
+                matcher: z.ZodEnum<["exact", "prefix", "regex"]>;
+                constraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+            }, "strip", z.ZodTypeAny, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }>, "many">;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            budget: z.ZodOptional<z.ZodObject<{
+                unit: z.ZodEnum<["USD", "ops", "points"]>;
+                cap: z.ZodNumber;
+                window: z.ZodOptional<z.ZodObject<{
+                    kind: z.ZodEnum<["rolling", "fixed"]>;
+                    durationSec: z.ZodNumber;
+                }, "strip", z.ZodTypeAny, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }>>;
+            }, "strip", z.ZodTypeAny, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }>>;
+            scopes: z.ZodArray<z.ZodObject<{
+                resource: z.ZodString;
+                matcher: z.ZodEnum<["exact", "prefix", "regex"]>;
+                constraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+            }, "strip", z.ZodTypeAny, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }>, "many">;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            budget: z.ZodOptional<z.ZodObject<{
+                unit: z.ZodEnum<["USD", "ops", "points"]>;
+                cap: z.ZodNumber;
+                window: z.ZodOptional<z.ZodObject<{
+                    kind: z.ZodEnum<["rolling", "fixed"]>;
+                    durationSec: z.ZodNumber;
+                }, "strip", z.ZodTypeAny, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }>>;
+            }, "strip", z.ZodTypeAny, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }>>;
+            scopes: z.ZodArray<z.ZodObject<{
+                resource: z.ZodString;
+                matcher: z.ZodEnum<["exact", "prefix", "regex"]>;
+                constraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+            }, "strip", z.ZodTypeAny, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }>, "many">;
+        }, z.ZodTypeAny, "passthrough">>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        notBefore: z.ZodOptional<z.ZodNumber>;
+        notAfter: z.ZodOptional<z.ZodNumber>;
+        crisp: z.ZodObject<{
+            budget: z.ZodOptional<z.ZodObject<{
+                unit: z.ZodEnum<["USD", "ops", "points"]>;
+                cap: z.ZodNumber;
+                window: z.ZodOptional<z.ZodObject<{
+                    kind: z.ZodEnum<["rolling", "fixed"]>;
+                    durationSec: z.ZodNumber;
+                }, "strip", z.ZodTypeAny, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }>>;
+            }, "strip", z.ZodTypeAny, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }>>;
+            scopes: z.ZodArray<z.ZodObject<{
+                resource: z.ZodString;
+                matcher: z.ZodEnum<["exact", "prefix", "regex"]>;
+                constraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+            }, "strip", z.ZodTypeAny, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }>, "many">;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            budget: z.ZodOptional<z.ZodObject<{
+                unit: z.ZodEnum<["USD", "ops", "points"]>;
+                cap: z.ZodNumber;
+                window: z.ZodOptional<z.ZodObject<{
+                    kind: z.ZodEnum<["rolling", "fixed"]>;
+                    durationSec: z.ZodNumber;
+                }, "strip", z.ZodTypeAny, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }>>;
+            }, "strip", z.ZodTypeAny, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }>>;
+            scopes: z.ZodArray<z.ZodObject<{
+                resource: z.ZodString;
+                matcher: z.ZodEnum<["exact", "prefix", "regex"]>;
+                constraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+            }, "strip", z.ZodTypeAny, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }>, "many">;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            budget: z.ZodOptional<z.ZodObject<{
+                unit: z.ZodEnum<["USD", "ops", "points"]>;
+                cap: z.ZodNumber;
+                window: z.ZodOptional<z.ZodObject<{
+                    kind: z.ZodEnum<["rolling", "fixed"]>;
+                    durationSec: z.ZodNumber;
+                }, "strip", z.ZodTypeAny, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }>>;
+            }, "strip", z.ZodTypeAny, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }>>;
+            scopes: z.ZodArray<z.ZodObject<{
+                resource: z.ZodString;
+                matcher: z.ZodEnum<["exact", "prefix", "regex"]>;
+                constraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+            }, "strip", z.ZodTypeAny, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }>, "many">;
+        }, z.ZodTypeAny, "passthrough">>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        notBefore: z.ZodOptional<z.ZodNumber>;
+        notAfter: z.ZodOptional<z.ZodNumber>;
+        crisp: z.ZodObject<{
+            budget: z.ZodOptional<z.ZodObject<{
+                unit: z.ZodEnum<["USD", "ops", "points"]>;
+                cap: z.ZodNumber;
+                window: z.ZodOptional<z.ZodObject<{
+                    kind: z.ZodEnum<["rolling", "fixed"]>;
+                    durationSec: z.ZodNumber;
+                }, "strip", z.ZodTypeAny, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }>>;
+            }, "strip", z.ZodTypeAny, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }>>;
+            scopes: z.ZodArray<z.ZodObject<{
+                resource: z.ZodString;
+                matcher: z.ZodEnum<["exact", "prefix", "regex"]>;
+                constraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+            }, "strip", z.ZodTypeAny, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }>, "many">;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            budget: z.ZodOptional<z.ZodObject<{
+                unit: z.ZodEnum<["USD", "ops", "points"]>;
+                cap: z.ZodNumber;
+                window: z.ZodOptional<z.ZodObject<{
+                    kind: z.ZodEnum<["rolling", "fixed"]>;
+                    durationSec: z.ZodNumber;
+                }, "strip", z.ZodTypeAny, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }>>;
+            }, "strip", z.ZodTypeAny, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }>>;
+            scopes: z.ZodArray<z.ZodObject<{
+                resource: z.ZodString;
+                matcher: z.ZodEnum<["exact", "prefix", "regex"]>;
+                constraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+            }, "strip", z.ZodTypeAny, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }>, "many">;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            budget: z.ZodOptional<z.ZodObject<{
+                unit: z.ZodEnum<["USD", "ops", "points"]>;
+                cap: z.ZodNumber;
+                window: z.ZodOptional<z.ZodObject<{
+                    kind: z.ZodEnum<["rolling", "fixed"]>;
+                    durationSec: z.ZodNumber;
+                }, "strip", z.ZodTypeAny, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }>>;
+            }, "strip", z.ZodTypeAny, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }>>;
+            scopes: z.ZodArray<z.ZodObject<{
+                resource: z.ZodString;
+                matcher: z.ZodEnum<["exact", "prefix", "regex"]>;
+                constraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+            }, "strip", z.ZodTypeAny, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }>, "many">;
+        }, z.ZodTypeAny, "passthrough">>;
+    }, z.ZodTypeAny, "passthrough">>;
+    /** Optional parent delegation ID */
+    parentId: z.ZodOptional<z.ZodString>;
+    /** Optional VC ID (if not provided, will be created) */
+    vcId: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    issuerDid: string;
+    subjectDid: string;
+    constraints: {
+        crisp: {
+            scopes: {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }[];
+            budget?: {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            } | undefined;
+        } & {
+            [k: string]: unknown;
+        };
+        notBefore?: number | undefined;
+        notAfter?: number | undefined;
+    } & {
+        [k: string]: unknown;
+    };
+    controller?: string | undefined;
+    vcId?: string | undefined;
+    parentId?: string | undefined;
+}, {
+    issuerDid: string;
+    subjectDid: string;
+    constraints: {
+        crisp: {
+            scopes: {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }[];
+            budget?: {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            } | undefined;
+        } & {
+            [k: string]: unknown;
+        };
+        notBefore?: number | undefined;
+        notAfter?: number | undefined;
+    } & {
+        [k: string]: unknown;
+    };
+    controller?: string | undefined;
+    vcId?: string | undefined;
+    parentId?: string | undefined;
+}>;
+export type DelegationCreationRequest = z.infer<typeof DelegationCreationRequestSchema>;
+/**
+ * Delegation Verification Result
+ *
+ * Result of delegation verification
+ */
+export declare const DelegationVerificationResultSchema: z.ZodObject<{
+    /** Whether delegation is valid */
+    valid: z.ZodBoolean;
+    /** Delegation ID */
+    delegationId: z.ZodString;
+    /** Status */
+    status: z.ZodEnum<["active", "revoked", "expired"]>;
+    /** Optional reason for invalid status */
+    reason: z.ZodOptional<z.ZodString>;
+    /** Whether backing VC is valid */
+    credentialValid: z.ZodOptional<z.ZodBoolean>;
+    /** Whether chain is valid (if part of chain) */
+    chainValid: z.ZodOptional<z.ZodBoolean>;
+    /** Timestamp of verification */
+    verifiedAt: z.ZodNumber;
+    /** Optional verification details */
+    details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+}, "strip", z.ZodTypeAny, {
+    valid: boolean;
+    status: "active" | "revoked" | "expired";
+    delegationId: string;
+    verifiedAt: number;
+    reason?: string | undefined;
+    credentialValid?: boolean | undefined;
+    chainValid?: boolean | undefined;
+    details?: Record<string, any> | undefined;
+}, {
+    valid: boolean;
+    status: "active" | "revoked" | "expired";
+    delegationId: string;
+    verifiedAt: number;
+    reason?: string | undefined;
+    credentialValid?: boolean | undefined;
+    chainValid?: boolean | undefined;
+    details?: Record<string, any> | undefined;
+}>;
+export type DelegationVerificationResult = z.infer<typeof DelegationVerificationResultSchema>;
+/**
+ * Validation Helpers
+ */
+/**
+ * Validate a delegation record
+ *
+ * @param record - The delegation record to validate
+ * @returns Validation result
+ */
+export declare function validateDelegationRecord(record: unknown): z.SafeParseReturnType<z.objectInputType<{
+    /** Unique identifier for the delegation */
+    id: z.ZodString;
+    /** DID of the delegator (issuer, e.g., merchant/user) */
+    issuerDid: z.ZodString;
+    /** DID of the delegatee (subject, e.g., agent) */
+    subjectDid: z.ZodString;
+    /** Optional controller (user account ID or DID) */
+    controller: z.ZodOptional<z.ZodString>;
+    /** ID of the backing Verifiable Credential */
+    vcId: z.ZodString;
+    /** Optional parent delegation ID for chain tracking */
+    parentId: z.ZodOptional<z.ZodString>;
+    /** CRISP constraints on this delegation */
+    constraints: z.ZodObject<{
+        notBefore: z.ZodOptional<z.ZodNumber>;
+        notAfter: z.ZodOptional<z.ZodNumber>;
+        crisp: z.ZodObject<{
+            budget: z.ZodOptional<z.ZodObject<{
+                unit: z.ZodEnum<["USD", "ops", "points"]>;
+                cap: z.ZodNumber;
+                window: z.ZodOptional<z.ZodObject<{
+                    kind: z.ZodEnum<["rolling", "fixed"]>;
+                    durationSec: z.ZodNumber;
+                }, "strip", z.ZodTypeAny, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }>>;
+            }, "strip", z.ZodTypeAny, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }>>;
+            scopes: z.ZodArray<z.ZodObject<{
+                resource: z.ZodString;
+                matcher: z.ZodEnum<["exact", "prefix", "regex"]>;
+                constraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+            }, "strip", z.ZodTypeAny, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }>, "many">;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            budget: z.ZodOptional<z.ZodObject<{
+                unit: z.ZodEnum<["USD", "ops", "points"]>;
+                cap: z.ZodNumber;
+                window: z.ZodOptional<z.ZodObject<{
+                    kind: z.ZodEnum<["rolling", "fixed"]>;
+                    durationSec: z.ZodNumber;
+                }, "strip", z.ZodTypeAny, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }>>;
+            }, "strip", z.ZodTypeAny, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }>>;
+            scopes: z.ZodArray<z.ZodObject<{
+                resource: z.ZodString;
+                matcher: z.ZodEnum<["exact", "prefix", "regex"]>;
+                constraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+            }, "strip", z.ZodTypeAny, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }>, "many">;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            budget: z.ZodOptional<z.ZodObject<{
+                unit: z.ZodEnum<["USD", "ops", "points"]>;
+                cap: z.ZodNumber;
+                window: z.ZodOptional<z.ZodObject<{
+                    kind: z.ZodEnum<["rolling", "fixed"]>;
+                    durationSec: z.ZodNumber;
+                }, "strip", z.ZodTypeAny, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }>>;
+            }, "strip", z.ZodTypeAny, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }>>;
+            scopes: z.ZodArray<z.ZodObject<{
+                resource: z.ZodString;
+                matcher: z.ZodEnum<["exact", "prefix", "regex"]>;
+                constraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+            }, "strip", z.ZodTypeAny, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }>, "many">;
+        }, z.ZodTypeAny, "passthrough">>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        notBefore: z.ZodOptional<z.ZodNumber>;
+        notAfter: z.ZodOptional<z.ZodNumber>;
+        crisp: z.ZodObject<{
+            budget: z.ZodOptional<z.ZodObject<{
+                unit: z.ZodEnum<["USD", "ops", "points"]>;
+                cap: z.ZodNumber;
+                window: z.ZodOptional<z.ZodObject<{
+                    kind: z.ZodEnum<["rolling", "fixed"]>;
+                    durationSec: z.ZodNumber;
+                }, "strip", z.ZodTypeAny, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }>>;
+            }, "strip", z.ZodTypeAny, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }>>;
+            scopes: z.ZodArray<z.ZodObject<{
+                resource: z.ZodString;
+                matcher: z.ZodEnum<["exact", "prefix", "regex"]>;
+                constraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+            }, "strip", z.ZodTypeAny, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }>, "many">;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            budget: z.ZodOptional<z.ZodObject<{
+                unit: z.ZodEnum<["USD", "ops", "points"]>;
+                cap: z.ZodNumber;
+                window: z.ZodOptional<z.ZodObject<{
+                    kind: z.ZodEnum<["rolling", "fixed"]>;
+                    durationSec: z.ZodNumber;
+                }, "strip", z.ZodTypeAny, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }>>;
+            }, "strip", z.ZodTypeAny, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }>>;
+            scopes: z.ZodArray<z.ZodObject<{
+                resource: z.ZodString;
+                matcher: z.ZodEnum<["exact", "prefix", "regex"]>;
+                constraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+            }, "strip", z.ZodTypeAny, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }>, "many">;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            budget: z.ZodOptional<z.ZodObject<{
+                unit: z.ZodEnum<["USD", "ops", "points"]>;
+                cap: z.ZodNumber;
+                window: z.ZodOptional<z.ZodObject<{
+                    kind: z.ZodEnum<["rolling", "fixed"]>;
+                    durationSec: z.ZodNumber;
+                }, "strip", z.ZodTypeAny, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }>>;
+            }, "strip", z.ZodTypeAny, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }>>;
+            scopes: z.ZodArray<z.ZodObject<{
+                resource: z.ZodString;
+                matcher: z.ZodEnum<["exact", "prefix", "regex"]>;
+                constraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+            }, "strip", z.ZodTypeAny, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }>, "many">;
+        }, z.ZodTypeAny, "passthrough">>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        notBefore: z.ZodOptional<z.ZodNumber>;
+        notAfter: z.ZodOptional<z.ZodNumber>;
+        crisp: z.ZodObject<{
+            budget: z.ZodOptional<z.ZodObject<{
+                unit: z.ZodEnum<["USD", "ops", "points"]>;
+                cap: z.ZodNumber;
+                window: z.ZodOptional<z.ZodObject<{
+                    kind: z.ZodEnum<["rolling", "fixed"]>;
+                    durationSec: z.ZodNumber;
+                }, "strip", z.ZodTypeAny, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }>>;
+            }, "strip", z.ZodTypeAny, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }>>;
+            scopes: z.ZodArray<z.ZodObject<{
+                resource: z.ZodString;
+                matcher: z.ZodEnum<["exact", "prefix", "regex"]>;
+                constraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+            }, "strip", z.ZodTypeAny, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }>, "many">;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            budget: z.ZodOptional<z.ZodObject<{
+                unit: z.ZodEnum<["USD", "ops", "points"]>;
+                cap: z.ZodNumber;
+                window: z.ZodOptional<z.ZodObject<{
+                    kind: z.ZodEnum<["rolling", "fixed"]>;
+                    durationSec: z.ZodNumber;
+                }, "strip", z.ZodTypeAny, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }>>;
+            }, "strip", z.ZodTypeAny, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }>>;
+            scopes: z.ZodArray<z.ZodObject<{
+                resource: z.ZodString;
+                matcher: z.ZodEnum<["exact", "prefix", "regex"]>;
+                constraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+            }, "strip", z.ZodTypeAny, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }>, "many">;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            budget: z.ZodOptional<z.ZodObject<{
+                unit: z.ZodEnum<["USD", "ops", "points"]>;
+                cap: z.ZodNumber;
+                window: z.ZodOptional<z.ZodObject<{
+                    kind: z.ZodEnum<["rolling", "fixed"]>;
+                    durationSec: z.ZodNumber;
+                }, "strip", z.ZodTypeAny, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }>>;
+            }, "strip", z.ZodTypeAny, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }>>;
+            scopes: z.ZodArray<z.ZodObject<{
+                resource: z.ZodString;
+                matcher: z.ZodEnum<["exact", "prefix", "regex"]>;
+                constraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+            }, "strip", z.ZodTypeAny, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }>, "many">;
+        }, z.ZodTypeAny, "passthrough">>;
+    }, z.ZodTypeAny, "passthrough">>;
+    /** Detached JWS signature over canonical delegation document */
+    signature: z.ZodString;
+    /** Current status of the delegation */
+    status: z.ZodEnum<["active", "revoked", "expired"]>;
+    /** Timestamp when created (milliseconds since epoch) */
+    createdAt: z.ZodOptional<z.ZodNumber>;
+    /** Timestamp when revoked (if status is revoked) */
+    revokedAt: z.ZodOptional<z.ZodNumber>;
+    /** Optional reason for revocation */
+    revokedReason: z.ZodOptional<z.ZodString>;
+    /** Optional metadata */
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+}, z.ZodTypeAny, "passthrough">, z.objectOutputType<{
+    /** Unique identifier for the delegation */
+    id: z.ZodString;
+    /** DID of the delegator (issuer, e.g., merchant/user) */
+    issuerDid: z.ZodString;
+    /** DID of the delegatee (subject, e.g., agent) */
+    subjectDid: z.ZodString;
+    /** Optional controller (user account ID or DID) */
+    controller: z.ZodOptional<z.ZodString>;
+    /** ID of the backing Verifiable Credential */
+    vcId: z.ZodString;
+    /** Optional parent delegation ID for chain tracking */
+    parentId: z.ZodOptional<z.ZodString>;
+    /** CRISP constraints on this delegation */
+    constraints: z.ZodObject<{
+        notBefore: z.ZodOptional<z.ZodNumber>;
+        notAfter: z.ZodOptional<z.ZodNumber>;
+        crisp: z.ZodObject<{
+            budget: z.ZodOptional<z.ZodObject<{
+                unit: z.ZodEnum<["USD", "ops", "points"]>;
+                cap: z.ZodNumber;
+                window: z.ZodOptional<z.ZodObject<{
+                    kind: z.ZodEnum<["rolling", "fixed"]>;
+                    durationSec: z.ZodNumber;
+                }, "strip", z.ZodTypeAny, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }>>;
+            }, "strip", z.ZodTypeAny, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }>>;
+            scopes: z.ZodArray<z.ZodObject<{
+                resource: z.ZodString;
+                matcher: z.ZodEnum<["exact", "prefix", "regex"]>;
+                constraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+            }, "strip", z.ZodTypeAny, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }>, "many">;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            budget: z.ZodOptional<z.ZodObject<{
+                unit: z.ZodEnum<["USD", "ops", "points"]>;
+                cap: z.ZodNumber;
+                window: z.ZodOptional<z.ZodObject<{
+                    kind: z.ZodEnum<["rolling", "fixed"]>;
+                    durationSec: z.ZodNumber;
+                }, "strip", z.ZodTypeAny, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }>>;
+            }, "strip", z.ZodTypeAny, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }>>;
+            scopes: z.ZodArray<z.ZodObject<{
+                resource: z.ZodString;
+                matcher: z.ZodEnum<["exact", "prefix", "regex"]>;
+                constraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+            }, "strip", z.ZodTypeAny, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }>, "many">;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            budget: z.ZodOptional<z.ZodObject<{
+                unit: z.ZodEnum<["USD", "ops", "points"]>;
+                cap: z.ZodNumber;
+                window: z.ZodOptional<z.ZodObject<{
+                    kind: z.ZodEnum<["rolling", "fixed"]>;
+                    durationSec: z.ZodNumber;
+                }, "strip", z.ZodTypeAny, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }>>;
+            }, "strip", z.ZodTypeAny, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }>>;
+            scopes: z.ZodArray<z.ZodObject<{
+                resource: z.ZodString;
+                matcher: z.ZodEnum<["exact", "prefix", "regex"]>;
+                constraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+            }, "strip", z.ZodTypeAny, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }>, "many">;
+        }, z.ZodTypeAny, "passthrough">>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        notBefore: z.ZodOptional<z.ZodNumber>;
+        notAfter: z.ZodOptional<z.ZodNumber>;
+        crisp: z.ZodObject<{
+            budget: z.ZodOptional<z.ZodObject<{
+                unit: z.ZodEnum<["USD", "ops", "points"]>;
+                cap: z.ZodNumber;
+                window: z.ZodOptional<z.ZodObject<{
+                    kind: z.ZodEnum<["rolling", "fixed"]>;
+                    durationSec: z.ZodNumber;
+                }, "strip", z.ZodTypeAny, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }>>;
+            }, "strip", z.ZodTypeAny, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }>>;
+            scopes: z.ZodArray<z.ZodObject<{
+                resource: z.ZodString;
+                matcher: z.ZodEnum<["exact", "prefix", "regex"]>;
+                constraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+            }, "strip", z.ZodTypeAny, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }>, "many">;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            budget: z.ZodOptional<z.ZodObject<{
+                unit: z.ZodEnum<["USD", "ops", "points"]>;
+                cap: z.ZodNumber;
+                window: z.ZodOptional<z.ZodObject<{
+                    kind: z.ZodEnum<["rolling", "fixed"]>;
+                    durationSec: z.ZodNumber;
+                }, "strip", z.ZodTypeAny, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }>>;
+            }, "strip", z.ZodTypeAny, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }>>;
+            scopes: z.ZodArray<z.ZodObject<{
+                resource: z.ZodString;
+                matcher: z.ZodEnum<["exact", "prefix", "regex"]>;
+                constraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+            }, "strip", z.ZodTypeAny, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }>, "many">;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            budget: z.ZodOptional<z.ZodObject<{
+                unit: z.ZodEnum<["USD", "ops", "points"]>;
+                cap: z.ZodNumber;
+                window: z.ZodOptional<z.ZodObject<{
+                    kind: z.ZodEnum<["rolling", "fixed"]>;
+                    durationSec: z.ZodNumber;
+                }, "strip", z.ZodTypeAny, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }>>;
+            }, "strip", z.ZodTypeAny, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }>>;
+            scopes: z.ZodArray<z.ZodObject<{
+                resource: z.ZodString;
+                matcher: z.ZodEnum<["exact", "prefix", "regex"]>;
+                constraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+            }, "strip", z.ZodTypeAny, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }>, "many">;
+        }, z.ZodTypeAny, "passthrough">>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        notBefore: z.ZodOptional<z.ZodNumber>;
+        notAfter: z.ZodOptional<z.ZodNumber>;
+        crisp: z.ZodObject<{
+            budget: z.ZodOptional<z.ZodObject<{
+                unit: z.ZodEnum<["USD", "ops", "points"]>;
+                cap: z.ZodNumber;
+                window: z.ZodOptional<z.ZodObject<{
+                    kind: z.ZodEnum<["rolling", "fixed"]>;
+                    durationSec: z.ZodNumber;
+                }, "strip", z.ZodTypeAny, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }>>;
+            }, "strip", z.ZodTypeAny, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }>>;
+            scopes: z.ZodArray<z.ZodObject<{
+                resource: z.ZodString;
+                matcher: z.ZodEnum<["exact", "prefix", "regex"]>;
+                constraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+            }, "strip", z.ZodTypeAny, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }>, "many">;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            budget: z.ZodOptional<z.ZodObject<{
+                unit: z.ZodEnum<["USD", "ops", "points"]>;
+                cap: z.ZodNumber;
+                window: z.ZodOptional<z.ZodObject<{
+                    kind: z.ZodEnum<["rolling", "fixed"]>;
+                    durationSec: z.ZodNumber;
+                }, "strip", z.ZodTypeAny, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }>>;
+            }, "strip", z.ZodTypeAny, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }>>;
+            scopes: z.ZodArray<z.ZodObject<{
+                resource: z.ZodString;
+                matcher: z.ZodEnum<["exact", "prefix", "regex"]>;
+                constraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+            }, "strip", z.ZodTypeAny, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }>, "many">;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            budget: z.ZodOptional<z.ZodObject<{
+                unit: z.ZodEnum<["USD", "ops", "points"]>;
+                cap: z.ZodNumber;
+                window: z.ZodOptional<z.ZodObject<{
+                    kind: z.ZodEnum<["rolling", "fixed"]>;
+                    durationSec: z.ZodNumber;
+                }, "strip", z.ZodTypeAny, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }, {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                }>>;
+            }, "strip", z.ZodTypeAny, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }, {
+                unit: "USD" | "ops" | "points";
+                cap: number;
+                window?: {
+                    kind: "rolling" | "fixed";
+                    durationSec: number;
+                } | undefined;
+            }>>;
+            scopes: z.ZodArray<z.ZodObject<{
+                resource: z.ZodString;
+                matcher: z.ZodEnum<["exact", "prefix", "regex"]>;
+                constraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+            }, "strip", z.ZodTypeAny, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }, {
+                resource: string;
+                matcher: "exact" | "prefix" | "regex";
+                constraints?: Record<string, any> | undefined;
+            }>, "many">;
+        }, z.ZodTypeAny, "passthrough">>;
+    }, z.ZodTypeAny, "passthrough">>;
+    /** Detached JWS signature over canonical delegation document */
+    signature: z.ZodString;
+    /** Current status of the delegation */
+    status: z.ZodEnum<["active", "revoked", "expired"]>;
+    /** Timestamp when created (milliseconds since epoch) */
+    createdAt: z.ZodOptional<z.ZodNumber>;
+    /** Timestamp when revoked (if status is revoked) */
+    revokedAt: z.ZodOptional<z.ZodNumber>;
+    /** Optional reason for revocation */
+    revokedReason: z.ZodOptional<z.ZodString>;
+    /** Optional metadata */
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+}, z.ZodTypeAny, "passthrough">>;
+/**
+ * Validate a delegation chain
+ *
+ * @param chain - The delegation chain to validate
+ * @returns Validation result
+ */
+export declare function validateDelegationChain(chain: unknown): z.SafeParseReturnType<{
+    valid: boolean;
+    depth: number;
+    rootIssuer: string;
+    leafSubject: string;
+    chain: {
+        issuerDid: string;
+        subjectDid: string;
+        vcId: string;
+        status: "active" | "revoked" | "expired";
+        constraints: {
+            crisp: {
+                scopes: {
+                    resource: string;
+                    matcher: "exact" | "prefix" | "regex";
+                    constraints?: Record<string, any> | undefined;
+                }[];
+                budget?: {
+                    unit: "USD" | "ops" | "points";
+                    cap: number;
+                    window?: {
+                        kind: "rolling" | "fixed";
+                        durationSec: number;
+                    } | undefined;
+                } | undefined;
+            } & {
+                [k: string]: unknown;
+            };
+            notBefore?: number | undefined;
+            notAfter?: number | undefined;
+        } & {
+            [k: string]: unknown;
+        };
+        delegationId: string;
+        depth: number;
+    }[];
+    errors?: string[] | undefined;
+}, {
+    valid: boolean;
+    depth: number;
+    rootIssuer: string;
+    leafSubject: string;
+    chain: {
+        issuerDid: string;
+        subjectDid: string;
+        vcId: string;
+        status: "active" | "revoked" | "expired";
+        constraints: {
+            crisp: {
+                scopes: {
+                    resource: string;
+                    matcher: "exact" | "prefix" | "regex";
+                    constraints?: Record<string, any> | undefined;
+                }[];
+                budget?: {
+                    unit: "USD" | "ops" | "points";
+                    cap: number;
+                    window?: {
+                        kind: "rolling" | "fixed";
+                        durationSec: number;
+                    } | undefined;
+                } | undefined;
+            } & {
+                [k: string]: unknown;
+            };
+            notBefore?: number | undefined;
+            notAfter?: number | undefined;
+        } & {
+            [k: string]: unknown;
+        };
+        delegationId: string;
+        depth: number;
+    }[];
+    errors?: string[] | undefined;
+}>;
+/**
+ * Check if a delegation is expired based on constraints
+ *
+ * @param delegation - The delegation to check
+ * @returns true if expired
+ */
+export declare function isDelegationExpired(delegation: DelegationRecord): boolean;
+/**
+ * Check if a delegation is not yet valid based on constraints
+ *
+ * @param delegation - The delegation to check
+ * @returns true if not yet valid
+ */
+export declare function isDelegationNotYetValid(delegation: DelegationRecord): boolean;
+/**
+ * Check if a delegation is currently valid (active and within time bounds)
+ *
+ * @param delegation - The delegation to check
+ * @returns true if currently valid
+ */
+export declare function isDelegationCurrentlyValid(delegation: DelegationRecord): boolean;
+/**
+ * Constants
+ */
+/**
+ * Maximum reasonable delegation chain depth
+ */
+export declare const MAX_DELEGATION_CHAIN_DEPTH = 10;
+/**
+ * Default delegation status for new delegations
+ */
+export declare const DEFAULT_DELEGATION_STATUS: DelegationStatus;
+/**
+ * Supported delegation statuses
+ */
+export declare const DELEGATION_STATUSES: DelegationStatus[];
+//# sourceMappingURL=schemas.d.ts.map