@peac/schema 0.9.18

package/dist/validators.d.ts

@@ -0,0 +1,656 @@
+/**
+ * Zod validators for PEAC protocol types
+ */
+import { z } from 'zod';
+export declare const NormalizedPayment: z.ZodObject<{
+    rail: z.ZodString;
+    reference: z.ZodString;
+    amount: z.ZodNumber;
+    currency: z.ZodString;
+    asset: z.ZodOptional<z.ZodString>;
+    env: z.ZodOptional<z.ZodString>;
+    evidence: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strict", z.ZodTypeAny, {
+    rail: string;
+    reference: string;
+    amount: number;
+    currency: string;
+    asset?: string | undefined;
+    env?: string | undefined;
+    evidence?: Record<string, unknown> | undefined;
+    metadata?: Record<string, unknown> | undefined;
+}, {
+    rail: string;
+    reference: string;
+    amount: number;
+    currency: string;
+    asset?: string | undefined;
+    env?: string | undefined;
+    evidence?: Record<string, unknown> | undefined;
+    metadata?: Record<string, unknown> | undefined;
+}>;
+export declare const Subject: z.ZodObject<{
+    uri: z.ZodEffects<z.ZodString, string, string>;
+}, "strict", z.ZodTypeAny, {
+    uri: string;
+}, {
+    uri: string;
+}>;
+export declare const AIPREFSnapshot: z.ZodObject<{
+    url: z.ZodEffects<z.ZodString, string, string>;
+    hash: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    url: string;
+    hash: string;
+}, {
+    url: string;
+    hash: string;
+}>;
+export declare const Extensions: z.ZodObject<{
+    aipref_snapshot: z.ZodOptional<z.ZodObject<{
+        url: z.ZodEffects<z.ZodString, string, string>;
+        hash: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        url: string;
+        hash: string;
+    }, {
+        url: string;
+        hash: string;
+    }>>;
+}, "strip", z.ZodUnknown, z.objectOutputType<{
+    aipref_snapshot: z.ZodOptional<z.ZodObject<{
+        url: z.ZodEffects<z.ZodString, string, string>;
+        hash: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        url: string;
+        hash: string;
+    }, {
+        url: string;
+        hash: string;
+    }>>;
+}, z.ZodUnknown, "strip">, z.objectInputType<{
+    aipref_snapshot: z.ZodOptional<z.ZodObject<{
+        url: z.ZodEffects<z.ZodString, string, string>;
+        hash: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        url: string;
+        hash: string;
+    }, {
+        url: string;
+        hash: string;
+    }>>;
+}, z.ZodUnknown, "strip">>;
+export declare const JWSHeader: z.ZodObject<{
+    typ: z.ZodLiteral<"peac.receipt/0.9">;
+    alg: z.ZodLiteral<"EdDSA">;
+    kid: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    typ: "peac.receipt/0.9";
+    alg: "EdDSA";
+    kid: string;
+}, {
+    typ: "peac.receipt/0.9";
+    alg: "EdDSA";
+    kid: string;
+}>;
+export declare const ReceiptClaims: z.ZodObject<{
+    iss: z.ZodEffects<z.ZodString, string, string>;
+    aud: z.ZodEffects<z.ZodString, string, string>;
+    iat: z.ZodNumber;
+    exp: z.ZodOptional<z.ZodNumber>;
+    rid: z.ZodString;
+    amt: z.ZodNumber;
+    cur: z.ZodString;
+    payment: z.ZodObject<{
+        rail: z.ZodString;
+        reference: z.ZodString;
+        amount: z.ZodNumber;
+        currency: z.ZodString;
+        asset: z.ZodOptional<z.ZodString>;
+        env: z.ZodOptional<z.ZodString>;
+        evidence: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strict", z.ZodTypeAny, {
+        rail: string;
+        reference: string;
+        amount: number;
+        currency: string;
+        asset?: string | undefined;
+        env?: string | undefined;
+        evidence?: Record<string, unknown> | undefined;
+        metadata?: Record<string, unknown> | undefined;
+    }, {
+        rail: string;
+        reference: string;
+        amount: number;
+        currency: string;
+        asset?: string | undefined;
+        env?: string | undefined;
+        evidence?: Record<string, unknown> | undefined;
+        metadata?: Record<string, unknown> | undefined;
+    }>;
+    subject: z.ZodOptional<z.ZodObject<{
+        uri: z.ZodEffects<z.ZodString, string, string>;
+    }, "strict", z.ZodTypeAny, {
+        uri: string;
+    }, {
+        uri: string;
+    }>>;
+    ext: z.ZodOptional<z.ZodObject<{
+        aipref_snapshot: z.ZodOptional<z.ZodObject<{
+            url: z.ZodEffects<z.ZodString, string, string>;
+            hash: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            url: string;
+            hash: string;
+        }, {
+            url: string;
+            hash: string;
+        }>>;
+    }, "strip", z.ZodUnknown, z.objectOutputType<{
+        aipref_snapshot: z.ZodOptional<z.ZodObject<{
+            url: z.ZodEffects<z.ZodString, string, string>;
+            hash: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            url: string;
+            hash: string;
+        }, {
+            url: string;
+            hash: string;
+        }>>;
+    }, z.ZodUnknown, "strip">, z.objectInputType<{
+        aipref_snapshot: z.ZodOptional<z.ZodObject<{
+            url: z.ZodEffects<z.ZodString, string, string>;
+            hash: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            url: string;
+            hash: string;
+        }, {
+            url: string;
+            hash: string;
+        }>>;
+    }, z.ZodUnknown, "strip">>>;
+}, "strict", z.ZodTypeAny, {
+    iss: string;
+    aud: string;
+    iat: number;
+    rid: string;
+    amt: number;
+    cur: string;
+    payment: {
+        rail: string;
+        reference: string;
+        amount: number;
+        currency: string;
+        asset?: string | undefined;
+        env?: string | undefined;
+        evidence?: Record<string, unknown> | undefined;
+        metadata?: Record<string, unknown> | undefined;
+    };
+    exp?: number | undefined;
+    subject?: {
+        uri: string;
+    } | undefined;
+    ext?: z.objectOutputType<{
+        aipref_snapshot: z.ZodOptional<z.ZodObject<{
+            url: z.ZodEffects<z.ZodString, string, string>;
+            hash: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            url: string;
+            hash: string;
+        }, {
+            url: string;
+            hash: string;
+        }>>;
+    }, z.ZodUnknown, "strip"> | undefined;
+}, {
+    iss: string;
+    aud: string;
+    iat: number;
+    rid: string;
+    amt: number;
+    cur: string;
+    payment: {
+        rail: string;
+        reference: string;
+        amount: number;
+        currency: string;
+        asset?: string | undefined;
+        env?: string | undefined;
+        evidence?: Record<string, unknown> | undefined;
+        metadata?: Record<string, unknown> | undefined;
+    };
+    exp?: number | undefined;
+    subject?: {
+        uri: string;
+    } | undefined;
+    ext?: z.objectInputType<{
+        aipref_snapshot: z.ZodOptional<z.ZodObject<{
+            url: z.ZodEffects<z.ZodString, string, string>;
+            hash: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            url: string;
+            hash: string;
+        }, {
+            url: string;
+            hash: string;
+        }>>;
+    }, z.ZodUnknown, "strip"> | undefined;
+}>;
+export declare const VerifyRequest: z.ZodObject<{
+    receipt_jws: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    receipt_jws: string;
+}, {
+    receipt_jws: string;
+}>;
+/**
+ * Control purpose - what the access is for
+ *
+ * v0.9.17+: Added ai_input, search for RSL alignment
+ * v0.9.18+: Added ai_index (RSL 1.0 canonical token). Removed ai_search.
+ *
+ * @see https://rslstandard.org/rsl for RSL 1.0 specification
+ */
+export declare const ControlPurposeSchema: z.ZodEnum<["crawl", "index", "train", "inference", "ai_input", "ai_index", "search"]>;
+/**
+ * Control licensing mode - how access is licensed
+ */
+export declare const ControlLicensingModeSchema: z.ZodEnum<["subscription", "pay_per_crawl", "pay_per_inference"]>;
+/**
+ * Control decision type
+ */
+export declare const ControlDecisionSchema: z.ZodEnum<["allow", "deny", "review"]>;
+/**
+ * Single control step in governance chain
+ */
+export declare const ControlStepSchema: z.ZodObject<{
+    engine: z.ZodString;
+    version: z.ZodOptional<z.ZodString>;
+    policy_id: z.ZodOptional<z.ZodString>;
+    result: z.ZodEnum<["allow", "deny", "review"]>;
+    reason: z.ZodOptional<z.ZodString>;
+    purpose: z.ZodOptional<z.ZodEnum<["crawl", "index", "train", "inference", "ai_input", "ai_index", "search"]>>;
+    licensing_mode: z.ZodOptional<z.ZodEnum<["subscription", "pay_per_crawl", "pay_per_inference"]>>;
+    scope: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
+    limits_snapshot: z.ZodOptional<z.ZodUnknown>;
+    evidence_ref: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    engine: string;
+    result: "allow" | "deny" | "review";
+    version?: string | undefined;
+    policy_id?: string | undefined;
+    reason?: string | undefined;
+    purpose?: "crawl" | "index" | "train" | "inference" | "ai_input" | "ai_index" | "search" | undefined;
+    licensing_mode?: "subscription" | "pay_per_crawl" | "pay_per_inference" | undefined;
+    scope?: string | string[] | undefined;
+    limits_snapshot?: unknown;
+    evidence_ref?: string | undefined;
+}, {
+    engine: string;
+    result: "allow" | "deny" | "review";
+    version?: string | undefined;
+    policy_id?: string | undefined;
+    reason?: string | undefined;
+    purpose?: "crawl" | "index" | "train" | "inference" | "ai_input" | "ai_index" | "search" | undefined;
+    licensing_mode?: "subscription" | "pay_per_crawl" | "pay_per_inference" | undefined;
+    scope?: string | string[] | undefined;
+    limits_snapshot?: unknown;
+    evidence_ref?: string | undefined;
+}>;
+/**
+ * Composable control block - multi-party governance
+ */
+export declare const ControlBlockSchema: z.ZodEffects<z.ZodObject<{
+    chain: z.ZodArray<z.ZodObject<{
+        engine: z.ZodString;
+        version: z.ZodOptional<z.ZodString>;
+        policy_id: z.ZodOptional<z.ZodString>;
+        result: z.ZodEnum<["allow", "deny", "review"]>;
+        reason: z.ZodOptional<z.ZodString>;
+        purpose: z.ZodOptional<z.ZodEnum<["crawl", "index", "train", "inference", "ai_input", "ai_index", "search"]>>;
+        licensing_mode: z.ZodOptional<z.ZodEnum<["subscription", "pay_per_crawl", "pay_per_inference"]>>;
+        scope: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
+        limits_snapshot: z.ZodOptional<z.ZodUnknown>;
+        evidence_ref: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        engine: string;
+        result: "allow" | "deny" | "review";
+        version?: string | undefined;
+        policy_id?: string | undefined;
+        reason?: string | undefined;
+        purpose?: "crawl" | "index" | "train" | "inference" | "ai_input" | "ai_index" | "search" | undefined;
+        licensing_mode?: "subscription" | "pay_per_crawl" | "pay_per_inference" | undefined;
+        scope?: string | string[] | undefined;
+        limits_snapshot?: unknown;
+        evidence_ref?: string | undefined;
+    }, {
+        engine: string;
+        result: "allow" | "deny" | "review";
+        version?: string | undefined;
+        policy_id?: string | undefined;
+        reason?: string | undefined;
+        purpose?: "crawl" | "index" | "train" | "inference" | "ai_input" | "ai_index" | "search" | undefined;
+        licensing_mode?: "subscription" | "pay_per_crawl" | "pay_per_inference" | undefined;
+        scope?: string | string[] | undefined;
+        limits_snapshot?: unknown;
+        evidence_ref?: string | undefined;
+    }>, "many">;
+    decision: z.ZodEnum<["allow", "deny", "review"]>;
+    combinator: z.ZodOptional<z.ZodLiteral<"any_can_veto">>;
+}, "strip", z.ZodTypeAny, {
+    chain: {
+        engine: string;
+        result: "allow" | "deny" | "review";
+        version?: string | undefined;
+        policy_id?: string | undefined;
+        reason?: string | undefined;
+        purpose?: "crawl" | "index" | "train" | "inference" | "ai_input" | "ai_index" | "search" | undefined;
+        licensing_mode?: "subscription" | "pay_per_crawl" | "pay_per_inference" | undefined;
+        scope?: string | string[] | undefined;
+        limits_snapshot?: unknown;
+        evidence_ref?: string | undefined;
+    }[];
+    decision: "allow" | "deny" | "review";
+    combinator?: "any_can_veto" | undefined;
+}, {
+    chain: {
+        engine: string;
+        result: "allow" | "deny" | "review";
+        version?: string | undefined;
+        policy_id?: string | undefined;
+        reason?: string | undefined;
+        purpose?: "crawl" | "index" | "train" | "inference" | "ai_input" | "ai_index" | "search" | undefined;
+        licensing_mode?: "subscription" | "pay_per_crawl" | "pay_per_inference" | undefined;
+        scope?: string | string[] | undefined;
+        limits_snapshot?: unknown;
+        evidence_ref?: string | undefined;
+    }[];
+    decision: "allow" | "deny" | "review";
+    combinator?: "any_can_veto" | undefined;
+}>, {
+    chain: {
+        engine: string;
+        result: "allow" | "deny" | "review";
+        version?: string | undefined;
+        policy_id?: string | undefined;
+        reason?: string | undefined;
+        purpose?: "crawl" | "index" | "train" | "inference" | "ai_input" | "ai_index" | "search" | undefined;
+        licensing_mode?: "subscription" | "pay_per_crawl" | "pay_per_inference" | undefined;
+        scope?: string | string[] | undefined;
+        limits_snapshot?: unknown;
+        evidence_ref?: string | undefined;
+    }[];
+    decision: "allow" | "deny" | "review";
+    combinator?: "any_can_veto" | undefined;
+}, {
+    chain: {
+        engine: string;
+        result: "allow" | "deny" | "review";
+        version?: string | undefined;
+        policy_id?: string | undefined;
+        reason?: string | undefined;
+        purpose?: "crawl" | "index" | "train" | "inference" | "ai_input" | "ai_index" | "search" | undefined;
+        licensing_mode?: "subscription" | "pay_per_crawl" | "pay_per_inference" | undefined;
+        scope?: string | string[] | undefined;
+        limits_snapshot?: unknown;
+        evidence_ref?: string | undefined;
+    }[];
+    decision: "allow" | "deny" | "review";
+    combinator?: "any_can_veto" | undefined;
+}>;
+/**
+ * Payment split schema
+ *
+ * Invariants:
+ * - party is required (non-empty string)
+ * - amount if present must be >= 0
+ * - share if present must be in [0,1]
+ * - At least one of amount or share must be specified
+ */
+export declare const PaymentSplitSchema: z.ZodEffects<z.ZodObject<{
+    party: z.ZodString;
+    amount: z.ZodOptional<z.ZodNumber>;
+    currency: z.ZodOptional<z.ZodString>;
+    share: z.ZodOptional<z.ZodNumber>;
+    rail: z.ZodOptional<z.ZodString>;
+    account_ref: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strict", z.ZodTypeAny, {
+    party: string;
+    rail?: string | undefined;
+    amount?: number | undefined;
+    currency?: string | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    share?: number | undefined;
+    account_ref?: string | undefined;
+}, {
+    party: string;
+    rail?: string | undefined;
+    amount?: number | undefined;
+    currency?: string | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    share?: number | undefined;
+    account_ref?: string | undefined;
+}>, {
+    party: string;
+    rail?: string | undefined;
+    amount?: number | undefined;
+    currency?: string | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    share?: number | undefined;
+    account_ref?: string | undefined;
+}, {
+    party: string;
+    rail?: string | undefined;
+    amount?: number | undefined;
+    currency?: string | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    share?: number | undefined;
+    account_ref?: string | undefined;
+}>;
+/**
+ * Payment routing mode schema (rail-agnostic)
+ *
+ * Describes how the payment is routed between payer, aggregator, and merchant.
+ * This is a generic hint - specific rails populate it from their native formats.
+ *
+ * Values:
+ * - "direct": Direct payment to merchant (no intermediary)
+ * - "callback": Routed via callback URL / payment service
+ * - "role": Role-based routing (e.g., "publisher", "platform")
+ *
+ * Examples of producers:
+ * - x402 v2 `payTo.mode` -> routing
+ * - Stripe Connect `destination` -> routing = 'direct' or 'callback'
+ * - UPI `pa` (payee address) -> routing = 'direct'
+ */
+export declare const PaymentRoutingSchema: z.ZodEnum<["direct", "callback", "role"]>;
+/**
+ * Payment evidence schema
+ *
+ * Full schema for PaymentEvidence including aggregator/splits support.
+ */
+export declare const PaymentEvidenceSchema: z.ZodObject<{
+    rail: z.ZodString;
+    reference: z.ZodString;
+    amount: z.ZodNumber;
+    currency: z.ZodString;
+    asset: z.ZodString;
+    env: z.ZodEnum<["live", "test"]>;
+    network: z.ZodOptional<z.ZodString>;
+    facilitator_ref: z.ZodOptional<z.ZodString>;
+    evidence: z.ZodUnknown;
+    aggregator: z.ZodOptional<z.ZodString>;
+    splits: z.ZodOptional<z.ZodArray<z.ZodEffects<z.ZodObject<{
+        party: z.ZodString;
+        amount: z.ZodOptional<z.ZodNumber>;
+        currency: z.ZodOptional<z.ZodString>;
+        share: z.ZodOptional<z.ZodNumber>;
+        rail: z.ZodOptional<z.ZodString>;
+        account_ref: z.ZodOptional<z.ZodString>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strict", z.ZodTypeAny, {
+        party: string;
+        rail?: string | undefined;
+        amount?: number | undefined;
+        currency?: string | undefined;
+        metadata?: Record<string, unknown> | undefined;
+        share?: number | undefined;
+        account_ref?: string | undefined;
+    }, {
+        party: string;
+        rail?: string | undefined;
+        amount?: number | undefined;
+        currency?: string | undefined;
+        metadata?: Record<string, unknown> | undefined;
+        share?: number | undefined;
+        account_ref?: string | undefined;
+    }>, {
+        party: string;
+        rail?: string | undefined;
+        amount?: number | undefined;
+        currency?: string | undefined;
+        metadata?: Record<string, unknown> | undefined;
+        share?: number | undefined;
+        account_ref?: string | undefined;
+    }, {
+        party: string;
+        rail?: string | undefined;
+        amount?: number | undefined;
+        currency?: string | undefined;
+        metadata?: Record<string, unknown> | undefined;
+        share?: number | undefined;
+        account_ref?: string | undefined;
+    }>, "many">>;
+    routing: z.ZodOptional<z.ZodEnum<["direct", "callback", "role"]>>;
+}, "strict", z.ZodTypeAny, {
+    rail: string;
+    reference: string;
+    amount: number;
+    currency: string;
+    asset: string;
+    env: "live" | "test";
+    evidence?: unknown;
+    network?: string | undefined;
+    facilitator_ref?: string | undefined;
+    aggregator?: string | undefined;
+    splits?: {
+        party: string;
+        rail?: string | undefined;
+        amount?: number | undefined;
+        currency?: string | undefined;
+        metadata?: Record<string, unknown> | undefined;
+        share?: number | undefined;
+        account_ref?: string | undefined;
+    }[] | undefined;
+    routing?: "direct" | "callback" | "role" | undefined;
+}, {
+    rail: string;
+    reference: string;
+    amount: number;
+    currency: string;
+    asset: string;
+    env: "live" | "test";
+    evidence?: unknown;
+    network?: string | undefined;
+    facilitator_ref?: string | undefined;
+    aggregator?: string | undefined;
+    splits?: {
+        party: string;
+        rail?: string | undefined;
+        amount?: number | undefined;
+        currency?: string | undefined;
+        metadata?: Record<string, unknown> | undefined;
+        share?: number | undefined;
+        account_ref?: string | undefined;
+    }[] | undefined;
+    routing?: "direct" | "callback" | "role" | undefined;
+}>;
+/**
+ * Subject type schema
+ */
+export declare const SubjectTypeSchema: z.ZodEnum<["human", "org", "agent"]>;
+/**
+ * Subject profile schema
+ *
+ * Invariants:
+ * - id is required (non-empty string)
+ * - type is required (human, org, or agent)
+ * - labels if present must be non-empty strings
+ */
+export declare const SubjectProfileSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodEnum<["human", "org", "agent"]>;
+    labels: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strict", z.ZodTypeAny, {
+    type: "human" | "org" | "agent";
+    id: string;
+    metadata?: Record<string, unknown> | undefined;
+    labels?: string[] | undefined;
+}, {
+    type: "human" | "org" | "agent";
+    id: string;
+    metadata?: Record<string, unknown> | undefined;
+    labels?: string[] | undefined;
+}>;
+/**
+ * Subject profile snapshot schema
+ *
+ * Invariants:
+ * - subject is required (valid SubjectProfile)
+ * - captured_at is required (non-empty string)
+ *   MUST be RFC 3339 / ISO 8601 UTC; format not enforced in schema for v0.9.16
+ */
+export declare const SubjectProfileSnapshotSchema: z.ZodObject<{
+    subject: z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodEnum<["human", "org", "agent"]>;
+        labels: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strict", z.ZodTypeAny, {
+        type: "human" | "org" | "agent";
+        id: string;
+        metadata?: Record<string, unknown> | undefined;
+        labels?: string[] | undefined;
+    }, {
+        type: "human" | "org" | "agent";
+        id: string;
+        metadata?: Record<string, unknown> | undefined;
+        labels?: string[] | undefined;
+    }>;
+    captured_at: z.ZodString;
+    source: z.ZodOptional<z.ZodString>;
+    version: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    subject: {
+        type: "human" | "org" | "agent";
+        id: string;
+        metadata?: Record<string, unknown> | undefined;
+        labels?: string[] | undefined;
+    };
+    captured_at: string;
+    version?: string | undefined;
+    source?: string | undefined;
+}, {
+    subject: {
+        type: "human" | "org" | "agent";
+        id: string;
+        metadata?: Record<string, unknown> | undefined;
+        labels?: string[] | undefined;
+    };
+    captured_at: string;
+    version?: string | undefined;
+    source?: string | undefined;
+}>;
+/**
+ * Validate a subject snapshot (if present)
+ *
+ * - Returns validated snapshot or null if absent
+ * - Throws ZodError for malformed data
+ * - Logs advisory warning if id looks like PII (deduplicated)
+ */
+export declare function validateSubjectSnapshot(snapshot: unknown): z.infer<typeof SubjectProfileSnapshotSchema> | null;
+//# sourceMappingURL=validators.d.ts.map

package/dist/validators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validators.d.ts","sourceRoot":"","sources":["../src/validators.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAYxB,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;EAWnB,CAAC;AAEZ,eAAO,MAAM,OAAO;;;;;;EAAuC,CAAC;AAE5D,eAAO,MAAM,cAAc;;;;;;;;;EAKhB,CAAC;AAIZ,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAKC,CAAC;AAEzB,eAAO,MAAM,SAAS;;;;;;;;;;;;EAMX,CAAC;AAEZ,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAaf,CAAC;AAEZ,eAAO,MAAM,aAAa;;;;;;EAIf,CAAC;AAMZ;;;;;;;GAOG;AACH,eAAO,MAAM,oBAAoB,uFAQ/B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,0BAA0B,mEAIrC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,qBAAqB,wCAAsC,CAAC;AAEzE;;GAEG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAW5B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4B5B,CAAC;AAMJ;;;;;;;;GAQG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAa3B,CAAC;AAEL;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,oBAAoB,2CAAyC,CAAC;AAE3E;;;;GAIG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAevB,CAAC;AAMZ;;GAEG;AACH,eAAO,MAAM,iBAAiB,sCAAoC,CAAC;AAEnE;;;;;;;GAOG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;EAOtB,CAAC;AAEZ;;;;;;;GAOG;AACH,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAO9B,CAAC;AAwBZ;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CACrC,QAAQ,EAAE,OAAO,GAChB,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,GAAG,IAAI,CAmBrD"}