@kya-os/contracts 1.3.1-canary.0 → 1.3.1-canary.1

package/dist/delegation/schemas.d.ts

@@ -1,4081 +0,0 @@
-/**
- * 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>;
-        scopes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-        crisp: z.ZodOptional<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>;
-        scopes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-        crisp: z.ZodOptional<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>;
-        scopes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-        crisp: z.ZodOptional<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>;
-        scopes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-        crisp: z.ZodOptional<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>;
-        scopes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-        crisp: z.ZodOptional<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>;
-        scopes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-        crisp: z.ZodOptional<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>;
-        scopes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-        crisp: z.ZodOptional<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>;
-        scopes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-        crisp: z.ZodOptional<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>;
-        scopes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-        crisp: z.ZodOptional<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>;
-        scopes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-        crisp: z.ZodOptional<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>;
-        scopes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-        crisp: z.ZodOptional<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>;
-        scopes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-        crisp: z.ZodOptional<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, {
-    status: "active" | "revoked" | "expired";
-    constraints: {
-        notBefore?: number | undefined;
-        notAfter?: number | undefined;
-        scopes?: string[] | undefined;
-        crisp?: 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"> | undefined;
-    } & {
-        [k: string]: unknown;
-    };
-    issuerDid: string;
-    subjectDid: string;
-    vcId: string;
-    delegationId: string;
-    depth: number;
-}, {
-    status: "active" | "revoked" | "expired";
-    constraints: {
-        notBefore?: number | undefined;
-        notAfter?: number | undefined;
-        scopes?: string[] | undefined;
-        crisp?: 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"> | undefined;
-    } & {
-        [k: string]: unknown;
-    };
-    issuerDid: string;
-    subjectDid: string;
-    vcId: string;
-    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>;
-            scopes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-            crisp: z.ZodOptional<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>;
-            scopes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-            crisp: z.ZodOptional<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>;
-            scopes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-            crisp: z.ZodOptional<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, {
-        status: "active" | "revoked" | "expired";
-        constraints: {
-            notBefore?: number | undefined;
-            notAfter?: number | undefined;
-            scopes?: string[] | undefined;
-            crisp?: 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"> | undefined;
-        } & {
-            [k: string]: unknown;
-        };
-        issuerDid: string;
-        subjectDid: string;
-        vcId: string;
-        delegationId: string;
-        depth: number;
-    }, {
-        status: "active" | "revoked" | "expired";
-        constraints: {
-            notBefore?: number | undefined;
-            notAfter?: number | undefined;
-            scopes?: string[] | undefined;
-            crisp?: 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"> | undefined;
-        } & {
-            [k: string]: unknown;
-        };
-        issuerDid: string;
-        subjectDid: string;
-        vcId: string;
-        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: {
-        status: "active" | "revoked" | "expired";
-        constraints: {
-            notBefore?: number | undefined;
-            notAfter?: number | undefined;
-            scopes?: string[] | undefined;
-            crisp?: 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"> | undefined;
-        } & {
-            [k: string]: unknown;
-        };
-        issuerDid: string;
-        subjectDid: string;
-        vcId: string;
-        delegationId: string;
-        depth: number;
-    }[];
-    errors?: string[] | undefined;
-}, {
-    valid: boolean;
-    depth: number;
-    rootIssuer: string;
-    leafSubject: string;
-    chain: {
-        status: "active" | "revoked" | "expired";
-        constraints: {
-            notBefore?: number | undefined;
-            notAfter?: number | undefined;
-            scopes?: string[] | undefined;
-            crisp?: 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"> | undefined;
-        } & {
-            [k: string]: unknown;
-        };
-        issuerDid: string;
-        subjectDid: string;
-        vcId: string;
-        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>;
-        scopes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-        crisp: z.ZodOptional<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>;
-        scopes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-        crisp: z.ZodOptional<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>;
-        scopes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-        crisp: z.ZodOptional<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, {
-    constraints: {
-        notBefore?: number | undefined;
-        notAfter?: number | undefined;
-        scopes?: string[] | undefined;
-        crisp?: 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"> | undefined;
-    } & {
-        [k: string]: unknown;
-    };
-    issuerDid: string;
-    subjectDid: string;
-    controller?: string | undefined;
-    vcId?: string | undefined;
-    parentId?: string | undefined;
-}, {
-    constraints: {
-        notBefore?: number | undefined;
-        notAfter?: number | undefined;
-        scopes?: string[] | undefined;
-        crisp?: 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"> | undefined;
-    } & {
-        [k: string]: unknown;
-    };
-    issuerDid: string;
-    subjectDid: string;
-    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>;
-        scopes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-        crisp: z.ZodOptional<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>;
-        scopes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-        crisp: z.ZodOptional<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>;
-        scopes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-        crisp: z.ZodOptional<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>;
-        scopes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-        crisp: z.ZodOptional<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>;
-        scopes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-        crisp: z.ZodOptional<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>;
-        scopes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-        crisp: z.ZodOptional<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: {
-        status: "active" | "revoked" | "expired";
-        constraints: {
-            notBefore?: number | undefined;
-            notAfter?: number | undefined;
-            scopes?: string[] | undefined;
-            crisp?: 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"> | undefined;
-        } & {
-            [k: string]: unknown;
-        };
-        issuerDid: string;
-        subjectDid: string;
-        vcId: string;
-        delegationId: string;
-        depth: number;
-    }[];
-    errors?: string[] | undefined;
-}, {
-    valid: boolean;
-    depth: number;
-    rootIssuer: string;
-    leafSubject: string;
-    chain: {
-        status: "active" | "revoked" | "expired";
-        constraints: {
-            notBefore?: number | undefined;
-            notAfter?: number | undefined;
-            scopes?: string[] | undefined;
-            crisp?: 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"> | undefined;
-        } & {
-            [k: string]: unknown;
-        };
-        issuerDid: string;
-        subjectDid: string;
-        vcId: string;
-        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