@tinycloud/sdk-core 2.11.0-beta.9 → 2.11.0

package/dist/unified-BlXXf3l7.d.cts

@@ -0,0 +1,429 @@
+import { a as JsonValue } from './capability-BjzXwtNw.cjs';
+import { z } from 'zod';
+
+type SignedObjectErrorCode = "schema-invalid" | "canonicalization-mismatch" | "digest-mismatch" | "id-mismatch" | "signing-key-binding" | "signature-material-invalid" | "signature-suite-unsupported" | "signature-invalid";
+declare class SignedObjectProfileError extends Error {
+    readonly code: SignedObjectErrorCode;
+    constructor(code: SignedObjectErrorCode, message: string);
+}
+declare class SignedObjectSchemaError extends SignedObjectProfileError {
+    constructor(message: string);
+}
+declare class SignedObjectCanonicalizationError extends SignedObjectProfileError {
+    constructor(message: string);
+}
+declare class SignedObjectDigestError extends SignedObjectProfileError {
+    constructor(message: string);
+}
+declare class SignedObjectIdError extends SignedObjectProfileError {
+    constructor(message: string);
+}
+declare class SigningKeyBindingError extends SignedObjectProfileError {
+    constructor(message: string);
+}
+declare class SignatureMaterialError extends SignedObjectProfileError {
+    constructor(message: string);
+}
+declare class UnsupportedSignatureSuiteError extends SignedObjectProfileError {
+    constructor(message: string);
+}
+declare class SignatureVerificationError extends SignedObjectProfileError {
+    constructor(message: string);
+}
+declare function toSignedObjectError(error: unknown): SignedObjectProfileError;
+
+declare const POLICY_SCHEMA = "xyz.tinycloud.policy/policy/v0";
+declare const POLICY_STATUS_SCHEMA = "xyz.tinycloud.policy/status/v0";
+declare const POLICY_ENGINE_RECORD_SCHEMA = "xyz.tinycloud.policy/engine-record/v0";
+declare const ED25519_JCS_SIGNATURE_SUITE = "eddsa-ed25519-sha256-jcs-v1";
+declare const EIP191_JCS_SIGNATURE_SUITE = "eip191-secp256k1-sha256-jcs-v1";
+type SignedObjectKind = "Policy" | "PolicyStatus" | "PolicyEngineRecord";
+type SignatureSuite = typeof ED25519_JCS_SIGNATURE_SUITE | typeof EIP191_JCS_SIGNATURE_SUITE;
+interface SignedObjectSignature {
+    suite: SignatureSuite;
+    signerDid: string;
+    value: string;
+}
+type JsonObject = {
+    readonly [key: string]: JsonValue;
+};
+interface Policy {
+    readonly schema: typeof POLICY_SCHEMA;
+    readonly policyId: string;
+    readonly ownerDid: string;
+    readonly signingKeyDid: string;
+    readonly createdAt: string;
+    readonly expiresAt?: string;
+    readonly resource: JsonObject;
+    readonly when: JsonObject;
+    readonly grant: JsonObject;
+    readonly disclosure?: JsonObject;
+    readonly audit?: JsonObject;
+    readonly signature: SignedObjectSignature;
+}
+type UnsignedPolicy = Omit<Policy, "policyId" | "signature">;
+interface PolicyStatus {
+    readonly schema: typeof POLICY_STATUS_SCHEMA;
+    readonly statusId: string;
+    readonly policyId: string;
+    readonly ownerDid: string;
+    readonly sequence: number;
+    readonly disposition: "active" | "suspended" | "revoked";
+    readonly effectiveAt: string;
+    readonly reasonCode?: string;
+    readonly signingKeyDid: string;
+    readonly signature: SignedObjectSignature;
+}
+type UnsignedPolicyStatus = Omit<PolicyStatus, "statusId" | "signature">;
+interface PolicyEngineRecord {
+    readonly schema: typeof POLICY_ENGINE_RECORD_SCHEMA;
+    readonly engineRecordId: string;
+    readonly ownerDid: string;
+    readonly endpoint: string;
+    readonly audience: string;
+    readonly supportedPolicyVersions: string[];
+    readonly supportedEvidenceVerifiers: string[];
+    readonly grantIssuerDid: string;
+    readonly expiresAt: string;
+    readonly signature: SignedObjectSignature;
+}
+type UnsignedPolicyEngineRecord = Omit<PolicyEngineRecord, "engineRecordId" | "signature">;
+type SignedPolicyObject = Policy | PolicyStatus | PolicyEngineRecord;
+type UnsignedPolicyObject = UnsignedPolicy | UnsignedPolicyStatus | UnsignedPolicyEngineRecord;
+interface SignedObjectSigner {
+    readonly suite: SignatureSuite;
+    readonly signerDid: string;
+    signDigest(digest: Uint8Array): Promise<Uint8Array | string> | Uint8Array | string;
+}
+interface SignedObjectMaterial {
+    readonly kind: SignedObjectKind;
+    readonly idField: string;
+    readonly id: string;
+    readonly domain: string;
+    readonly unsigned: JsonObject;
+    readonly jcs: string;
+    readonly jcsBytes: Uint8Array;
+    readonly digest: Uint8Array;
+    readonly digestHex: string;
+}
+type SignedObjectVerificationResult<T extends SignedPolicyObject> = {
+    readonly ok: true;
+    readonly object: T;
+    readonly material: SignedObjectMaterial;
+} | {
+    readonly ok: false;
+    readonly error: SignedObjectProfileError;
+};
+declare function canonicalizeSignedObjectUnsigned(input: unknown): string;
+declare function deriveSignedObjectMaterial(input: unknown): SignedObjectMaterial;
+declare function signedObjectIdFor(input: unknown): string;
+declare function createAndSignSignedObject(input: unknown, signer: SignedObjectSigner): Promise<SignedPolicyObject>;
+declare function createAndSignPolicy(input: unknown, signer: SignedObjectSigner): Promise<Policy>;
+declare function createAndSignPolicyStatus(input: unknown, signer: SignedObjectSigner): Promise<PolicyStatus>;
+declare function createAndSignPolicyEngineRecord(input: unknown, signer: SignedObjectSigner): Promise<PolicyEngineRecord>;
+declare function verifySignedObject(input: unknown): Promise<{
+    object: SignedPolicyObject;
+    material: SignedObjectMaterial;
+}>;
+declare function verifyPolicy(input: unknown): Promise<{
+    object: Policy;
+    material: SignedObjectMaterial;
+}>;
+declare function verifyPolicyStatus(input: unknown): Promise<{
+    object: PolicyStatus;
+    material: SignedObjectMaterial;
+}>;
+declare function verifyPolicyEngineRecord(input: unknown): Promise<{
+    object: PolicyEngineRecord;
+    material: SignedObjectMaterial;
+}>;
+declare function validatePolicySigned(input: unknown): Promise<SignedObjectVerificationResult<Policy>>;
+declare function validatePolicyStatusSigned(input: unknown): Promise<SignedObjectVerificationResult<PolicyStatus>>;
+declare function validatePolicyEngineRecordSigned(input: unknown): Promise<SignedObjectVerificationResult<PolicyEngineRecord>>;
+declare function validatePolicyUnsigned(input: unknown): UnsignedPolicy;
+declare function validatePolicyStatusUnsigned(input: unknown): UnsignedPolicyStatus;
+declare function validatePolicyEngineRecordUnsigned(input: unknown): UnsignedPolicyEngineRecord;
+declare function validatePolicySignedShape(input: unknown): Policy;
+declare function validatePolicyStatusSignedShape(input: unknown): PolicyStatus;
+declare function validatePolicyEngineRecordSignedShape(input: unknown): PolicyEngineRecord;
+
+declare const POLICY_V1_SCHEMA: "xyz.tinycloud.policy/policy/v1";
+declare const POLICY_CAPABILITY_V1_SCHEMA: "xyz.tinycloud.policy/capability/v1";
+declare const POLICY_ENFORCEMENT_DELEGATION_V2_SCHEMA: "xyz.tinycloud.policy/enforcement-delegation/v2";
+declare const ATTESTED_ENFORCER_BINDING_V2_SCHEMA: "xyz.tinycloud.policy/attested-enforcer/v2";
+declare const ROOT_STATUS_CHECKPOINT_V1_SCHEMA: "xyz.tinycloud.policy/root-status/v1";
+declare const ROOT_REVOCATION_V1_SCHEMA: "xyz.tinycloud.policy/root-revocation/v1";
+declare const POLICY_SESSION_UCAN_V1_PROFILE: "policy-session-ucan/v1";
+declare const POLICY_V1_DOMAIN = "xyz.tinycloud.policy/policy/v1\0";
+declare const POLICY_CAPABILITY_V1_DOMAIN = "xyz.tinycloud.policy/PolicyCapability/v1\0";
+declare const CONTENT_SOURCE_V1_DOMAIN = "xyz.tinycloud.policy/ContentSource/v1\0";
+declare const NATIVE_PROJECTION_V1_DOMAIN = "xyz.tinycloud.policy/NativeProjection/v1\0";
+declare const ROOT_STATUS_V1_DOMAIN = "xyz.tinycloud.policy/RootStatusCheckpoint/v1\0";
+declare const ROOT_STATUS_RENEWAL_V1_DOMAIN = "xyz.tinycloud.policy/RootStatusRenewal/v1\0";
+declare const ROOT_REVOCATION_V1_DOMAIN = "xyz.tinycloud.policy/RootRevocation/v1\0";
+declare const LAST_V2_CREATE_AT: "2026-09-30T00:00:00Z";
+declare const MAX_LEGACY_ENVELOPE_EXPIRES_AT: "2026-12-29T00:00:00Z";
+declare const LAST_V2_READ_AT: "2027-01-05T00:00:00Z";
+type UnifiedResourceSelector = "exact" | "prefix";
+interface UnifiedKvCapability {
+    readonly kind: "kv";
+    readonly resource: string;
+    readonly selector: UnifiedResourceSelector;
+    readonly actions: readonly ("tinycloud.kv/get" | "tinycloud.kv/list" | "tinycloud.kv/metadata" | "tinycloud.kv/put")[];
+}
+interface UnifiedEncryptionCapability {
+    readonly kind: "encryption";
+    readonly resource: string;
+    readonly action: "tinycloud.encryption/decrypt";
+}
+type UnifiedPolicyCapability = UnifiedKvCapability | UnifiedEncryptionCapability;
+interface UnifiedNativeCapability {
+    readonly service: "tinycloud.kv" | "tinycloud.encryption";
+    readonly space: string;
+    readonly path: string;
+    readonly actions: readonly string[];
+    readonly caveat?: Readonly<Record<string, string>>;
+}
+interface UnifiedContentSource {
+    readonly shareId: string;
+    readonly kvResource: string;
+    readonly selector: UnifiedResourceSelector;
+    readonly encryptionNetwork: string;
+    readonly encryptedSymmetricKeyDigestHex: string;
+    readonly keyVersion: number;
+    readonly mode: "mutable" | "immutable";
+    readonly initialCiphertextDigestHex?: string;
+}
+interface UnifiedPolicyV1 {
+    readonly schema: typeof POLICY_V1_SCHEMA;
+    readonly policyId: string;
+    readonly ownerDid: string;
+    readonly createdAt: string;
+    readonly expiresAt?: string;
+    readonly contentSource: UnifiedContentSource;
+    readonly capabilityCeiling: readonly UnifiedPolicyCapability[];
+    readonly signature: {
+        readonly suite: string;
+        readonly signerDid: string;
+        readonly value: string;
+    };
+}
+interface PolicySessionUcanV1 {
+    readonly authorization: string;
+    readonly cid: string;
+    readonly iss: string;
+    readonly aud: string;
+    readonly prf: readonly [string, string];
+    readonly att: Readonly<Record<string, Readonly<Record<string, readonly unknown[]>>>>;
+    readonly nbf: number;
+    readonly exp: number;
+    readonly nnc: string;
+    readonly fact: Readonly<Record<string, unknown>>;
+}
+interface PolicyChallengeV3 {
+    readonly challengeId: string;
+    readonly nonce: string;
+    readonly policyCid: string;
+    readonly recipientDid: string;
+    readonly [key: string]: unknown;
+}
+declare function requestPolicyChallengeV3(input: {
+    readonly nodeOrigin: string;
+    readonly policyCid: string;
+    readonly recipientDid: string;
+    readonly requestedCapabilities: readonly UnifiedPolicyCapability[];
+    readonly fetch?: typeof fetch;
+}): Promise<PolicyChallengeV3>;
+declare function mintPolicySessionV3(input: {
+    readonly nodeOrigin: string;
+    readonly policyCid: string;
+    readonly policyRootCid: string;
+    readonly enforcementRootCid: string;
+    readonly recipientDid: string;
+    readonly requestedCapabilities: readonly UnifiedPolicyCapability[];
+    readonly expectedFacts?: Readonly<Record<string, string | number>>;
+    readonly claim: Readonly<Record<string, unknown>>;
+    readonly presentation: Readonly<Record<string, unknown>>;
+    readonly challenge?: PolicyChallengeV3;
+    readonly fetch?: typeof fetch;
+}): Promise<PolicySessionUcanV1>;
+interface PolicyRootStatusV3 {
+    readonly rootCid: string;
+    readonly state: "active" | "revoked";
+    readonly checkpoint: Readonly<Record<string, unknown>>;
+    readonly revocation?: Readonly<Record<string, unknown>>;
+}
+declare function verifyPolicyRootStatusCheckpointV3(input: {
+    readonly rootCid: string;
+    readonly checkpoint: Readonly<Record<string, unknown>>;
+    readonly expectedNodeAudience?: string;
+    readonly now?: Date;
+}): boolean;
+declare function getPolicyRootStatusV3(input: {
+    readonly nodeOrigin: string;
+    readonly rootCid: string;
+    readonly expectedNodeAudience?: string;
+    readonly expectedEnforcerDid?: string;
+    readonly now?: Date;
+    readonly fetch?: typeof fetch;
+}): Promise<PolicyRootStatusV3>;
+declare function verifyPolicyRootRevocationV3(input: {
+    readonly rootCid: string;
+    readonly checkpoint: Readonly<Record<string, unknown>>;
+    readonly revocation: Readonly<Record<string, unknown>>;
+    readonly expectedEnforcerDid?: string;
+}): boolean;
+declare function renewPolicyRootStatusV3(input: {
+    readonly nodeOrigin: string;
+    readonly rootCid: string;
+    readonly ownerDid: string;
+    readonly nodeAudience: string;
+    readonly sign: (digest: Uint8Array) => Promise<Uint8Array>;
+    readonly now?: Date;
+    readonly nonce?: string;
+    readonly fetch?: typeof fetch;
+}): Promise<Readonly<Record<string, unknown>>>;
+declare function revokePolicyRootV3(input: {
+    readonly nodeOrigin: string;
+    readonly rootCid: string;
+    readonly targetRole: "policy-authority" | "policy-enforcement";
+    readonly ownerDid: string;
+    readonly issuerDid: string;
+    readonly nodeAudience: string;
+    readonly reason: string;
+    readonly sign: (digest: Uint8Array) => Promise<Uint8Array>;
+    readonly now?: Date;
+    readonly fetch?: typeof fetch;
+}): Promise<Readonly<Record<string, unknown>>>;
+declare function normalizeUnifiedPolicyCapability(input: unknown): UnifiedPolicyCapability;
+declare function canonicalizeUnifiedPolicyCapability(input: unknown): UnifiedPolicyCapability;
+declare function unifiedPolicyCapabilityDigestHex(input: unknown): string;
+declare function unifiedPolicyCapabilityContains(authorityInput: unknown, requestedInput: unknown): boolean;
+declare function projectUnifiedPolicyCapability(input: unknown): UnifiedNativeCapability;
+declare function projectUnifiedPolicyCapabilities(input: readonly unknown[]): UnifiedNativeCapability[];
+declare function unifiedNativeProjectionHashHex(input: readonly unknown[]): string;
+declare function unifiedPolicyCapabilityFromNative(input: unknown): UnifiedPolicyCapability;
+declare function contentSourceDigestHex(input: UnifiedContentSource): string;
+declare function policyDigestHex(policy: Omit<UnifiedPolicyV1, "policyId" | "signature">): string;
+declare function policyIdForDigestHex(digestHex: string): string;
+declare function policyCidFromCanonicalBytes(bytes: Uint8Array): string;
+declare const CompactHeaderSchema: z.ZodObject<{
+    alg: z.ZodLiteral<"EdDSA">;
+    jwk: z.ZodObject<{
+        alg: z.ZodLiteral<"EdDSA">;
+        crv: z.ZodLiteral<"Ed25519">;
+        kty: z.ZodLiteral<"OKP">;
+        x: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        alg: "EdDSA";
+        kty: "OKP";
+        crv: "Ed25519";
+        x: string;
+    }, {
+        alg: "EdDSA";
+        kty: "OKP";
+        crv: "Ed25519";
+        x: string;
+    }>;
+    typ: z.ZodLiteral<"JWT">;
+    ucv: z.ZodLiteral<"0.10.0">;
+}, "strict", z.ZodTypeAny, {
+    alg: "EdDSA";
+    jwk: {
+        alg: "EdDSA";
+        kty: "OKP";
+        crv: "Ed25519";
+        x: string;
+    };
+    typ: "JWT";
+    ucv: "0.10.0";
+}, {
+    alg: "EdDSA";
+    jwk: {
+        alg: "EdDSA";
+        kty: "OKP";
+        crv: "Ed25519";
+        x: string;
+    };
+    typ: "JWT";
+    ucv: "0.10.0";
+}>;
+declare const CompactPayloadSchema: z.ZodObject<{
+    att: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodArray<z.ZodUnknown, "many">>>;
+    aud: z.ZodString;
+    exp: z.ZodNumber;
+    fct: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>, "many">;
+    iss: z.ZodString;
+    nbf: z.ZodNumber;
+    nnc: z.ZodString;
+    prf: z.ZodArray<z.ZodString, "many">;
+}, "strict", z.ZodTypeAny, {
+    iss: string;
+    nbf: number;
+    exp: number;
+    att: Record<string, Record<string, unknown[]>>;
+    aud: string;
+    fct: Record<string, unknown>[];
+    nnc: string;
+    prf: string[];
+}, {
+    iss: string;
+    nbf: number;
+    exp: number;
+    att: Record<string, Record<string, unknown[]>>;
+    aud: string;
+    fct: Record<string, unknown>[];
+    nnc: string;
+    prf: string[];
+}>;
+interface CompactUcanAuthorizationV1 {
+    readonly authorization: string;
+    readonly cid: string;
+    readonly header: z.infer<typeof CompactHeaderSchema>;
+    readonly payload: z.infer<typeof CompactPayloadSchema>;
+}
+interface SignCompactUcanAuthorizationInput {
+    readonly issuerDid: string;
+    readonly audienceDid: string;
+    readonly attenuation: Readonly<Record<string, Readonly<Record<string, readonly unknown[]>>>>;
+    readonly facts: readonly [Readonly<Record<string, unknown>>];
+    readonly proofs: readonly string[];
+    readonly notBefore: number;
+    readonly expiresAt: number;
+    readonly nonce: string;
+    readonly sign: (bytes: Uint8Array) => Promise<Uint8Array>;
+}
+/** Sign exact compact-UCAN bytes with a caller-owned, potentially non-extractable key. */
+declare function signCompactUcanAuthorization(input: SignCompactUcanAuthorizationInput): Promise<CompactUcanAuthorizationV1>;
+interface CompactPolicyInvocationInput {
+    readonly sessionAuthorization: string;
+    readonly sessionCid: string;
+    readonly recipientDid: string;
+    readonly audienceDid: string;
+    readonly resource: string;
+    readonly action: string;
+    readonly caveat?: Readonly<Record<string, unknown>>;
+    readonly facts?: Readonly<Record<string, unknown>>;
+    readonly privateKey: Uint8Array;
+    readonly now?: number;
+    readonly nonce?: string;
+}
+/** Sign a fresh one-parent ordinary invocation; S0 itself is never a bearer. */
+declare function createCompactPolicyInvocation(input: CompactPolicyInvocationInput): CompactUcanAuthorizationV1;
+declare function createCompactPolicyDescendant(input: {
+    readonly parentAuthorization: string;
+    readonly parentCid: string;
+    readonly issuerDid: string;
+    readonly audienceDid: string;
+    readonly attenuation: Readonly<Record<string, Readonly<Record<string, readonly unknown[]>>>>;
+    readonly privateKey: Uint8Array;
+    readonly now?: number;
+    readonly expiresAt?: number;
+    readonly nonce?: string;
+}): CompactUcanAuthorizationV1;
+/** Byte-independent semantic containment shared by S0, descendants and mint requests. */
+declare function compactAttenuationContains(parent: Readonly<Record<string, Readonly<Record<string, readonly unknown[]>>>>, child: Readonly<Record<string, Readonly<Record<string, readonly unknown[]>>>>): boolean;
+declare function parseCompactUcanAuthorization(input: string, expectedCid?: string): CompactUcanAuthorizationV1;
+declare function parsePolicySessionUcan(authorization: string, expectedProofs?: readonly [string, string]): PolicySessionUcanV1;
+
+export { type UnifiedPolicyCapability as $, ATTESTED_ENFORCER_BINDING_V2_SCHEMA as A, SignedObjectCanonicalizationError as B, CONTENT_SOURCE_V1_DOMAIN as C, SignedObjectDigestError as D, ED25519_JCS_SIGNATURE_SUITE as E, type SignedObjectErrorCode as F, SignedObjectIdError as G, type SignedObjectKind as H, type SignedObjectMaterial as I, type JsonObject as J, SignedObjectProfileError as K, LAST_V2_CREATE_AT as L, MAX_LEGACY_ENVELOPE_EXPIRES_AT as M, NATIVE_PROJECTION_V1_DOMAIN as N, SignedObjectSchemaError as O, type PolicyEngineRecord as P, type SignedObjectSignature as Q, ROOT_REVOCATION_V1_DOMAIN as R, type SignedObjectSigner as S, type SignedObjectVerificationResult as T, type UnsignedPolicyEngineRecord as U, type SignedPolicyObject as V, SigningKeyBindingError as W, type UnifiedContentSource as X, type UnifiedEncryptionCapability as Y, type UnifiedKvCapability as Z, type UnifiedNativeCapability as _, type Policy as a, type UnifiedPolicyV1 as a0, type UnifiedResourceSelector as a1, type UnsignedPolicy as a2, type UnsignedPolicyObject as a3, type UnsignedPolicyStatus as a4, UnsupportedSignatureSuiteError as a5, canonicalizeSignedObjectUnsigned as a6, canonicalizeUnifiedPolicyCapability as a7, compactAttenuationContains as a8, contentSourceDigestHex as a9, unifiedPolicyCapabilityFromNative as aA, validatePolicyEngineRecordSigned as aB, validatePolicyEngineRecordSignedShape as aC, validatePolicyEngineRecordUnsigned as aD, validatePolicySigned as aE, validatePolicySignedShape as aF, validatePolicyStatusSigned as aG, validatePolicyStatusSignedShape as aH, validatePolicyStatusUnsigned as aI, validatePolicyUnsigned as aJ, verifyPolicy as aK, verifyPolicyEngineRecord as aL, verifyPolicyRootRevocationV3 as aM, verifyPolicyRootStatusCheckpointV3 as aN, verifyPolicyStatus as aO, verifySignedObject as aP, createAndSignPolicy as aa, createAndSignPolicyEngineRecord as ab, createAndSignPolicyStatus as ac, createAndSignSignedObject as ad, createCompactPolicyDescendant as ae, createCompactPolicyInvocation as af, deriveSignedObjectMaterial as ag, getPolicyRootStatusV3 as ah, mintPolicySessionV3 as ai, normalizeUnifiedPolicyCapability as aj, parseCompactUcanAuthorization as ak, parsePolicySessionUcan as al, policyCidFromCanonicalBytes as am, policyDigestHex as an, policyIdForDigestHex as ao, projectUnifiedPolicyCapabilities as ap, projectUnifiedPolicyCapability as aq, renewPolicyRootStatusV3 as ar, requestPolicyChallengeV3 as as, revokePolicyRootV3 as at, signCompactUcanAuthorization as au, signedObjectIdFor as av, toSignedObjectError as aw, unifiedNativeProjectionHashHex as ax, unifiedPolicyCapabilityContains as ay, unifiedPolicyCapabilityDigestHex as az, type CompactPolicyInvocationInput as b, type CompactUcanAuthorizationV1 as c, EIP191_JCS_SIGNATURE_SUITE as d, LAST_V2_READ_AT as e, POLICY_CAPABILITY_V1_DOMAIN as f, POLICY_CAPABILITY_V1_SCHEMA as g, POLICY_ENFORCEMENT_DELEGATION_V2_SCHEMA as h, POLICY_ENGINE_RECORD_SCHEMA as i, POLICY_SCHEMA as j, POLICY_SESSION_UCAN_V1_PROFILE as k, POLICY_STATUS_SCHEMA as l, POLICY_V1_DOMAIN as m, POLICY_V1_SCHEMA as n, type PolicyChallengeV3 as o, type PolicyRootStatusV3 as p, type PolicySessionUcanV1 as q, type PolicyStatus as r, ROOT_REVOCATION_V1_SCHEMA as s, ROOT_STATUS_CHECKPOINT_V1_SCHEMA as t, ROOT_STATUS_RENEWAL_V1_DOMAIN as u, ROOT_STATUS_V1_DOMAIN as v, type SignCompactUcanAuthorizationInput as w, SignatureMaterialError as x, type SignatureSuite as y, SignatureVerificationError as z };