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

package/dist/delegation/schemas.d.ts

@@ -4,10 +4,17 @@
  * 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
+ * **IMPORTANT**: Per Python POC design (Delegation-Service.md:136-146),
+ * delegations SHOULD be issued as W3C Verifiable Credentials, not just reference them.
+ * This file provides both:
+ * - DelegationRecord: Legacy/internal format (contains delegation data)
+ * - DelegationCredential: W3C VC format (delegation as credentialSubject)
+ *
+ * Related Spec: MCP-I §4.1, §4.2, W3C VC Data Model 1.1
  * Python Reference: Delegation-Documentation.md, Delegation-Service.md
  */
 import { z } from 'zod';
+import { CredentialStatusSchema } from '../vc/schemas.js';
 /**
  * Delegation Status
  *
@@ -1706,6 +1713,9 @@ export declare const DelegationChainEntrySchema: z.ZodObject<{
     status: z.ZodEnum<["active", "revoked", "expired"]>;
 }, "strip", z.ZodTypeAny, {
     status: "active" | "revoked" | "expired";
+    issuerDid: string;
+    subjectDid: string;
+    vcId: string;
     constraints: {
         notBefore?: number | undefined;
         notAfter?: number | undefined;
@@ -1756,13 +1766,13 @@ export declare const DelegationChainEntrySchema: z.ZodObject<{
     } & {
         [k: string]: unknown;
     };
-    issuerDid: string;
-    subjectDid: string;
-    vcId: string;
     delegationId: string;
     depth: number;
 }, {
     status: "active" | "revoked" | "expired";
+    issuerDid: string;
+    subjectDid: string;
+    vcId: string;
     constraints: {
         notBefore?: number | undefined;
         notAfter?: number | undefined;
@@ -1813,9 +1823,6 @@ export declare const DelegationChainEntrySchema: z.ZodObject<{
     } & {
         [k: string]: unknown;
     };
-    issuerDid: string;
-    subjectDid: string;
-    vcId: string;
     delegationId: string;
     depth: number;
 }>;
@@ -2241,6 +2248,9 @@ export declare const DelegationChainSchema: z.ZodObject<{
         status: z.ZodEnum<["active", "revoked", "expired"]>;
     }, "strip", z.ZodTypeAny, {
         status: "active" | "revoked" | "expired";
+        issuerDid: string;
+        subjectDid: string;
+        vcId: string;
         constraints: {
             notBefore?: number | undefined;
             notAfter?: number | undefined;
@@ -2291,13 +2301,13 @@ export declare const DelegationChainSchema: z.ZodObject<{
         } & {
             [k: string]: unknown;
         };
-        issuerDid: string;
-        subjectDid: string;
-        vcId: string;
         delegationId: string;
         depth: number;
     }, {
         status: "active" | "revoked" | "expired";
+        issuerDid: string;
+        subjectDid: string;
+        vcId: string;
         constraints: {
             notBefore?: number | undefined;
             notAfter?: number | undefined;
@@ -2348,9 +2358,6 @@ export declare const DelegationChainSchema: z.ZodObject<{
         } & {
             [k: string]: unknown;
         };
-        issuerDid: string;
-        subjectDid: string;
-        vcId: string;
         delegationId: string;
         depth: number;
     }>, "many">;
@@ -2367,6 +2374,9 @@ export declare const DelegationChainSchema: z.ZodObject<{
     leafSubject: string;
     chain: {
         status: "active" | "revoked" | "expired";
+        issuerDid: string;
+        subjectDid: string;
+        vcId: string;
         constraints: {
             notBefore?: number | undefined;
             notAfter?: number | undefined;
@@ -2417,9 +2427,6 @@ export declare const DelegationChainSchema: z.ZodObject<{
         } & {
             [k: string]: unknown;
         };
-        issuerDid: string;
-        subjectDid: string;
-        vcId: string;
         delegationId: string;
         depth: number;
     }[];
@@ -2431,6 +2438,9 @@ export declare const DelegationChainSchema: z.ZodObject<{
     leafSubject: string;
     chain: {
         status: "active" | "revoked" | "expired";
+        issuerDid: string;
+        subjectDid: string;
+        vcId: string;
         constraints: {
             notBefore?: number | undefined;
             notAfter?: number | undefined;
@@ -2481,9 +2491,6 @@ export declare const DelegationChainSchema: z.ZodObject<{
         } & {
             [k: string]: unknown;
         };
-        issuerDid: string;
-        subjectDid: string;
-        vcId: string;
         delegationId: string;
         depth: number;
     }[];
@@ -2902,6 +2909,8 @@ export declare const DelegationCreationRequestSchema: z.ZodObject<{
     /** Optional VC ID (if not provided, will be created) */
     vcId: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
+    issuerDid: string;
+    subjectDid: string;
     constraints: {
         notBefore?: number | undefined;
         notAfter?: number | undefined;
@@ -2952,12 +2961,12 @@ export declare const DelegationCreationRequestSchema: z.ZodObject<{
     } & {
         [k: string]: unknown;
     };
-    issuerDid: string;
-    subjectDid: string;
     controller?: string | undefined;
     vcId?: string | undefined;
     parentId?: string | undefined;
 }, {
+    issuerDid: string;
+    subjectDid: string;
     constraints: {
         notBefore?: number | undefined;
         notAfter?: number | undefined;
@@ -3008,8 +3017,6 @@ export declare const DelegationCreationRequestSchema: z.ZodObject<{
     } & {
         [k: string]: unknown;
     };
-    issuerDid: string;
-    subjectDid: string;
     controller?: string | undefined;
     vcId?: string | undefined;
     parentId?: string | undefined;
@@ -3920,6 +3927,9 @@ export declare function validateDelegationChain(chain: unknown): z.SafeParseRetu
     leafSubject: string;
     chain: {
         status: "active" | "revoked" | "expired";
+        issuerDid: string;
+        subjectDid: string;
+        vcId: string;
         constraints: {
             notBefore?: number | undefined;
             notAfter?: number | undefined;
@@ -3970,9 +3980,6 @@ export declare function validateDelegationChain(chain: unknown): z.SafeParseRetu
         } & {
             [k: string]: unknown;
         };
-        issuerDid: string;
-        subjectDid: string;
-        vcId: string;
         delegationId: string;
         depth: number;
     }[];
@@ -3984,6 +3991,9 @@ export declare function validateDelegationChain(chain: unknown): z.SafeParseRetu
     leafSubject: string;
     chain: {
         status: "active" | "revoked" | "expired";
+        issuerDid: string;
+        subjectDid: string;
+        vcId: string;
         constraints: {
             notBefore?: number | undefined;
             notAfter?: number | undefined;
@@ -4034,9 +4044,6 @@ export declare function validateDelegationChain(chain: unknown): z.SafeParseRetu
         } & {
             [k: string]: unknown;
         };
-        issuerDid: string;
-        subjectDid: string;
-        vcId: string;
         delegationId: string;
         depth: number;
     }[];
@@ -4078,4 +4085,4298 @@ export declare const DEFAULT_DELEGATION_STATUS: DelegationStatus;
  * Supported delegation statuses
  */
 export declare const DELEGATION_STATUSES: DelegationStatus[];
+/**
+ * Delegation Credential Context
+ *
+ * Additional JSON-LD context for delegation credentials
+ */
+export declare const DELEGATION_CREDENTIAL_CONTEXT: "https://schemas.kya-os.ai/xmcp-i/credentials/delegation.v1.0.0.json";
+/**
+ * Delegation Credential Subject Schema
+ *
+ * The credentialSubject of a DelegationCredential contains:
+ * - id: The delegatee DID (subject of the delegation)
+ * - delegation: The complete delegation record
+ *
+ * Per Python POC (Delegation-Service.md:136-146), delegations are issued AS
+ * W3C VCs, with the delegation data embedded in the credentialSubject.
+ */
+export declare const DelegationCredentialSubjectSchema: z.ZodObject<{
+    /** Subject DID (delegatee) */
+    id: z.ZodString;
+    /** The delegation information */
+    delegation: 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>;
+        /** 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">>;
+        /** Current status of the delegation */
+        status: z.ZodDefault<z.ZodEnum<["active", "revoked", "expired"]>>;
+        /** Timestamp when created (milliseconds since epoch) */
+        createdAt: z.ZodOptional<z.ZodNumber>;
+        /** Optional metadata */
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    }, "strip", z.ZodTypeAny, {
+        status: "active" | "revoked" | "expired";
+        id: string;
+        issuerDid: string;
+        subjectDid: string;
+        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;
+        };
+        controller?: string | undefined;
+        parentId?: string | undefined;
+        createdAt?: number | undefined;
+        metadata?: Record<string, any> | undefined;
+    }, {
+        id: string;
+        issuerDid: string;
+        subjectDid: string;
+        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;
+        };
+        status?: "active" | "revoked" | "expired" | undefined;
+        controller?: string | undefined;
+        parentId?: string | undefined;
+        createdAt?: number | undefined;
+        metadata?: Record<string, any> | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    delegation: {
+        status: "active" | "revoked" | "expired";
+        id: string;
+        issuerDid: string;
+        subjectDid: string;
+        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;
+        };
+        controller?: string | undefined;
+        parentId?: string | undefined;
+        createdAt?: number | undefined;
+        metadata?: Record<string, any> | undefined;
+    };
+}, {
+    id: string;
+    delegation: {
+        id: string;
+        issuerDid: string;
+        subjectDid: string;
+        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;
+        };
+        status?: "active" | "revoked" | "expired" | undefined;
+        controller?: string | undefined;
+        parentId?: string | undefined;
+        createdAt?: number | undefined;
+        metadata?: Record<string, any> | undefined;
+    };
+}>;
+export type DelegationCredentialSubject = z.infer<typeof DelegationCredentialSubjectSchema>;
+/**
+ * Delegation Credential Schema
+ *
+ * W3C Verifiable Credential for delegations.
+ * This is the PRIMARY format for delegation issuance and verification.
+ *
+ * Structure:
+ * - @context: [...W3C VC contexts, delegation context]
+ * - type: ['VerifiableCredential', 'DelegationCredential']
+ * - issuer: Delegator DID
+ * - issuanceDate: When delegation was created
+ * - expirationDate: Maps to delegation.constraints.notAfter
+ * - credentialSubject: Contains delegatee DID + delegation data
+ * - credentialStatus: StatusList2021Entry for revocation checking
+ * - proof: Ed25519Signature2020
+ *
+ * Per Python POC design (Delegation-Service.md:136-163):
+ * - Every delegation MUST be issued as a VC
+ * - Verification checks BOTH the VC signature AND delegation constraints
+ * - Revocation updates the StatusList2021
+ *
+ * Related Spec: MCP-I §4.1, §4.2, W3C VC Data Model 1.1
+ */
+export declare const DelegationCredentialSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+} & {
+    '@context': z.ZodEffects<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodAny>]>, "many">, (string | Record<string, any>)[], (string | Record<string, any>)[]>;
+    type: z.ZodEffects<z.ZodArray<z.ZodString, "many">, string[], string[]>;
+    issuer: z.ZodUnion<[z.ZodString, z.ZodObject<{
+        id: z.ZodString;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        id: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        id: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">>]>;
+    issuanceDate: z.ZodString;
+    expirationDate: z.ZodOptional<z.ZodString>;
+    credentialSubject: z.ZodObject<{
+        /** Subject DID (delegatee) */
+        id: z.ZodString;
+        /** The delegation information */
+        delegation: 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>;
+            /** 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">>;
+            /** Current status of the delegation */
+            status: z.ZodDefault<z.ZodEnum<["active", "revoked", "expired"]>>;
+            /** Timestamp when created (milliseconds since epoch) */
+            createdAt: z.ZodOptional<z.ZodNumber>;
+            /** Optional metadata */
+            metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        }, "strip", z.ZodTypeAny, {
+            status: "active" | "revoked" | "expired";
+            id: string;
+            issuerDid: string;
+            subjectDid: string;
+            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;
+            };
+            controller?: string | undefined;
+            parentId?: string | undefined;
+            createdAt?: number | undefined;
+            metadata?: Record<string, any> | undefined;
+        }, {
+            id: string;
+            issuerDid: string;
+            subjectDid: string;
+            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;
+            };
+            status?: "active" | "revoked" | "expired" | undefined;
+            controller?: string | undefined;
+            parentId?: string | undefined;
+            createdAt?: number | undefined;
+            metadata?: Record<string, any> | undefined;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        delegation: {
+            status: "active" | "revoked" | "expired";
+            id: string;
+            issuerDid: string;
+            subjectDid: string;
+            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;
+            };
+            controller?: string | undefined;
+            parentId?: string | undefined;
+            createdAt?: number | undefined;
+            metadata?: Record<string, any> | undefined;
+        };
+    }, {
+        id: string;
+        delegation: {
+            id: string;
+            issuerDid: string;
+            subjectDid: string;
+            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;
+            };
+            status?: "active" | "revoked" | "expired" | undefined;
+            controller?: string | undefined;
+            parentId?: string | undefined;
+            createdAt?: number | undefined;
+            metadata?: Record<string, any> | undefined;
+        };
+    }>;
+    credentialStatus: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"StatusList2021Entry">;
+        statusPurpose: z.ZodEnum<["revocation", "suspension"]>;
+        statusListIndex: z.ZodString;
+        statusListCredential: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: "StatusList2021Entry";
+        id: string;
+        statusPurpose: "revocation" | "suspension";
+        statusListIndex: string;
+        statusListCredential: string;
+    }, {
+        type: "StatusList2021Entry";
+        id: string;
+        statusPurpose: "revocation" | "suspension";
+        statusListIndex: string;
+        statusListCredential: string;
+    }>>;
+    proof: z.ZodOptional<z.ZodObject<{
+        type: z.ZodString;
+        created: z.ZodOptional<z.ZodString>;
+        verificationMethod: z.ZodOptional<z.ZodString>;
+        proofPurpose: z.ZodOptional<z.ZodString>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        type: z.ZodString;
+        created: z.ZodOptional<z.ZodString>;
+        verificationMethod: z.ZodOptional<z.ZodString>;
+        proofPurpose: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        type: z.ZodString;
+        created: z.ZodOptional<z.ZodString>;
+        verificationMethod: z.ZodOptional<z.ZodString>;
+        proofPurpose: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">>>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    id: z.ZodOptional<z.ZodString>;
+} & {
+    '@context': z.ZodEffects<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodAny>]>, "many">, (string | Record<string, any>)[], (string | Record<string, any>)[]>;
+    type: z.ZodEffects<z.ZodArray<z.ZodString, "many">, string[], string[]>;
+    issuer: z.ZodUnion<[z.ZodString, z.ZodObject<{
+        id: z.ZodString;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        id: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        id: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">>]>;
+    issuanceDate: z.ZodString;
+    expirationDate: z.ZodOptional<z.ZodString>;
+    credentialSubject: z.ZodObject<{
+        /** Subject DID (delegatee) */
+        id: z.ZodString;
+        /** The delegation information */
+        delegation: 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>;
+            /** 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">>;
+            /** Current status of the delegation */
+            status: z.ZodDefault<z.ZodEnum<["active", "revoked", "expired"]>>;
+            /** Timestamp when created (milliseconds since epoch) */
+            createdAt: z.ZodOptional<z.ZodNumber>;
+            /** Optional metadata */
+            metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        }, "strip", z.ZodTypeAny, {
+            status: "active" | "revoked" | "expired";
+            id: string;
+            issuerDid: string;
+            subjectDid: string;
+            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;
+            };
+            controller?: string | undefined;
+            parentId?: string | undefined;
+            createdAt?: number | undefined;
+            metadata?: Record<string, any> | undefined;
+        }, {
+            id: string;
+            issuerDid: string;
+            subjectDid: string;
+            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;
+            };
+            status?: "active" | "revoked" | "expired" | undefined;
+            controller?: string | undefined;
+            parentId?: string | undefined;
+            createdAt?: number | undefined;
+            metadata?: Record<string, any> | undefined;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        delegation: {
+            status: "active" | "revoked" | "expired";
+            id: string;
+            issuerDid: string;
+            subjectDid: string;
+            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;
+            };
+            controller?: string | undefined;
+            parentId?: string | undefined;
+            createdAt?: number | undefined;
+            metadata?: Record<string, any> | undefined;
+        };
+    }, {
+        id: string;
+        delegation: {
+            id: string;
+            issuerDid: string;
+            subjectDid: string;
+            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;
+            };
+            status?: "active" | "revoked" | "expired" | undefined;
+            controller?: string | undefined;
+            parentId?: string | undefined;
+            createdAt?: number | undefined;
+            metadata?: Record<string, any> | undefined;
+        };
+    }>;
+    credentialStatus: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"StatusList2021Entry">;
+        statusPurpose: z.ZodEnum<["revocation", "suspension"]>;
+        statusListIndex: z.ZodString;
+        statusListCredential: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: "StatusList2021Entry";
+        id: string;
+        statusPurpose: "revocation" | "suspension";
+        statusListIndex: string;
+        statusListCredential: string;
+    }, {
+        type: "StatusList2021Entry";
+        id: string;
+        statusPurpose: "revocation" | "suspension";
+        statusListIndex: string;
+        statusListCredential: string;
+    }>>;
+    proof: z.ZodOptional<z.ZodObject<{
+        type: z.ZodString;
+        created: z.ZodOptional<z.ZodString>;
+        verificationMethod: z.ZodOptional<z.ZodString>;
+        proofPurpose: z.ZodOptional<z.ZodString>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        type: z.ZodString;
+        created: z.ZodOptional<z.ZodString>;
+        verificationMethod: z.ZodOptional<z.ZodString>;
+        proofPurpose: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        type: z.ZodString;
+        created: z.ZodOptional<z.ZodString>;
+        verificationMethod: z.ZodOptional<z.ZodString>;
+        proofPurpose: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">>>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    id: z.ZodOptional<z.ZodString>;
+} & {
+    '@context': z.ZodEffects<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodAny>]>, "many">, (string | Record<string, any>)[], (string | Record<string, any>)[]>;
+    type: z.ZodEffects<z.ZodArray<z.ZodString, "many">, string[], string[]>;
+    issuer: z.ZodUnion<[z.ZodString, z.ZodObject<{
+        id: z.ZodString;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        id: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        id: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">>]>;
+    issuanceDate: z.ZodString;
+    expirationDate: z.ZodOptional<z.ZodString>;
+    credentialSubject: z.ZodObject<{
+        /** Subject DID (delegatee) */
+        id: z.ZodString;
+        /** The delegation information */
+        delegation: 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>;
+            /** 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">>;
+            /** Current status of the delegation */
+            status: z.ZodDefault<z.ZodEnum<["active", "revoked", "expired"]>>;
+            /** Timestamp when created (milliseconds since epoch) */
+            createdAt: z.ZodOptional<z.ZodNumber>;
+            /** Optional metadata */
+            metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        }, "strip", z.ZodTypeAny, {
+            status: "active" | "revoked" | "expired";
+            id: string;
+            issuerDid: string;
+            subjectDid: string;
+            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;
+            };
+            controller?: string | undefined;
+            parentId?: string | undefined;
+            createdAt?: number | undefined;
+            metadata?: Record<string, any> | undefined;
+        }, {
+            id: string;
+            issuerDid: string;
+            subjectDid: string;
+            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;
+            };
+            status?: "active" | "revoked" | "expired" | undefined;
+            controller?: string | undefined;
+            parentId?: string | undefined;
+            createdAt?: number | undefined;
+            metadata?: Record<string, any> | undefined;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        delegation: {
+            status: "active" | "revoked" | "expired";
+            id: string;
+            issuerDid: string;
+            subjectDid: string;
+            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;
+            };
+            controller?: string | undefined;
+            parentId?: string | undefined;
+            createdAt?: number | undefined;
+            metadata?: Record<string, any> | undefined;
+        };
+    }, {
+        id: string;
+        delegation: {
+            id: string;
+            issuerDid: string;
+            subjectDid: string;
+            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;
+            };
+            status?: "active" | "revoked" | "expired" | undefined;
+            controller?: string | undefined;
+            parentId?: string | undefined;
+            createdAt?: number | undefined;
+            metadata?: Record<string, any> | undefined;
+        };
+    }>;
+    credentialStatus: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"StatusList2021Entry">;
+        statusPurpose: z.ZodEnum<["revocation", "suspension"]>;
+        statusListIndex: z.ZodString;
+        statusListCredential: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: "StatusList2021Entry";
+        id: string;
+        statusPurpose: "revocation" | "suspension";
+        statusListIndex: string;
+        statusListCredential: string;
+    }, {
+        type: "StatusList2021Entry";
+        id: string;
+        statusPurpose: "revocation" | "suspension";
+        statusListIndex: string;
+        statusListCredential: string;
+    }>>;
+    proof: z.ZodOptional<z.ZodObject<{
+        type: z.ZodString;
+        created: z.ZodOptional<z.ZodString>;
+        verificationMethod: z.ZodOptional<z.ZodString>;
+        proofPurpose: z.ZodOptional<z.ZodString>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        type: z.ZodString;
+        created: z.ZodOptional<z.ZodString>;
+        verificationMethod: z.ZodOptional<z.ZodString>;
+        proofPurpose: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        type: z.ZodString;
+        created: z.ZodOptional<z.ZodString>;
+        verificationMethod: z.ZodOptional<z.ZodString>;
+        proofPurpose: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">>>;
+}, z.ZodTypeAny, "passthrough">>;
+export type DelegationCredential = z.infer<typeof DelegationCredentialSchema>;
+/**
+ * Validate a delegation credential
+ *
+ * @param credential - The delegation credential to validate
+ * @returns Validation result
+ */
+export declare function validateDelegationCredential(credential: unknown): z.SafeParseReturnType<z.objectInputType<{
+    id: z.ZodOptional<z.ZodString>;
+} & {
+    '@context': z.ZodEffects<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodAny>]>, "many">, (string | Record<string, any>)[], (string | Record<string, any>)[]>;
+    type: z.ZodEffects<z.ZodArray<z.ZodString, "many">, string[], string[]>;
+    issuer: z.ZodUnion<[z.ZodString, z.ZodObject<{
+        id: z.ZodString;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        id: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        id: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">>]>;
+    issuanceDate: z.ZodString;
+    expirationDate: z.ZodOptional<z.ZodString>;
+    credentialSubject: z.ZodObject<{
+        /** Subject DID (delegatee) */
+        id: z.ZodString;
+        /** The delegation information */
+        delegation: 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>;
+            /** 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">>;
+            /** Current status of the delegation */
+            status: z.ZodDefault<z.ZodEnum<["active", "revoked", "expired"]>>;
+            /** Timestamp when created (milliseconds since epoch) */
+            createdAt: z.ZodOptional<z.ZodNumber>;
+            /** Optional metadata */
+            metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        }, "strip", z.ZodTypeAny, {
+            status: "active" | "revoked" | "expired";
+            id: string;
+            issuerDid: string;
+            subjectDid: string;
+            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;
+            };
+            controller?: string | undefined;
+            parentId?: string | undefined;
+            createdAt?: number | undefined;
+            metadata?: Record<string, any> | undefined;
+        }, {
+            id: string;
+            issuerDid: string;
+            subjectDid: string;
+            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;
+            };
+            status?: "active" | "revoked" | "expired" | undefined;
+            controller?: string | undefined;
+            parentId?: string | undefined;
+            createdAt?: number | undefined;
+            metadata?: Record<string, any> | undefined;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        delegation: {
+            status: "active" | "revoked" | "expired";
+            id: string;
+            issuerDid: string;
+            subjectDid: string;
+            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;
+            };
+            controller?: string | undefined;
+            parentId?: string | undefined;
+            createdAt?: number | undefined;
+            metadata?: Record<string, any> | undefined;
+        };
+    }, {
+        id: string;
+        delegation: {
+            id: string;
+            issuerDid: string;
+            subjectDid: string;
+            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;
+            };
+            status?: "active" | "revoked" | "expired" | undefined;
+            controller?: string | undefined;
+            parentId?: string | undefined;
+            createdAt?: number | undefined;
+            metadata?: Record<string, any> | undefined;
+        };
+    }>;
+    credentialStatus: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"StatusList2021Entry">;
+        statusPurpose: z.ZodEnum<["revocation", "suspension"]>;
+        statusListIndex: z.ZodString;
+        statusListCredential: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: "StatusList2021Entry";
+        id: string;
+        statusPurpose: "revocation" | "suspension";
+        statusListIndex: string;
+        statusListCredential: string;
+    }, {
+        type: "StatusList2021Entry";
+        id: string;
+        statusPurpose: "revocation" | "suspension";
+        statusListIndex: string;
+        statusListCredential: string;
+    }>>;
+    proof: z.ZodOptional<z.ZodObject<{
+        type: z.ZodString;
+        created: z.ZodOptional<z.ZodString>;
+        verificationMethod: z.ZodOptional<z.ZodString>;
+        proofPurpose: z.ZodOptional<z.ZodString>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        type: z.ZodString;
+        created: z.ZodOptional<z.ZodString>;
+        verificationMethod: z.ZodOptional<z.ZodString>;
+        proofPurpose: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        type: z.ZodString;
+        created: z.ZodOptional<z.ZodString>;
+        verificationMethod: z.ZodOptional<z.ZodString>;
+        proofPurpose: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">>>;
+}, z.ZodTypeAny, "passthrough">, z.objectOutputType<{
+    id: z.ZodOptional<z.ZodString>;
+} & {
+    '@context': z.ZodEffects<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodAny>]>, "many">, (string | Record<string, any>)[], (string | Record<string, any>)[]>;
+    type: z.ZodEffects<z.ZodArray<z.ZodString, "many">, string[], string[]>;
+    issuer: z.ZodUnion<[z.ZodString, z.ZodObject<{
+        id: z.ZodString;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        id: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        id: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">>]>;
+    issuanceDate: z.ZodString;
+    expirationDate: z.ZodOptional<z.ZodString>;
+    credentialSubject: z.ZodObject<{
+        /** Subject DID (delegatee) */
+        id: z.ZodString;
+        /** The delegation information */
+        delegation: 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>;
+            /** 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">>;
+            /** Current status of the delegation */
+            status: z.ZodDefault<z.ZodEnum<["active", "revoked", "expired"]>>;
+            /** Timestamp when created (milliseconds since epoch) */
+            createdAt: z.ZodOptional<z.ZodNumber>;
+            /** Optional metadata */
+            metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        }, "strip", z.ZodTypeAny, {
+            status: "active" | "revoked" | "expired";
+            id: string;
+            issuerDid: string;
+            subjectDid: string;
+            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;
+            };
+            controller?: string | undefined;
+            parentId?: string | undefined;
+            createdAt?: number | undefined;
+            metadata?: Record<string, any> | undefined;
+        }, {
+            id: string;
+            issuerDid: string;
+            subjectDid: string;
+            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;
+            };
+            status?: "active" | "revoked" | "expired" | undefined;
+            controller?: string | undefined;
+            parentId?: string | undefined;
+            createdAt?: number | undefined;
+            metadata?: Record<string, any> | undefined;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        delegation: {
+            status: "active" | "revoked" | "expired";
+            id: string;
+            issuerDid: string;
+            subjectDid: string;
+            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;
+            };
+            controller?: string | undefined;
+            parentId?: string | undefined;
+            createdAt?: number | undefined;
+            metadata?: Record<string, any> | undefined;
+        };
+    }, {
+        id: string;
+        delegation: {
+            id: string;
+            issuerDid: string;
+            subjectDid: string;
+            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;
+            };
+            status?: "active" | "revoked" | "expired" | undefined;
+            controller?: string | undefined;
+            parentId?: string | undefined;
+            createdAt?: number | undefined;
+            metadata?: Record<string, any> | undefined;
+        };
+    }>;
+    credentialStatus: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"StatusList2021Entry">;
+        statusPurpose: z.ZodEnum<["revocation", "suspension"]>;
+        statusListIndex: z.ZodString;
+        statusListCredential: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: "StatusList2021Entry";
+        id: string;
+        statusPurpose: "revocation" | "suspension";
+        statusListIndex: string;
+        statusListCredential: string;
+    }, {
+        type: "StatusList2021Entry";
+        id: string;
+        statusPurpose: "revocation" | "suspension";
+        statusListIndex: string;
+        statusListCredential: string;
+    }>>;
+    proof: z.ZodOptional<z.ZodObject<{
+        type: z.ZodString;
+        created: z.ZodOptional<z.ZodString>;
+        verificationMethod: z.ZodOptional<z.ZodString>;
+        proofPurpose: z.ZodOptional<z.ZodString>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        type: z.ZodString;
+        created: z.ZodOptional<z.ZodString>;
+        verificationMethod: z.ZodOptional<z.ZodString>;
+        proofPurpose: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        type: z.ZodString;
+        created: z.ZodOptional<z.ZodString>;
+        verificationMethod: z.ZodOptional<z.ZodString>;
+        proofPurpose: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">>>;
+}, z.ZodTypeAny, "passthrough">>;
+/**
+ * Extract DelegationRecord from DelegationCredential
+ *
+ * Utility to extract the legacy DelegationRecord format from a W3C VC.
+ * Useful for backward compatibility and internal processing.
+ *
+ * @param vc - The delegation credential
+ * @returns DelegationRecord
+ */
+export declare function extractDelegationFromVC(vc: DelegationCredential): DelegationRecord;
+/**
+ * Create DelegationCredential from DelegationRecord (unsigned)
+ *
+ * Wraps a DelegationRecord in a W3C VC structure (without proof).
+ * The caller must sign this to create a valid DelegationCredential.
+ *
+ * @param delegation - The delegation record
+ * @param options - Optional VC options (id, issuanceDate, etc.)
+ * @returns Unsigned DelegationCredential
+ */
+export declare function wrapDelegationAsVC(delegation: DelegationRecord, options?: {
+    id?: string;
+    issuanceDate?: string;
+    expirationDate?: string;
+    credentialStatus?: z.infer<typeof CredentialStatusSchema>;
+}): Omit<DelegationCredential, 'proof'>;
+/**
+ * Check if a delegation credential is expired
+ *
+ * @param vc - The delegation credential
+ * @returns true if expired
+ */
+export declare function isDelegationCredentialExpired(vc: DelegationCredential): boolean;
+/**
+ * Check if a delegation credential is not yet valid
+ *
+ * @param vc - The delegation credential
+ * @returns true if not yet valid
+ */
+export declare function isDelegationCredentialNotYetValid(vc: DelegationCredential): boolean;
 //# sourceMappingURL=schemas.d.ts.map