@vorionsys/security 1.0.0

package/dist/semantic-governance/types.d.ts

@@ -0,0 +1,3916 @@
+/**
+ * Semantic Governance Types - Layer 5
+ *
+ * Core types for semantic governance addressing the "confused deputy" problem
+ * where authenticated agents can be manipulated via prompt injection.
+ *
+ * This module provides:
+ * - Instruction Integrity (binding agents to approved prompts)
+ * - Output Schema Binding (constraining agent output)
+ * - Inference Scope Controls (limiting derived knowledge)
+ * - Context Authentication (securing the data plane)
+ * - Dual-Channel Authorization (separating control from data)
+ *
+ * @packageDocumentation
+ * @module @vorion/semantic-governance
+ */
+import { z } from 'zod';
+/**
+ * Domain codes representing capability areas
+ */
+export type DomainCode = 'A' | 'B' | 'C' | 'D' | 'E' | 'F' | 'G' | 'H' | 'I' | 'S';
+export declare const DomainCodeSchema: z.ZodEnum<["A", "B", "C", "D", "E", "F", "G", "H", "I", "S"]>;
+/**
+ * Trust tiers indicating verification level
+ */
+export declare enum TrustTier {
+    /** Sandbox — isolated testing */
+    T0_SANDBOX = 0,
+    /** Observed — read-only, monitored */
+    T1_OBSERVED = 1,
+    /** Provisional — basic operations, heavy supervision */
+    T2_PROVISIONAL = 2,
+    /** Monitored — standard operations, continuous monitoring */
+    T3_MONITORED = 3,
+    /** Standard — external API access, policy-governed */
+    T4_STANDARD = 4,
+    /** Trusted — cross-agent communication, delegated tasks */
+    T5_TRUSTED = 5,
+    /** Certified — admin tasks, agent spawning, minimal oversight */
+    T6_CERTIFIED = 6,
+    /** Autonomous — full autonomy, self-governance */
+    T7_AUTONOMOUS = 7
+}
+export declare const TrustTierSchema: z.ZodNativeEnum<typeof TrustTier>;
+/**
+ * Instruction template definition with parameter schema
+ */
+export interface InstructionTemplate {
+    /** Template identifier */
+    id: string;
+    /** SHA-256 hash of the template */
+    hash: string;
+    /** Human-readable description */
+    description: string;
+    /** JSON Schema for allowed parameters */
+    parameterSchema: object;
+}
+export declare const InstructionTemplateSchema: z.ZodObject<{
+    id: z.ZodString;
+    hash: z.ZodString;
+    description: z.ZodString;
+    parameterSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, "strip", z.ZodTypeAny, {
+    id?: string;
+    description?: string;
+    hash?: string;
+    parameterSchema?: Record<string, unknown>;
+}, {
+    id?: string;
+    description?: string;
+    hash?: string;
+    parameterSchema?: Record<string, unknown>;
+}>;
+/**
+ * Instruction source configuration
+ */
+export interface InstructionSource {
+    /** Allowed source DIDs or identifiers */
+    allowedSources: string[];
+    /** Whether signature verification is required */
+    requireSignature: boolean;
+}
+export declare const InstructionSourceSchema: z.ZodObject<{
+    allowedSources: z.ZodArray<z.ZodString, "many">;
+    requireSignature: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    allowedSources?: string[];
+    requireSignature?: boolean;
+}, {
+    allowedSources?: string[];
+    requireSignature?: boolean;
+}>;
+/**
+ * Instruction integrity configuration
+ * Binds an agent to approved system prompts
+ */
+export interface InstructionIntegrity {
+    /** SHA-256 hashes of allowed system prompts */
+    allowedInstructionHashes: string[];
+    /** Instruction templates with parameter schemas */
+    instructionTemplates: InstructionTemplate[];
+    /** Allowed instruction sources */
+    instructionSource: InstructionSource;
+}
+export declare const InstructionIntegritySchema: z.ZodObject<{
+    allowedInstructionHashes: z.ZodArray<z.ZodString, "many">;
+    instructionTemplates: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        hash: z.ZodString;
+        description: z.ZodString;
+        parameterSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, "strip", z.ZodTypeAny, {
+        id?: string;
+        description?: string;
+        hash?: string;
+        parameterSchema?: Record<string, unknown>;
+    }, {
+        id?: string;
+        description?: string;
+        hash?: string;
+        parameterSchema?: Record<string, unknown>;
+    }>, "many">;
+    instructionSource: z.ZodObject<{
+        allowedSources: z.ZodArray<z.ZodString, "many">;
+        requireSignature: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        allowedSources?: string[];
+        requireSignature?: boolean;
+    }, {
+        allowedSources?: string[];
+        requireSignature?: boolean;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    allowedInstructionHashes?: string[];
+    instructionTemplates?: {
+        id?: string;
+        description?: string;
+        hash?: string;
+        parameterSchema?: Record<string, unknown>;
+    }[];
+    instructionSource?: {
+        allowedSources?: string[];
+        requireSignature?: boolean;
+    };
+}, {
+    allowedInstructionHashes?: string[];
+    instructionTemplates?: {
+        id?: string;
+        description?: string;
+        hash?: string;
+        parameterSchema?: Record<string, unknown>;
+    }[];
+    instructionSource?: {
+        allowedSources?: string[];
+        requireSignature?: boolean;
+    };
+}>;
+/**
+ * Result of instruction validation
+ */
+export interface InstructionValidationResult {
+    /** Whether instruction is valid */
+    valid: boolean;
+    /** Validation method used */
+    method?: 'exact-match' | 'template-match' | 'signed-source';
+    /** Template ID if template-matched */
+    templateId?: string;
+    /** Reason for rejection */
+    reason?: string;
+    /** SHA-256 hash of the instruction */
+    instructionHash?: string;
+    /** Extracted parameters if template-matched */
+    extractedParams?: Record<string, unknown>;
+}
+export declare const InstructionValidationResultSchema: z.ZodObject<{
+    valid: z.ZodBoolean;
+    method: z.ZodOptional<z.ZodEnum<["exact-match", "template-match", "signed-source"]>>;
+    templateId: z.ZodOptional<z.ZodString>;
+    reason: z.ZodOptional<z.ZodString>;
+    instructionHash: z.ZodOptional<z.ZodString>;
+    extractedParams: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    valid?: boolean;
+    method?: "exact-match" | "template-match" | "signed-source";
+    reason?: string;
+    templateId?: string;
+    instructionHash?: string;
+    extractedParams?: Record<string, unknown>;
+}, {
+    valid?: boolean;
+    method?: "exact-match" | "template-match" | "signed-source";
+    reason?: string;
+    templateId?: string;
+    instructionHash?: string;
+    extractedParams?: Record<string, unknown>;
+}>;
+/**
+ * Template match result
+ */
+export interface TemplateMatchResult {
+    /** Whether the template matched */
+    matches: boolean;
+    /** Template ID if matched */
+    templateId?: string;
+    /** Extracted parameters */
+    extractedParams?: Record<string, unknown>;
+    /** Match confidence score (0-1) */
+    confidence?: number;
+}
+export declare const TemplateMatchResultSchema: z.ZodObject<{
+    matches: z.ZodBoolean;
+    templateId: z.ZodOptional<z.ZodString>;
+    extractedParams: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    confidence: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    matches?: boolean;
+    confidence?: number;
+    templateId?: string;
+    extractedParams?: Record<string, unknown>;
+}, {
+    matches?: boolean;
+    confidence?: number;
+    templateId?: string;
+    extractedParams?: Record<string, unknown>;
+}>;
+/**
+ * Output schema definition
+ */
+export interface OutputSchema {
+    /** Schema identifier */
+    id: string;
+    /** Human-readable description */
+    description: string;
+    /** JSON Schema for output validation */
+    jsonSchema: object;
+}
+export declare const OutputSchemaSchema: z.ZodObject<{
+    id: z.ZodString;
+    description: z.ZodString;
+    jsonSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, "strip", z.ZodTypeAny, {
+    id?: string;
+    description?: string;
+    jsonSchema?: Record<string, unknown>;
+}, {
+    id?: string;
+    description?: string;
+    jsonSchema?: Record<string, unknown>;
+}>;
+/**
+ * Prohibited pattern definition
+ */
+export interface ProhibitedPattern {
+    /** Pattern type */
+    type: 'regex' | 'keyword' | 'semantic';
+    /** Pattern value (regex string, keyword, or semantic description) */
+    pattern: string;
+    /** Human-readable description */
+    description: string;
+    /** Severity level */
+    severity?: 'low' | 'medium' | 'high' | 'critical';
+}
+export declare const ProhibitedPatternSchema: z.ZodObject<{
+    type: z.ZodEnum<["regex", "keyword", "semantic"]>;
+    pattern: z.ZodString;
+    description: z.ZodString;
+    severity: z.ZodOptional<z.ZodEnum<["low", "medium", "high", "critical"]>>;
+}, "strip", z.ZodTypeAny, {
+    type?: "regex" | "keyword" | "semantic";
+    pattern?: string;
+    description?: string;
+    severity?: "low" | "medium" | "high" | "critical";
+}, {
+    type?: "regex" | "keyword" | "semantic";
+    pattern?: string;
+    description?: string;
+    severity?: "low" | "medium" | "high" | "critical";
+}>;
+/**
+ * Output schema binding configuration
+ * Constrains what an agent can produce as output
+ */
+export interface OutputBinding {
+    /** Allowed output schemas */
+    allowedSchemas: OutputSchema[];
+    /** Prohibited patterns (e.g., PII, credentials) */
+    prohibitedPatterns: ProhibitedPattern[];
+    /** Allowed external endpoints (glob patterns) */
+    allowedExternalEndpoints: string[];
+    /** Blocked external endpoints (glob patterns) */
+    blockedExternalEndpoints: string[];
+}
+export declare const OutputBindingSchema: z.ZodObject<{
+    allowedSchemas: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        description: z.ZodString;
+        jsonSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, "strip", z.ZodTypeAny, {
+        id?: string;
+        description?: string;
+        jsonSchema?: Record<string, unknown>;
+    }, {
+        id?: string;
+        description?: string;
+        jsonSchema?: Record<string, unknown>;
+    }>, "many">;
+    prohibitedPatterns: z.ZodArray<z.ZodObject<{
+        type: z.ZodEnum<["regex", "keyword", "semantic"]>;
+        pattern: z.ZodString;
+        description: z.ZodString;
+        severity: z.ZodOptional<z.ZodEnum<["low", "medium", "high", "critical"]>>;
+    }, "strip", z.ZodTypeAny, {
+        type?: "regex" | "keyword" | "semantic";
+        pattern?: string;
+        description?: string;
+        severity?: "low" | "medium" | "high" | "critical";
+    }, {
+        type?: "regex" | "keyword" | "semantic";
+        pattern?: string;
+        description?: string;
+        severity?: "low" | "medium" | "high" | "critical";
+    }>, "many">;
+    allowedExternalEndpoints: z.ZodArray<z.ZodString, "many">;
+    blockedExternalEndpoints: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    allowedSchemas?: {
+        id?: string;
+        description?: string;
+        jsonSchema?: Record<string, unknown>;
+    }[];
+    prohibitedPatterns?: {
+        type?: "regex" | "keyword" | "semantic";
+        pattern?: string;
+        description?: string;
+        severity?: "low" | "medium" | "high" | "critical";
+    }[];
+    allowedExternalEndpoints?: string[];
+    blockedExternalEndpoints?: string[];
+}, {
+    allowedSchemas?: {
+        id?: string;
+        description?: string;
+        jsonSchema?: Record<string, unknown>;
+    }[];
+    prohibitedPatterns?: {
+        type?: "regex" | "keyword" | "semantic";
+        pattern?: string;
+        description?: string;
+        severity?: "low" | "medium" | "high" | "critical";
+    }[];
+    allowedExternalEndpoints?: string[];
+    blockedExternalEndpoints?: string[];
+}>;
+/**
+ * Pattern scan result
+ */
+export interface PatternScanResult {
+    /** Whether prohibited patterns were detected */
+    detected: boolean;
+    /** List of detected patterns */
+    patterns: Array<{
+        type: 'regex' | 'keyword' | 'semantic';
+        pattern: string;
+        description: string;
+        matches: string[];
+        severity?: 'low' | 'medium' | 'high' | 'critical';
+    }>;
+    /** Overall severity */
+    severity?: 'low' | 'medium' | 'high' | 'critical';
+}
+export declare const PatternScanResultSchema: z.ZodObject<{
+    detected: z.ZodBoolean;
+    patterns: z.ZodArray<z.ZodObject<{
+        type: z.ZodEnum<["regex", "keyword", "semantic"]>;
+        pattern: z.ZodString;
+        description: z.ZodString;
+        matches: z.ZodArray<z.ZodString, "many">;
+        severity: z.ZodOptional<z.ZodEnum<["low", "medium", "high", "critical"]>>;
+    }, "strip", z.ZodTypeAny, {
+        type?: "regex" | "keyword" | "semantic";
+        pattern?: string;
+        description?: string;
+        severity?: "low" | "medium" | "high" | "critical";
+        matches?: string[];
+    }, {
+        type?: "regex" | "keyword" | "semantic";
+        pattern?: string;
+        description?: string;
+        severity?: "low" | "medium" | "high" | "critical";
+        matches?: string[];
+    }>, "many">;
+    severity: z.ZodOptional<z.ZodEnum<["low", "medium", "high", "critical"]>>;
+}, "strip", z.ZodTypeAny, {
+    severity?: "low" | "medium" | "high" | "critical";
+    detected?: boolean;
+    patterns?: {
+        type?: "regex" | "keyword" | "semantic";
+        pattern?: string;
+        description?: string;
+        severity?: "low" | "medium" | "high" | "critical";
+        matches?: string[];
+    }[];
+}, {
+    severity?: "low" | "medium" | "high" | "critical";
+    detected?: boolean;
+    patterns?: {
+        type?: "regex" | "keyword" | "semantic";
+        pattern?: string;
+        description?: string;
+        severity?: "low" | "medium" | "high" | "critical";
+        matches?: string[];
+    }[];
+}>;
+/**
+ * Output validation result
+ */
+export interface OutputValidationResult {
+    /** Whether output is valid */
+    valid: boolean;
+    /** Whether output was modified */
+    modified?: boolean;
+    /** Modified output (if applicable) */
+    output?: unknown;
+    /** Matched schema ID */
+    schemaId?: string;
+    /** Reason for rejection */
+    reason?: string;
+    /** Pattern scan results */
+    patternScan?: PatternScanResult;
+}
+export declare const OutputValidationResultSchema: z.ZodObject<{
+    valid: z.ZodBoolean;
+    modified: z.ZodOptional<z.ZodBoolean>;
+    output: z.ZodOptional<z.ZodUnknown>;
+    schemaId: z.ZodOptional<z.ZodString>;
+    reason: z.ZodOptional<z.ZodString>;
+    patternScan: z.ZodOptional<z.ZodObject<{
+        detected: z.ZodBoolean;
+        patterns: z.ZodArray<z.ZodObject<{
+            type: z.ZodEnum<["regex", "keyword", "semantic"]>;
+            pattern: z.ZodString;
+            description: z.ZodString;
+            matches: z.ZodArray<z.ZodString, "many">;
+            severity: z.ZodOptional<z.ZodEnum<["low", "medium", "high", "critical"]>>;
+        }, "strip", z.ZodTypeAny, {
+            type?: "regex" | "keyword" | "semantic";
+            pattern?: string;
+            description?: string;
+            severity?: "low" | "medium" | "high" | "critical";
+            matches?: string[];
+        }, {
+            type?: "regex" | "keyword" | "semantic";
+            pattern?: string;
+            description?: string;
+            severity?: "low" | "medium" | "high" | "critical";
+            matches?: string[];
+        }>, "many">;
+        severity: z.ZodOptional<z.ZodEnum<["low", "medium", "high", "critical"]>>;
+    }, "strip", z.ZodTypeAny, {
+        severity?: "low" | "medium" | "high" | "critical";
+        detected?: boolean;
+        patterns?: {
+            type?: "regex" | "keyword" | "semantic";
+            pattern?: string;
+            description?: string;
+            severity?: "low" | "medium" | "high" | "critical";
+            matches?: string[];
+        }[];
+    }, {
+        severity?: "low" | "medium" | "high" | "critical";
+        detected?: boolean;
+        patterns?: {
+            type?: "regex" | "keyword" | "semantic";
+            pattern?: string;
+            description?: string;
+            severity?: "low" | "medium" | "high" | "critical";
+            matches?: string[];
+        }[];
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    valid?: boolean;
+    reason?: string;
+    output?: unknown;
+    modified?: boolean;
+    schemaId?: string;
+    patternScan?: {
+        severity?: "low" | "medium" | "high" | "critical";
+        detected?: boolean;
+        patterns?: {
+            type?: "regex" | "keyword" | "semantic";
+            pattern?: string;
+            description?: string;
+            severity?: "low" | "medium" | "high" | "critical";
+            matches?: string[];
+        }[];
+    };
+}, {
+    valid?: boolean;
+    reason?: string;
+    output?: unknown;
+    modified?: boolean;
+    schemaId?: string;
+    patternScan?: {
+        severity?: "low" | "medium" | "high" | "critical";
+        detected?: boolean;
+        patterns?: {
+            type?: "regex" | "keyword" | "semantic";
+            pattern?: string;
+            description?: string;
+            severity?: "low" | "medium" | "high" | "critical";
+            matches?: string[];
+        }[];
+    };
+}>;
+/**
+ * Sanitized output result
+ */
+export interface SanitizedOutput {
+    /** Sanitized content */
+    content: unknown;
+    /** Whether content was modified */
+    modified: boolean;
+    /** List of redactions made */
+    redactions: Array<{
+        type: string;
+        description: string;
+        count: number;
+    }>;
+}
+export declare const SanitizedOutputSchema: z.ZodObject<{
+    content: z.ZodUnknown;
+    modified: z.ZodBoolean;
+    redactions: z.ZodArray<z.ZodObject<{
+        type: z.ZodString;
+        description: z.ZodString;
+        count: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        type?: string;
+        description?: string;
+        count?: number;
+    }, {
+        type?: string;
+        description?: string;
+        count?: number;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    content?: unknown;
+    modified?: boolean;
+    redactions?: {
+        type?: string;
+        description?: string;
+        count?: number;
+    }[];
+}, {
+    content?: unknown;
+    modified?: boolean;
+    redactions?: {
+        type?: string;
+        description?: string;
+        count?: number;
+    }[];
+}>;
+/**
+ * Inference scope levels
+ */
+export declare enum InferenceLevel {
+    /** No inference; raw data passthrough only */
+    NONE = 0,
+    /** Aggregates, counts, averages */
+    STATISTICAL = 1,
+    /** Named entity extraction */
+    ENTITY = 2,
+    /** Relationship inference */
+    RELATIONAL = 3,
+    /** Pattern prediction */
+    PREDICTIVE = 4,
+    /** Full inference capability */
+    UNRESTRICTED = 5
+}
+export declare const InferenceLevelSchema: z.ZodNativeEnum<typeof InferenceLevel>;
+/**
+ * Inference level names for display
+ */
+export declare const INFERENCE_LEVEL_NAMES: Record<InferenceLevel, string>;
+/**
+ * Domain-specific inference override
+ */
+export interface DomainInferenceOverride {
+    /** Domain code */
+    domain: DomainCode;
+    /** Override level */
+    level: InferenceLevel;
+    /** Reason for override */
+    reason: string;
+}
+export declare const DomainInferenceOverrideSchema: z.ZodObject<{
+    domain: z.ZodEnum<["A", "B", "C", "D", "E", "F", "G", "H", "I", "S"]>;
+    level: z.ZodNativeEnum<typeof InferenceLevel>;
+    reason: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    level?: InferenceLevel;
+    domain?: "H" | "A" | "B" | "C" | "D" | "F" | "E" | "G" | "I" | "S";
+    reason?: string;
+}, {
+    level?: InferenceLevel;
+    domain?: "H" | "A" | "B" | "C" | "D" | "F" | "E" | "G" | "I" | "S";
+    reason?: string;
+}>;
+/**
+ * Derived knowledge handling configuration
+ */
+export interface DerivedKnowledgeHandling {
+    /** Retention policy */
+    retention: 'none' | 'session' | 'persistent';
+    /** Allowed recipients (DIDs or identifiers) */
+    allowedRecipients: string[];
+    /** Whether cross-context sharing is allowed */
+    crossContextSharing: boolean;
+}
+export declare const DerivedKnowledgeHandlingSchema: z.ZodObject<{
+    retention: z.ZodEnum<["none", "session", "persistent"]>;
+    allowedRecipients: z.ZodArray<z.ZodString, "many">;
+    crossContextSharing: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    retention?: "none" | "session" | "persistent";
+    allowedRecipients?: string[];
+    crossContextSharing?: boolean;
+}, {
+    retention?: "none" | "session" | "persistent";
+    allowedRecipients?: string[];
+    crossContextSharing?: boolean;
+}>;
+/**
+ * PII inference configuration
+ */
+export interface PIIInferenceConfig {
+    /** Whether PII inference is allowed */
+    allowed: boolean;
+    /** How to handle PII if not allowed */
+    handling: 'block' | 'redact' | 'hash';
+}
+export declare const PIIInferenceConfigSchema: z.ZodObject<{
+    allowed: z.ZodBoolean;
+    handling: z.ZodEnum<["block", "redact", "hash"]>;
+}, "strip", z.ZodTypeAny, {
+    allowed?: boolean;
+    handling?: "block" | "hash" | "redact";
+}, {
+    allowed?: boolean;
+    handling?: "block" | "hash" | "redact";
+}>;
+/**
+ * Inference scope configuration
+ * Controls what can be derived from accessed data
+ */
+export interface InferenceScope {
+    /** Global inference level limit */
+    globalLevel: InferenceLevel;
+    /** Domain-specific overrides */
+    domainOverrides: DomainInferenceOverride[];
+    /** How to handle derived knowledge */
+    derivedKnowledgeHandling: DerivedKnowledgeHandling;
+    /** PII inference controls */
+    piiInference: PIIInferenceConfig;
+}
+export declare const InferenceScopeSchema: z.ZodObject<{
+    globalLevel: z.ZodNativeEnum<typeof InferenceLevel>;
+    domainOverrides: z.ZodArray<z.ZodObject<{
+        domain: z.ZodEnum<["A", "B", "C", "D", "E", "F", "G", "H", "I", "S"]>;
+        level: z.ZodNativeEnum<typeof InferenceLevel>;
+        reason: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        level?: InferenceLevel;
+        domain?: "H" | "A" | "B" | "C" | "D" | "F" | "E" | "G" | "I" | "S";
+        reason?: string;
+    }, {
+        level?: InferenceLevel;
+        domain?: "H" | "A" | "B" | "C" | "D" | "F" | "E" | "G" | "I" | "S";
+        reason?: string;
+    }>, "many">;
+    derivedKnowledgeHandling: z.ZodObject<{
+        retention: z.ZodEnum<["none", "session", "persistent"]>;
+        allowedRecipients: z.ZodArray<z.ZodString, "many">;
+        crossContextSharing: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        retention?: "none" | "session" | "persistent";
+        allowedRecipients?: string[];
+        crossContextSharing?: boolean;
+    }, {
+        retention?: "none" | "session" | "persistent";
+        allowedRecipients?: string[];
+        crossContextSharing?: boolean;
+    }>;
+    piiInference: z.ZodObject<{
+        allowed: z.ZodBoolean;
+        handling: z.ZodEnum<["block", "redact", "hash"]>;
+    }, "strip", z.ZodTypeAny, {
+        allowed?: boolean;
+        handling?: "block" | "hash" | "redact";
+    }, {
+        allowed?: boolean;
+        handling?: "block" | "hash" | "redact";
+    }>;
+}, "strip", z.ZodTypeAny, {
+    globalLevel?: InferenceLevel;
+    domainOverrides?: {
+        level?: InferenceLevel;
+        domain?: "H" | "A" | "B" | "C" | "D" | "F" | "E" | "G" | "I" | "S";
+        reason?: string;
+    }[];
+    derivedKnowledgeHandling?: {
+        retention?: "none" | "session" | "persistent";
+        allowedRecipients?: string[];
+        crossContextSharing?: boolean;
+    };
+    piiInference?: {
+        allowed?: boolean;
+        handling?: "block" | "hash" | "redact";
+    };
+}, {
+    globalLevel?: InferenceLevel;
+    domainOverrides?: {
+        level?: InferenceLevel;
+        domain?: "H" | "A" | "B" | "C" | "D" | "F" | "E" | "G" | "I" | "S";
+        reason?: string;
+    }[];
+    derivedKnowledgeHandling?: {
+        retention?: "none" | "session" | "persistent";
+        allowedRecipients?: string[];
+        crossContextSharing?: boolean;
+    };
+    piiInference?: {
+        allowed?: boolean;
+        handling?: "block" | "hash" | "redact";
+    };
+}>;
+/**
+ * Inference operation types
+ */
+export type InferenceOperationType = 'aggregate' | 'count' | 'average' | 'entity-extraction' | 'relationship-inference' | 'pattern-prediction' | 'sentiment-analysis' | 'classification' | 'summarization' | 'custom';
+export declare const InferenceOperationTypeSchema: z.ZodEnum<["aggregate", "count", "average", "entity-extraction", "relationship-inference", "pattern-prediction", "sentiment-analysis", "classification", "summarization", "custom"]>;
+/**
+ * Inference operation definition
+ */
+export interface InferenceOperation {
+    /** Operation type */
+    type: InferenceOperationType;
+    /** Source domains */
+    sourceDomains: DomainCode[];
+    /** Description of the inference */
+    description?: string;
+    /** Custom inference level requirement (for custom operations) */
+    customLevel?: InferenceLevel;
+}
+export declare const InferenceOperationSchema: z.ZodObject<{
+    type: z.ZodEnum<["aggregate", "count", "average", "entity-extraction", "relationship-inference", "pattern-prediction", "sentiment-analysis", "classification", "summarization", "custom"]>;
+    sourceDomains: z.ZodArray<z.ZodEnum<["A", "B", "C", "D", "E", "F", "G", "H", "I", "S"]>, "many">;
+    description: z.ZodOptional<z.ZodString>;
+    customLevel: z.ZodOptional<z.ZodNativeEnum<typeof InferenceLevel>>;
+}, "strip", z.ZodTypeAny, {
+    type?: "custom" | "count" | "classification" | "aggregate" | "average" | "entity-extraction" | "relationship-inference" | "pattern-prediction" | "sentiment-analysis" | "summarization";
+    description?: string;
+    sourceDomains?: ("H" | "A" | "B" | "C" | "D" | "F" | "E" | "G" | "I" | "S")[];
+    customLevel?: InferenceLevel;
+}, {
+    type?: "custom" | "count" | "classification" | "aggregate" | "average" | "entity-extraction" | "relationship-inference" | "pattern-prediction" | "sentiment-analysis" | "summarization";
+    description?: string;
+    sourceDomains?: ("H" | "A" | "B" | "C" | "D" | "F" | "E" | "G" | "I" | "S")[];
+    customLevel?: InferenceLevel;
+}>;
+/**
+ * Derived knowledge representation
+ */
+export interface DerivedKnowledge {
+    /** Unique identifier */
+    id: string;
+    /** Type of knowledge */
+    type: InferenceOperationType;
+    /** Source data identifiers */
+    sourceIds: string[];
+    /** Source domains */
+    sourceDomains: DomainCode[];
+    /** The derived content */
+    content: unknown;
+    /** Creation timestamp */
+    createdAt: Date;
+    /** Inference level used */
+    inferenceLevel: InferenceLevel;
+}
+export declare const DerivedKnowledgeSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodEnum<["aggregate", "count", "average", "entity-extraction", "relationship-inference", "pattern-prediction", "sentiment-analysis", "classification", "summarization", "custom"]>;
+    sourceIds: z.ZodArray<z.ZodString, "many">;
+    sourceDomains: z.ZodArray<z.ZodEnum<["A", "B", "C", "D", "E", "F", "G", "H", "I", "S"]>, "many">;
+    content: z.ZodUnknown;
+    createdAt: z.ZodDate;
+    inferenceLevel: z.ZodNativeEnum<typeof InferenceLevel>;
+}, "strip", z.ZodTypeAny, {
+    id?: string;
+    type?: "custom" | "count" | "classification" | "aggregate" | "average" | "entity-extraction" | "relationship-inference" | "pattern-prediction" | "sentiment-analysis" | "summarization";
+    createdAt?: Date;
+    content?: unknown;
+    sourceDomains?: ("H" | "A" | "B" | "C" | "D" | "F" | "E" | "G" | "I" | "S")[];
+    sourceIds?: string[];
+    inferenceLevel?: InferenceLevel;
+}, {
+    id?: string;
+    type?: "custom" | "count" | "classification" | "aggregate" | "average" | "entity-extraction" | "relationship-inference" | "pattern-prediction" | "sentiment-analysis" | "summarization";
+    createdAt?: Date;
+    content?: unknown;
+    sourceDomains?: ("H" | "A" | "B" | "C" | "D" | "F" | "E" | "G" | "I" | "S")[];
+    sourceIds?: string[];
+    inferenceLevel?: InferenceLevel;
+}>;
+/**
+ * Inference validation result
+ */
+export interface InferenceValidationResult {
+    /** Whether inference is valid */
+    valid: boolean;
+    /** Reason for rejection */
+    reason?: string;
+    /** Required level */
+    requiredLevel?: InferenceLevel;
+    /** Agent's effective level */
+    agentLevel?: InferenceLevel;
+    /** Domain that caused restriction */
+    restrictedDomain?: DomainCode;
+}
+export declare const InferenceValidationResultSchema: z.ZodObject<{
+    valid: z.ZodBoolean;
+    reason: z.ZodOptional<z.ZodString>;
+    requiredLevel: z.ZodOptional<z.ZodNativeEnum<typeof InferenceLevel>>;
+    agentLevel: z.ZodOptional<z.ZodNativeEnum<typeof InferenceLevel>>;
+    restrictedDomain: z.ZodOptional<z.ZodEnum<["A", "B", "C", "D", "E", "F", "G", "H", "I", "S"]>>;
+}, "strip", z.ZodTypeAny, {
+    valid?: boolean;
+    reason?: string;
+    requiredLevel?: InferenceLevel;
+    agentLevel?: InferenceLevel;
+    restrictedDomain?: "H" | "A" | "B" | "C" | "D" | "F" | "E" | "G" | "I" | "S";
+}, {
+    valid?: boolean;
+    reason?: string;
+    requiredLevel?: InferenceLevel;
+    agentLevel?: InferenceLevel;
+    restrictedDomain?: "H" | "A" | "B" | "C" | "D" | "F" | "E" | "G" | "I" | "S";
+}>;
+/**
+ * Handling result for derived knowledge
+ */
+export interface HandlingResult {
+    /** Action taken */
+    action: 'stored' | 'discarded' | 'shared' | 'redacted';
+    /** Reason for action */
+    reason: string;
+    /** Modified knowledge (if redacted) */
+    modifiedKnowledge?: DerivedKnowledge;
+}
+export declare const HandlingResultSchema: z.ZodObject<{
+    action: z.ZodEnum<["stored", "discarded", "shared", "redacted"]>;
+    reason: z.ZodString;
+    modifiedKnowledge: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodEnum<["aggregate", "count", "average", "entity-extraction", "relationship-inference", "pattern-prediction", "sentiment-analysis", "classification", "summarization", "custom"]>;
+        sourceIds: z.ZodArray<z.ZodString, "many">;
+        sourceDomains: z.ZodArray<z.ZodEnum<["A", "B", "C", "D", "E", "F", "G", "H", "I", "S"]>, "many">;
+        content: z.ZodUnknown;
+        createdAt: z.ZodDate;
+        inferenceLevel: z.ZodNativeEnum<typeof InferenceLevel>;
+    }, "strip", z.ZodTypeAny, {
+        id?: string;
+        type?: "custom" | "count" | "classification" | "aggregate" | "average" | "entity-extraction" | "relationship-inference" | "pattern-prediction" | "sentiment-analysis" | "summarization";
+        createdAt?: Date;
+        content?: unknown;
+        sourceDomains?: ("H" | "A" | "B" | "C" | "D" | "F" | "E" | "G" | "I" | "S")[];
+        sourceIds?: string[];
+        inferenceLevel?: InferenceLevel;
+    }, {
+        id?: string;
+        type?: "custom" | "count" | "classification" | "aggregate" | "average" | "entity-extraction" | "relationship-inference" | "pattern-prediction" | "sentiment-analysis" | "summarization";
+        createdAt?: Date;
+        content?: unknown;
+        sourceDomains?: ("H" | "A" | "B" | "C" | "D" | "F" | "E" | "G" | "I" | "S")[];
+        sourceIds?: string[];
+        inferenceLevel?: InferenceLevel;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    reason?: string;
+    action?: "stored" | "redacted" | "discarded" | "shared";
+    modifiedKnowledge?: {
+        id?: string;
+        type?: "custom" | "count" | "classification" | "aggregate" | "average" | "entity-extraction" | "relationship-inference" | "pattern-prediction" | "sentiment-analysis" | "summarization";
+        createdAt?: Date;
+        content?: unknown;
+        sourceDomains?: ("H" | "A" | "B" | "C" | "D" | "F" | "E" | "G" | "I" | "S")[];
+        sourceIds?: string[];
+        inferenceLevel?: InferenceLevel;
+    };
+}, {
+    reason?: string;
+    action?: "stored" | "redacted" | "discarded" | "shared";
+    modifiedKnowledge?: {
+        id?: string;
+        type?: "custom" | "count" | "classification" | "aggregate" | "average" | "entity-extraction" | "relationship-inference" | "pattern-prediction" | "sentiment-analysis" | "summarization";
+        createdAt?: Date;
+        content?: unknown;
+        sourceDomains?: ("H" | "A" | "B" | "C" | "D" | "F" | "E" | "G" | "I" | "S")[];
+        sourceIds?: string[];
+        inferenceLevel?: InferenceLevel;
+    };
+}>;
+/**
+ * PII check result
+ */
+export interface PIICheckResult {
+    /** Whether PII was detected */
+    containsPII: boolean;
+    /** Types of PII detected */
+    piiTypes: string[];
+    /** Action taken */
+    action: 'allowed' | 'blocked' | 'redacted' | 'hashed';
+    /** Modified data (if redacted or hashed) */
+    modifiedData?: unknown;
+}
+export declare const PIICheckResultSchema: z.ZodObject<{
+    containsPII: z.ZodBoolean;
+    piiTypes: z.ZodArray<z.ZodString, "many">;
+    action: z.ZodEnum<["allowed", "blocked", "redacted", "hashed"]>;
+    modifiedData: z.ZodOptional<z.ZodUnknown>;
+}, "strip", z.ZodTypeAny, {
+    action?: "blocked" | "redacted" | "allowed" | "hashed";
+    containsPII?: boolean;
+    piiTypes?: string[];
+    modifiedData?: unknown;
+}, {
+    action?: "blocked" | "redacted" | "allowed" | "hashed";
+    containsPII?: boolean;
+    piiTypes?: string[];
+    modifiedData?: unknown;
+}>;
+/**
+ * Content integrity requirements
+ */
+export interface ContentIntegrity {
+    /** Whether signature is required */
+    signatureRequired: boolean;
+    /** Maximum age in seconds */
+    maxAge: number;
+    /** Allowed content formats */
+    allowedFormats: string[];
+}
+export declare const ContentIntegritySchema: z.ZodObject<{
+    signatureRequired: z.ZodBoolean;
+    maxAge: z.ZodNumber;
+    allowedFormats: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    maxAge?: number;
+    signatureRequired?: boolean;
+    allowedFormats?: string[];
+}, {
+    maxAge?: number;
+    signatureRequired?: boolean;
+    allowedFormats?: string[];
+}>;
+/**
+ * Context provider authentication requirements
+ */
+export interface ContextAuthenticationRequirements {
+    /** Whether authentication is required */
+    required: boolean;
+    /** Minimum trust tier for providers */
+    minTrustTier: TrustTier;
+    /** Required domains for providers */
+    requiredDomains?: DomainCode[];
+    /** Allowed provider DIDs */
+    allowedProviders: string[];
+    /** Blocked provider DIDs */
+    blockedProviders: string[];
+    /** Content integrity requirements */
+    contentIntegrity: ContentIntegrity;
+}
+export declare const ContextAuthenticationRequirementsSchema: z.ZodObject<{
+    required: z.ZodBoolean;
+    minTrustTier: z.ZodNativeEnum<typeof TrustTier>;
+    requiredDomains: z.ZodOptional<z.ZodArray<z.ZodEnum<["A", "B", "C", "D", "E", "F", "G", "H", "I", "S"]>, "many">>;
+    allowedProviders: z.ZodArray<z.ZodString, "many">;
+    blockedProviders: z.ZodArray<z.ZodString, "many">;
+    contentIntegrity: z.ZodObject<{
+        signatureRequired: z.ZodBoolean;
+        maxAge: z.ZodNumber;
+        allowedFormats: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        maxAge?: number;
+        signatureRequired?: boolean;
+        allowedFormats?: string[];
+    }, {
+        maxAge?: number;
+        signatureRequired?: boolean;
+        allowedFormats?: string[];
+    }>;
+}, "strip", z.ZodTypeAny, {
+    required?: boolean;
+    requiredDomains?: ("H" | "A" | "B" | "C" | "D" | "F" | "E" | "G" | "I" | "S")[];
+    minTrustTier?: TrustTier;
+    allowedProviders?: string[];
+    blockedProviders?: string[];
+    contentIntegrity?: {
+        maxAge?: number;
+        signatureRequired?: boolean;
+        allowedFormats?: string[];
+    };
+}, {
+    required?: boolean;
+    requiredDomains?: ("H" | "A" | "B" | "C" | "D" | "F" | "E" | "G" | "I" | "S")[];
+    minTrustTier?: TrustTier;
+    allowedProviders?: string[];
+    blockedProviders?: string[];
+    contentIntegrity?: {
+        maxAge?: number;
+        signatureRequired?: boolean;
+        allowedFormats?: string[];
+    };
+}>;
+/**
+ * Trust profile for context providers
+ */
+export interface TrustProfile {
+    /** Provider DID */
+    did: string;
+    /** Trust tier */
+    trustTier: TrustTier;
+    /** Capability domains */
+    domains: DomainCode[];
+    /** Trust score (0-1000) */
+    trustScore: number;
+    /** Attestations */
+    attestations?: string[];
+}
+export declare const TrustProfileSchema: z.ZodObject<{
+    did: z.ZodString;
+    trustTier: z.ZodNativeEnum<typeof TrustTier>;
+    domains: z.ZodArray<z.ZodEnum<["A", "B", "C", "D", "E", "F", "G", "H", "I", "S"]>, "many">;
+    trustScore: z.ZodNumber;
+    attestations: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    trustScore?: number;
+    did?: string;
+    trustTier?: TrustTier;
+    domains?: ("H" | "A" | "B" | "C" | "D" | "F" | "E" | "G" | "I" | "S")[];
+    attestations?: string[];
+}, {
+    trustScore?: number;
+    did?: string;
+    trustTier?: TrustTier;
+    domains?: ("H" | "A" | "B" | "C" | "D" | "F" | "E" | "G" | "I" | "S")[];
+    attestations?: string[];
+}>;
+/**
+ * Provider validation result
+ */
+export interface ProviderValidationResult {
+    /** Whether provider is valid */
+    valid: boolean;
+    /** Provider DID */
+    providerId: string;
+    /** Trust tier */
+    trustTier?: TrustTier;
+    /** Reason for rejection */
+    reason?: string;
+    /** Whether provider is on blocklist */
+    blocked?: boolean;
+}
+export declare const ProviderValidationResultSchema: z.ZodObject<{
+    valid: z.ZodBoolean;
+    providerId: z.ZodString;
+    trustTier: z.ZodOptional<z.ZodNativeEnum<typeof TrustTier>>;
+    reason: z.ZodOptional<z.ZodString>;
+    blocked: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    valid?: boolean;
+    providerId?: string;
+    reason?: string;
+    blocked?: boolean;
+    trustTier?: TrustTier;
+}, {
+    valid?: boolean;
+    providerId?: string;
+    reason?: string;
+    blocked?: boolean;
+    trustTier?: TrustTier;
+}>;
+/**
+ * Content validation result
+ */
+export interface ContentValidationResult {
+    /** Whether content is valid */
+    valid: boolean;
+    /** Signature verification status */
+    signatureValid?: boolean;
+    /** Content age in seconds */
+    ageSeconds?: number;
+    /** Content format */
+    format?: string;
+    /** Reason for rejection */
+    reason?: string;
+}
+export declare const ContentValidationResultSchema: z.ZodObject<{
+    valid: z.ZodBoolean;
+    signatureValid: z.ZodOptional<z.ZodBoolean>;
+    ageSeconds: z.ZodOptional<z.ZodNumber>;
+    format: z.ZodOptional<z.ZodString>;
+    reason: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    valid?: boolean;
+    reason?: string;
+    format?: string;
+    signatureValid?: boolean;
+    ageSeconds?: number;
+}, {
+    valid?: boolean;
+    reason?: string;
+    format?: string;
+    signatureValid?: boolean;
+    ageSeconds?: number;
+}>;
+/**
+ * Injection scan result
+ */
+export interface InjectionScanResult {
+    /** Whether injection patterns were detected */
+    detected: boolean;
+    /** Detected patterns */
+    patterns: string[];
+    /** Severity level */
+    severity?: 'low' | 'medium' | 'high' | 'critical';
+    /** Matched pattern descriptions */
+    descriptions?: string[];
+}
+export declare const InjectionScanResultSchema: z.ZodObject<{
+    detected: z.ZodBoolean;
+    patterns: z.ZodArray<z.ZodString, "many">;
+    severity: z.ZodOptional<z.ZodEnum<["low", "medium", "high", "critical"]>>;
+    descriptions: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    severity?: "low" | "medium" | "high" | "critical";
+    detected?: boolean;
+    patterns?: string[];
+    descriptions?: string[];
+}, {
+    severity?: "low" | "medium" | "high" | "critical";
+    detected?: boolean;
+    patterns?: string[];
+    descriptions?: string[];
+}>;
+/**
+ * Context validation result
+ */
+export interface ContextValidationResult {
+    /** Whether context is valid */
+    valid: boolean;
+    /** Reason for rejection */
+    reason?: string;
+    /** Provider validation result */
+    providerValidation?: ProviderValidationResult;
+    /** Content validation result */
+    contentValidation?: ContentValidationResult;
+    /** Injection scan results */
+    injectionScan?: InjectionScanResult;
+}
+export declare const ContextValidationResultSchema: z.ZodObject<{
+    valid: z.ZodBoolean;
+    reason: z.ZodOptional<z.ZodString>;
+    providerValidation: z.ZodOptional<z.ZodObject<{
+        valid: z.ZodBoolean;
+        providerId: z.ZodString;
+        trustTier: z.ZodOptional<z.ZodNativeEnum<typeof TrustTier>>;
+        reason: z.ZodOptional<z.ZodString>;
+        blocked: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        valid?: boolean;
+        providerId?: string;
+        reason?: string;
+        blocked?: boolean;
+        trustTier?: TrustTier;
+    }, {
+        valid?: boolean;
+        providerId?: string;
+        reason?: string;
+        blocked?: boolean;
+        trustTier?: TrustTier;
+    }>>;
+    contentValidation: z.ZodOptional<z.ZodObject<{
+        valid: z.ZodBoolean;
+        signatureValid: z.ZodOptional<z.ZodBoolean>;
+        ageSeconds: z.ZodOptional<z.ZodNumber>;
+        format: z.ZodOptional<z.ZodString>;
+        reason: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        valid?: boolean;
+        reason?: string;
+        format?: string;
+        signatureValid?: boolean;
+        ageSeconds?: number;
+    }, {
+        valid?: boolean;
+        reason?: string;
+        format?: string;
+        signatureValid?: boolean;
+        ageSeconds?: number;
+    }>>;
+    injectionScan: z.ZodOptional<z.ZodObject<{
+        detected: z.ZodBoolean;
+        patterns: z.ZodArray<z.ZodString, "many">;
+        severity: z.ZodOptional<z.ZodEnum<["low", "medium", "high", "critical"]>>;
+        descriptions: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        severity?: "low" | "medium" | "high" | "critical";
+        detected?: boolean;
+        patterns?: string[];
+        descriptions?: string[];
+    }, {
+        severity?: "low" | "medium" | "high" | "critical";
+        detected?: boolean;
+        patterns?: string[];
+        descriptions?: string[];
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    valid?: boolean;
+    reason?: string;
+    providerValidation?: {
+        valid?: boolean;
+        providerId?: string;
+        reason?: string;
+        blocked?: boolean;
+        trustTier?: TrustTier;
+    };
+    contentValidation?: {
+        valid?: boolean;
+        reason?: string;
+        format?: string;
+        signatureValid?: boolean;
+        ageSeconds?: number;
+    };
+    injectionScan?: {
+        severity?: "low" | "medium" | "high" | "critical";
+        detected?: boolean;
+        patterns?: string[];
+        descriptions?: string[];
+    };
+}, {
+    valid?: boolean;
+    reason?: string;
+    providerValidation?: {
+        valid?: boolean;
+        providerId?: string;
+        reason?: string;
+        blocked?: boolean;
+        trustTier?: TrustTier;
+    };
+    contentValidation?: {
+        valid?: boolean;
+        reason?: string;
+        format?: string;
+        signatureValid?: boolean;
+        ageSeconds?: number;
+    };
+    injectionScan?: {
+        severity?: "low" | "medium" | "high" | "critical";
+        detected?: boolean;
+        patterns?: string[];
+        descriptions?: string[];
+    };
+}>;
+/**
+ * Message channel classification
+ */
+export type MessageChannel = 'control' | 'data';
+export declare const MessageChannelSchema: z.ZodEnum<["control", "data"]>;
+/**
+ * Dual-channel authorization configuration
+ */
+export interface DualChannelConfig {
+    /** Whether dual-channel is enforced */
+    enforced: boolean;
+    /** Control plane sources */
+    controlPlaneSources: string[];
+    /** How to treat data plane content */
+    dataPlaneTreatment: 'block' | 'sanitize' | 'warn';
+}
+export declare const DualChannelConfigSchema: z.ZodObject<{
+    enforced: z.ZodBoolean;
+    controlPlaneSources: z.ZodArray<z.ZodString, "many">;
+    dataPlaneTreatment: z.ZodEnum<["block", "sanitize", "warn"]>;
+}, "strip", z.ZodTypeAny, {
+    enforced?: boolean;
+    controlPlaneSources?: string[];
+    dataPlaneTreatment?: "warn" | "block" | "sanitize";
+}, {
+    enforced?: boolean;
+    controlPlaneSources?: string[];
+    dataPlaneTreatment?: "warn" | "block" | "sanitize";
+}>;
+/**
+ * Message classification result
+ */
+export interface MessageClassification {
+    /** Detected channel */
+    channel: MessageChannel;
+    /** Message source */
+    source: string;
+    /** Whether source is authenticated */
+    authenticated: boolean;
+    /** Whether instructions are allowed from this channel */
+    instructionAllowed: boolean;
+    /** Confidence in classification (0-1) */
+    confidence?: number;
+}
+export declare const MessageClassificationSchema: z.ZodObject<{
+    channel: z.ZodEnum<["control", "data"]>;
+    source: z.ZodString;
+    authenticated: z.ZodBoolean;
+    instructionAllowed: z.ZodBoolean;
+    confidence: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    channel?: "data" | "control";
+    source?: string;
+    confidence?: number;
+    authenticated?: boolean;
+    instructionAllowed?: boolean;
+}, {
+    channel?: "data" | "control";
+    source?: string;
+    confidence?: number;
+    authenticated?: boolean;
+    instructionAllowed?: boolean;
+}>;
+/**
+ * Channel enforcement result
+ */
+export interface EnforcementResult {
+    /** Whether message is allowed to proceed */
+    allowed: boolean;
+    /** Action taken */
+    action: 'pass' | 'block' | 'sanitize' | 'warn';
+    /** Reason for action */
+    reason?: string;
+    /** Sanitized content (if applicable) */
+    sanitizedContent?: string;
+    /** Stripped instructions (for audit) */
+    strippedInstructions?: string[];
+}
+export declare const EnforcementResultSchema: z.ZodObject<{
+    allowed: z.ZodBoolean;
+    action: z.ZodEnum<["pass", "block", "sanitize", "warn"]>;
+    reason: z.ZodOptional<z.ZodString>;
+    sanitizedContent: z.ZodOptional<z.ZodString>;
+    strippedInstructions: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    reason?: string;
+    action?: "warn" | "block" | "pass" | "sanitize";
+    allowed?: boolean;
+    sanitizedContent?: string;
+    strippedInstructions?: string[];
+}, {
+    reason?: string;
+    action?: "warn" | "block" | "pass" | "sanitize";
+    allowed?: boolean;
+    sanitizedContent?: string;
+    strippedInstructions?: string[];
+}>;
+/**
+ * Complete semantic governance credential
+ * Combines all semantic governance controls into a single verifiable credential
+ */
+export interface SemanticGovernanceCredential {
+    /** Credential ID (typically the agent DID) */
+    id: string;
+    /** Full CAR ID string */
+    carId: string;
+    /** Instruction integrity rules */
+    instructionIntegrity: InstructionIntegrity;
+    /** Output binding rules */
+    outputBinding: OutputBinding;
+    /** Inference scope rules */
+    inferenceScope: InferenceScope;
+    /** Context authentication rules */
+    contextAuthentication: ContextAuthenticationRequirements;
+    /** Dual-channel configuration */
+    dualChannel: DualChannelConfig;
+    /** Credential metadata */
+    metadata?: {
+        /** Issuer DID */
+        issuer?: string;
+        /** Issuance date */
+        issuedAt?: Date;
+        /** Expiration date */
+        expiresAt?: Date;
+        /** Credential version */
+        version?: string;
+    };
+}
+export declare const SemanticGovernanceCredentialSchema: z.ZodObject<{
+    id: z.ZodString;
+    carId: z.ZodString;
+    instructionIntegrity: z.ZodObject<{
+        allowedInstructionHashes: z.ZodArray<z.ZodString, "many">;
+        instructionTemplates: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            hash: z.ZodString;
+            description: z.ZodString;
+            parameterSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, "strip", z.ZodTypeAny, {
+            id?: string;
+            description?: string;
+            hash?: string;
+            parameterSchema?: Record<string, unknown>;
+        }, {
+            id?: string;
+            description?: string;
+            hash?: string;
+            parameterSchema?: Record<string, unknown>;
+        }>, "many">;
+        instructionSource: z.ZodObject<{
+            allowedSources: z.ZodArray<z.ZodString, "many">;
+            requireSignature: z.ZodBoolean;
+        }, "strip", z.ZodTypeAny, {
+            allowedSources?: string[];
+            requireSignature?: boolean;
+        }, {
+            allowedSources?: string[];
+            requireSignature?: boolean;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        allowedInstructionHashes?: string[];
+        instructionTemplates?: {
+            id?: string;
+            description?: string;
+            hash?: string;
+            parameterSchema?: Record<string, unknown>;
+        }[];
+        instructionSource?: {
+            allowedSources?: string[];
+            requireSignature?: boolean;
+        };
+    }, {
+        allowedInstructionHashes?: string[];
+        instructionTemplates?: {
+            id?: string;
+            description?: string;
+            hash?: string;
+            parameterSchema?: Record<string, unknown>;
+        }[];
+        instructionSource?: {
+            allowedSources?: string[];
+            requireSignature?: boolean;
+        };
+    }>;
+    outputBinding: z.ZodObject<{
+        allowedSchemas: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            description: z.ZodString;
+            jsonSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, "strip", z.ZodTypeAny, {
+            id?: string;
+            description?: string;
+            jsonSchema?: Record<string, unknown>;
+        }, {
+            id?: string;
+            description?: string;
+            jsonSchema?: Record<string, unknown>;
+        }>, "many">;
+        prohibitedPatterns: z.ZodArray<z.ZodObject<{
+            type: z.ZodEnum<["regex", "keyword", "semantic"]>;
+            pattern: z.ZodString;
+            description: z.ZodString;
+            severity: z.ZodOptional<z.ZodEnum<["low", "medium", "high", "critical"]>>;
+        }, "strip", z.ZodTypeAny, {
+            type?: "regex" | "keyword" | "semantic";
+            pattern?: string;
+            description?: string;
+            severity?: "low" | "medium" | "high" | "critical";
+        }, {
+            type?: "regex" | "keyword" | "semantic";
+            pattern?: string;
+            description?: string;
+            severity?: "low" | "medium" | "high" | "critical";
+        }>, "many">;
+        allowedExternalEndpoints: z.ZodArray<z.ZodString, "many">;
+        blockedExternalEndpoints: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        allowedSchemas?: {
+            id?: string;
+            description?: string;
+            jsonSchema?: Record<string, unknown>;
+        }[];
+        prohibitedPatterns?: {
+            type?: "regex" | "keyword" | "semantic";
+            pattern?: string;
+            description?: string;
+            severity?: "low" | "medium" | "high" | "critical";
+        }[];
+        allowedExternalEndpoints?: string[];
+        blockedExternalEndpoints?: string[];
+    }, {
+        allowedSchemas?: {
+            id?: string;
+            description?: string;
+            jsonSchema?: Record<string, unknown>;
+        }[];
+        prohibitedPatterns?: {
+            type?: "regex" | "keyword" | "semantic";
+            pattern?: string;
+            description?: string;
+            severity?: "low" | "medium" | "high" | "critical";
+        }[];
+        allowedExternalEndpoints?: string[];
+        blockedExternalEndpoints?: string[];
+    }>;
+    inferenceScope: z.ZodObject<{
+        globalLevel: z.ZodNativeEnum<typeof InferenceLevel>;
+        domainOverrides: z.ZodArray<z.ZodObject<{
+            domain: z.ZodEnum<["A", "B", "C", "D", "E", "F", "G", "H", "I", "S"]>;
+            level: z.ZodNativeEnum<typeof InferenceLevel>;
+            reason: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            level?: InferenceLevel;
+            domain?: "H" | "A" | "B" | "C" | "D" | "F" | "E" | "G" | "I" | "S";
+            reason?: string;
+        }, {
+            level?: InferenceLevel;
+            domain?: "H" | "A" | "B" | "C" | "D" | "F" | "E" | "G" | "I" | "S";
+            reason?: string;
+        }>, "many">;
+        derivedKnowledgeHandling: z.ZodObject<{
+            retention: z.ZodEnum<["none", "session", "persistent"]>;
+            allowedRecipients: z.ZodArray<z.ZodString, "many">;
+            crossContextSharing: z.ZodBoolean;
+        }, "strip", z.ZodTypeAny, {
+            retention?: "none" | "session" | "persistent";
+            allowedRecipients?: string[];
+            crossContextSharing?: boolean;
+        }, {
+            retention?: "none" | "session" | "persistent";
+            allowedRecipients?: string[];
+            crossContextSharing?: boolean;
+        }>;
+        piiInference: z.ZodObject<{
+            allowed: z.ZodBoolean;
+            handling: z.ZodEnum<["block", "redact", "hash"]>;
+        }, "strip", z.ZodTypeAny, {
+            allowed?: boolean;
+            handling?: "block" | "hash" | "redact";
+        }, {
+            allowed?: boolean;
+            handling?: "block" | "hash" | "redact";
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        globalLevel?: InferenceLevel;
+        domainOverrides?: {
+            level?: InferenceLevel;
+            domain?: "H" | "A" | "B" | "C" | "D" | "F" | "E" | "G" | "I" | "S";
+            reason?: string;
+        }[];
+        derivedKnowledgeHandling?: {
+            retention?: "none" | "session" | "persistent";
+            allowedRecipients?: string[];
+            crossContextSharing?: boolean;
+        };
+        piiInference?: {
+            allowed?: boolean;
+            handling?: "block" | "hash" | "redact";
+        };
+    }, {
+        globalLevel?: InferenceLevel;
+        domainOverrides?: {
+            level?: InferenceLevel;
+            domain?: "H" | "A" | "B" | "C" | "D" | "F" | "E" | "G" | "I" | "S";
+            reason?: string;
+        }[];
+        derivedKnowledgeHandling?: {
+            retention?: "none" | "session" | "persistent";
+            allowedRecipients?: string[];
+            crossContextSharing?: boolean;
+        };
+        piiInference?: {
+            allowed?: boolean;
+            handling?: "block" | "hash" | "redact";
+        };
+    }>;
+    contextAuthentication: z.ZodObject<{
+        required: z.ZodBoolean;
+        minTrustTier: z.ZodNativeEnum<typeof TrustTier>;
+        requiredDomains: z.ZodOptional<z.ZodArray<z.ZodEnum<["A", "B", "C", "D", "E", "F", "G", "H", "I", "S"]>, "many">>;
+        allowedProviders: z.ZodArray<z.ZodString, "many">;
+        blockedProviders: z.ZodArray<z.ZodString, "many">;
+        contentIntegrity: z.ZodObject<{
+            signatureRequired: z.ZodBoolean;
+            maxAge: z.ZodNumber;
+            allowedFormats: z.ZodArray<z.ZodString, "many">;
+        }, "strip", z.ZodTypeAny, {
+            maxAge?: number;
+            signatureRequired?: boolean;
+            allowedFormats?: string[];
+        }, {
+            maxAge?: number;
+            signatureRequired?: boolean;
+            allowedFormats?: string[];
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        required?: boolean;
+        requiredDomains?: ("H" | "A" | "B" | "C" | "D" | "F" | "E" | "G" | "I" | "S")[];
+        minTrustTier?: TrustTier;
+        allowedProviders?: string[];
+        blockedProviders?: string[];
+        contentIntegrity?: {
+            maxAge?: number;
+            signatureRequired?: boolean;
+            allowedFormats?: string[];
+        };
+    }, {
+        required?: boolean;
+        requiredDomains?: ("H" | "A" | "B" | "C" | "D" | "F" | "E" | "G" | "I" | "S")[];
+        minTrustTier?: TrustTier;
+        allowedProviders?: string[];
+        blockedProviders?: string[];
+        contentIntegrity?: {
+            maxAge?: number;
+            signatureRequired?: boolean;
+            allowedFormats?: string[];
+        };
+    }>;
+    dualChannel: z.ZodObject<{
+        enforced: z.ZodBoolean;
+        controlPlaneSources: z.ZodArray<z.ZodString, "many">;
+        dataPlaneTreatment: z.ZodEnum<["block", "sanitize", "warn"]>;
+    }, "strip", z.ZodTypeAny, {
+        enforced?: boolean;
+        controlPlaneSources?: string[];
+        dataPlaneTreatment?: "warn" | "block" | "sanitize";
+    }, {
+        enforced?: boolean;
+        controlPlaneSources?: string[];
+        dataPlaneTreatment?: "warn" | "block" | "sanitize";
+    }>;
+    metadata: z.ZodOptional<z.ZodObject<{
+        issuer: z.ZodOptional<z.ZodString>;
+        issuedAt: z.ZodOptional<z.ZodDate>;
+        expiresAt: z.ZodOptional<z.ZodDate>;
+        version: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        expiresAt?: Date;
+        version?: string;
+        issuer?: string;
+        issuedAt?: Date;
+    }, {
+        expiresAt?: Date;
+        version?: string;
+        issuer?: string;
+        issuedAt?: Date;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    id?: string;
+    metadata?: {
+        expiresAt?: Date;
+        version?: string;
+        issuer?: string;
+        issuedAt?: Date;
+    };
+    carId?: string;
+    instructionIntegrity?: {
+        allowedInstructionHashes?: string[];
+        instructionTemplates?: {
+            id?: string;
+            description?: string;
+            hash?: string;
+            parameterSchema?: Record<string, unknown>;
+        }[];
+        instructionSource?: {
+            allowedSources?: string[];
+            requireSignature?: boolean;
+        };
+    };
+    outputBinding?: {
+        allowedSchemas?: {
+            id?: string;
+            description?: string;
+            jsonSchema?: Record<string, unknown>;
+        }[];
+        prohibitedPatterns?: {
+            type?: "regex" | "keyword" | "semantic";
+            pattern?: string;
+            description?: string;
+            severity?: "low" | "medium" | "high" | "critical";
+        }[];
+        allowedExternalEndpoints?: string[];
+        blockedExternalEndpoints?: string[];
+    };
+    inferenceScope?: {
+        globalLevel?: InferenceLevel;
+        domainOverrides?: {
+            level?: InferenceLevel;
+            domain?: "H" | "A" | "B" | "C" | "D" | "F" | "E" | "G" | "I" | "S";
+            reason?: string;
+        }[];
+        derivedKnowledgeHandling?: {
+            retention?: "none" | "session" | "persistent";
+            allowedRecipients?: string[];
+            crossContextSharing?: boolean;
+        };
+        piiInference?: {
+            allowed?: boolean;
+            handling?: "block" | "hash" | "redact";
+        };
+    };
+    contextAuthentication?: {
+        required?: boolean;
+        requiredDomains?: ("H" | "A" | "B" | "C" | "D" | "F" | "E" | "G" | "I" | "S")[];
+        minTrustTier?: TrustTier;
+        allowedProviders?: string[];
+        blockedProviders?: string[];
+        contentIntegrity?: {
+            maxAge?: number;
+            signatureRequired?: boolean;
+            allowedFormats?: string[];
+        };
+    };
+    dualChannel?: {
+        enforced?: boolean;
+        controlPlaneSources?: string[];
+        dataPlaneTreatment?: "warn" | "block" | "sanitize";
+    };
+}, {
+    id?: string;
+    metadata?: {
+        expiresAt?: Date;
+        version?: string;
+        issuer?: string;
+        issuedAt?: Date;
+    };
+    carId?: string;
+    instructionIntegrity?: {
+        allowedInstructionHashes?: string[];
+        instructionTemplates?: {
+            id?: string;
+            description?: string;
+            hash?: string;
+            parameterSchema?: Record<string, unknown>;
+        }[];
+        instructionSource?: {
+            allowedSources?: string[];
+            requireSignature?: boolean;
+        };
+    };
+    outputBinding?: {
+        allowedSchemas?: {
+            id?: string;
+            description?: string;
+            jsonSchema?: Record<string, unknown>;
+        }[];
+        prohibitedPatterns?: {
+            type?: "regex" | "keyword" | "semantic";
+            pattern?: string;
+            description?: string;
+            severity?: "low" | "medium" | "high" | "critical";
+        }[];
+        allowedExternalEndpoints?: string[];
+        blockedExternalEndpoints?: string[];
+    };
+    inferenceScope?: {
+        globalLevel?: InferenceLevel;
+        domainOverrides?: {
+            level?: InferenceLevel;
+            domain?: "H" | "A" | "B" | "C" | "D" | "F" | "E" | "G" | "I" | "S";
+            reason?: string;
+        }[];
+        derivedKnowledgeHandling?: {
+            retention?: "none" | "session" | "persistent";
+            allowedRecipients?: string[];
+            crossContextSharing?: boolean;
+        };
+        piiInference?: {
+            allowed?: boolean;
+            handling?: "block" | "hash" | "redact";
+        };
+    };
+    contextAuthentication?: {
+        required?: boolean;
+        requiredDomains?: ("H" | "A" | "B" | "C" | "D" | "F" | "E" | "G" | "I" | "S")[];
+        minTrustTier?: TrustTier;
+        allowedProviders?: string[];
+        blockedProviders?: string[];
+        contentIntegrity?: {
+            maxAge?: number;
+            signatureRequired?: boolean;
+            allowedFormats?: string[];
+        };
+    };
+    dualChannel?: {
+        enforced?: boolean;
+        controlPlaneSources?: string[];
+        dataPlaneTreatment?: "warn" | "block" | "sanitize";
+    };
+}>;
+/**
+ * Agent identity for semantic governance
+ */
+export interface AgentIdentity {
+    /** Agent DID */
+    did: string;
+    /** Full CAR ID string */
+    carId: string;
+    /** Trust tier */
+    trustTier: TrustTier;
+    /** Capability domains */
+    domains: DomainCode[];
+    /** Service endpoint URL */
+    serviceEndpoint?: string;
+}
+export declare const AgentIdentitySchema: z.ZodObject<{
+    did: z.ZodString;
+    carId: z.ZodString;
+    trustTier: z.ZodNativeEnum<typeof TrustTier>;
+    domains: z.ZodArray<z.ZodEnum<["A", "B", "C", "D", "E", "F", "G", "H", "I", "S"]>, "many">;
+    serviceEndpoint: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    did?: string;
+    trustTier?: TrustTier;
+    domains?: ("H" | "A" | "B" | "C" | "D" | "F" | "E" | "G" | "I" | "S")[];
+    carId?: string;
+    serviceEndpoint?: string;
+}, {
+    did?: string;
+    trustTier?: TrustTier;
+    domains?: ("H" | "A" | "B" | "C" | "D" | "F" | "E" | "G" | "I" | "S")[];
+    carId?: string;
+    serviceEndpoint?: string;
+}>;
+/**
+ * Action request for pre-action validation
+ */
+export interface ActionRequest {
+    /** Action type/name */
+    type: string;
+    /** Target resource */
+    target?: string;
+    /** Action parameters */
+    params?: Record<string, unknown>;
+    /** System instruction */
+    instruction?: string;
+    /** Context sources */
+    contextSources?: Array<{
+        providerId: string;
+        content: unknown;
+        signature?: string;
+    }>;
+    /** Requested inference operations */
+    inferenceOperations?: InferenceOperation[];
+}
+export declare const ActionRequestSchema: z.ZodObject<{
+    type: z.ZodString;
+    target: z.ZodOptional<z.ZodString>;
+    params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    instruction: z.ZodOptional<z.ZodString>;
+    contextSources: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        providerId: z.ZodString;
+        content: z.ZodUnknown;
+        signature: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        content?: unknown;
+        providerId?: string;
+        signature?: string;
+    }, {
+        content?: unknown;
+        providerId?: string;
+        signature?: string;
+    }>, "many">>;
+    inferenceOperations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        type: z.ZodEnum<["aggregate", "count", "average", "entity-extraction", "relationship-inference", "pattern-prediction", "sentiment-analysis", "classification", "summarization", "custom"]>;
+        sourceDomains: z.ZodArray<z.ZodEnum<["A", "B", "C", "D", "E", "F", "G", "H", "I", "S"]>, "many">;
+        description: z.ZodOptional<z.ZodString>;
+        customLevel: z.ZodOptional<z.ZodNativeEnum<typeof InferenceLevel>>;
+    }, "strip", z.ZodTypeAny, {
+        type?: "custom" | "count" | "classification" | "aggregate" | "average" | "entity-extraction" | "relationship-inference" | "pattern-prediction" | "sentiment-analysis" | "summarization";
+        description?: string;
+        sourceDomains?: ("H" | "A" | "B" | "C" | "D" | "F" | "E" | "G" | "I" | "S")[];
+        customLevel?: InferenceLevel;
+    }, {
+        type?: "custom" | "count" | "classification" | "aggregate" | "average" | "entity-extraction" | "relationship-inference" | "pattern-prediction" | "sentiment-analysis" | "summarization";
+        description?: string;
+        sourceDomains?: ("H" | "A" | "B" | "C" | "D" | "F" | "E" | "G" | "I" | "S")[];
+        customLevel?: InferenceLevel;
+    }>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    params?: Record<string, unknown>;
+    type?: string;
+    target?: string;
+    instruction?: string;
+    contextSources?: {
+        content?: unknown;
+        providerId?: string;
+        signature?: string;
+    }[];
+    inferenceOperations?: {
+        type?: "custom" | "count" | "classification" | "aggregate" | "average" | "entity-extraction" | "relationship-inference" | "pattern-prediction" | "sentiment-analysis" | "summarization";
+        description?: string;
+        sourceDomains?: ("H" | "A" | "B" | "C" | "D" | "F" | "E" | "G" | "I" | "S")[];
+        customLevel?: InferenceLevel;
+    }[];
+}, {
+    params?: Record<string, unknown>;
+    type?: string;
+    target?: string;
+    instruction?: string;
+    contextSources?: {
+        content?: unknown;
+        providerId?: string;
+        signature?: string;
+    }[];
+    inferenceOperations?: {
+        type?: "custom" | "count" | "classification" | "aggregate" | "average" | "entity-extraction" | "relationship-inference" | "pattern-prediction" | "sentiment-analysis" | "summarization";
+        description?: string;
+        sourceDomains?: ("H" | "A" | "B" | "C" | "D" | "F" | "E" | "G" | "I" | "S")[];
+        customLevel?: InferenceLevel;
+    }[];
+}>;
+/**
+ * Action record for post-action validation
+ */
+export interface ActionRecord {
+    /** Action type/name */
+    type: string;
+    /** Target resource */
+    target?: string;
+    /** Action output */
+    output: unknown;
+    /** Derived knowledge produced */
+    derivedKnowledge?: DerivedKnowledge[];
+    /** External endpoints accessed */
+    externalEndpoints?: string[];
+    /** Execution duration in ms */
+    durationMs?: number;
+}
+export declare const ActionRecordSchema: z.ZodObject<{
+    type: z.ZodString;
+    target: z.ZodOptional<z.ZodString>;
+    output: z.ZodUnknown;
+    derivedKnowledge: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodEnum<["aggregate", "count", "average", "entity-extraction", "relationship-inference", "pattern-prediction", "sentiment-analysis", "classification", "summarization", "custom"]>;
+        sourceIds: z.ZodArray<z.ZodString, "many">;
+        sourceDomains: z.ZodArray<z.ZodEnum<["A", "B", "C", "D", "E", "F", "G", "H", "I", "S"]>, "many">;
+        content: z.ZodUnknown;
+        createdAt: z.ZodDate;
+        inferenceLevel: z.ZodNativeEnum<typeof InferenceLevel>;
+    }, "strip", z.ZodTypeAny, {
+        id?: string;
+        type?: "custom" | "count" | "classification" | "aggregate" | "average" | "entity-extraction" | "relationship-inference" | "pattern-prediction" | "sentiment-analysis" | "summarization";
+        createdAt?: Date;
+        content?: unknown;
+        sourceDomains?: ("H" | "A" | "B" | "C" | "D" | "F" | "E" | "G" | "I" | "S")[];
+        sourceIds?: string[];
+        inferenceLevel?: InferenceLevel;
+    }, {
+        id?: string;
+        type?: "custom" | "count" | "classification" | "aggregate" | "average" | "entity-extraction" | "relationship-inference" | "pattern-prediction" | "sentiment-analysis" | "summarization";
+        createdAt?: Date;
+        content?: unknown;
+        sourceDomains?: ("H" | "A" | "B" | "C" | "D" | "F" | "E" | "G" | "I" | "S")[];
+        sourceIds?: string[];
+        inferenceLevel?: InferenceLevel;
+    }>, "many">>;
+    externalEndpoints: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    durationMs: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    type?: string;
+    target?: string;
+    durationMs?: number;
+    output?: unknown;
+    derivedKnowledge?: {
+        id?: string;
+        type?: "custom" | "count" | "classification" | "aggregate" | "average" | "entity-extraction" | "relationship-inference" | "pattern-prediction" | "sentiment-analysis" | "summarization";
+        createdAt?: Date;
+        content?: unknown;
+        sourceDomains?: ("H" | "A" | "B" | "C" | "D" | "F" | "E" | "G" | "I" | "S")[];
+        sourceIds?: string[];
+        inferenceLevel?: InferenceLevel;
+    }[];
+    externalEndpoints?: string[];
+}, {
+    type?: string;
+    target?: string;
+    durationMs?: number;
+    output?: unknown;
+    derivedKnowledge?: {
+        id?: string;
+        type?: "custom" | "count" | "classification" | "aggregate" | "average" | "entity-extraction" | "relationship-inference" | "pattern-prediction" | "sentiment-analysis" | "summarization";
+        createdAt?: Date;
+        content?: unknown;
+        sourceDomains?: ("H" | "A" | "B" | "C" | "D" | "F" | "E" | "G" | "I" | "S")[];
+        sourceIds?: string[];
+        inferenceLevel?: InferenceLevel;
+    }[];
+    externalEndpoints?: string[];
+}>;
+/**
+ * Complete agent interaction for validation
+ */
+export interface AgentInteraction {
+    /** Interaction ID */
+    id: string;
+    /** Agent identity */
+    agent: AgentIdentity;
+    /** Incoming message */
+    message: {
+        source: string;
+        content: string;
+        authenticated: boolean;
+        timestamp: Date;
+    };
+    /** System instruction */
+    instruction?: string;
+    /** Context data */
+    context?: Array<{
+        providerId: string;
+        content: unknown;
+        signature?: string;
+        timestamp?: Date;
+    }>;
+    /** Planned/executed action */
+    action?: ActionRequest | ActionRecord;
+}
+export declare const AgentInteractionSchema: z.ZodObject<{
+    id: z.ZodString;
+    agent: z.ZodObject<{
+        did: z.ZodString;
+        carId: z.ZodString;
+        trustTier: z.ZodNativeEnum<typeof TrustTier>;
+        domains: z.ZodArray<z.ZodEnum<["A", "B", "C", "D", "E", "F", "G", "H", "I", "S"]>, "many">;
+        serviceEndpoint: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        did?: string;
+        trustTier?: TrustTier;
+        domains?: ("H" | "A" | "B" | "C" | "D" | "F" | "E" | "G" | "I" | "S")[];
+        carId?: string;
+        serviceEndpoint?: string;
+    }, {
+        did?: string;
+        trustTier?: TrustTier;
+        domains?: ("H" | "A" | "B" | "C" | "D" | "F" | "E" | "G" | "I" | "S")[];
+        carId?: string;
+        serviceEndpoint?: string;
+    }>;
+    message: z.ZodObject<{
+        source: z.ZodString;
+        content: z.ZodString;
+        authenticated: z.ZodBoolean;
+        timestamp: z.ZodDate;
+    }, "strip", z.ZodTypeAny, {
+        timestamp?: Date;
+        content?: string;
+        source?: string;
+        authenticated?: boolean;
+    }, {
+        timestamp?: Date;
+        content?: string;
+        source?: string;
+        authenticated?: boolean;
+    }>;
+    instruction: z.ZodOptional<z.ZodString>;
+    context: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        providerId: z.ZodString;
+        content: z.ZodUnknown;
+        signature: z.ZodOptional<z.ZodString>;
+        timestamp: z.ZodOptional<z.ZodDate>;
+    }, "strip", z.ZodTypeAny, {
+        timestamp?: Date;
+        content?: unknown;
+        providerId?: string;
+        signature?: string;
+    }, {
+        timestamp?: Date;
+        content?: unknown;
+        providerId?: string;
+        signature?: string;
+    }>, "many">>;
+    action: z.ZodOptional<z.ZodUnion<[z.ZodObject<{
+        type: z.ZodString;
+        target: z.ZodOptional<z.ZodString>;
+        params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        instruction: z.ZodOptional<z.ZodString>;
+        contextSources: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            providerId: z.ZodString;
+            content: z.ZodUnknown;
+            signature: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            content?: unknown;
+            providerId?: string;
+            signature?: string;
+        }, {
+            content?: unknown;
+            providerId?: string;
+            signature?: string;
+        }>, "many">>;
+        inferenceOperations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            type: z.ZodEnum<["aggregate", "count", "average", "entity-extraction", "relationship-inference", "pattern-prediction", "sentiment-analysis", "classification", "summarization", "custom"]>;
+            sourceDomains: z.ZodArray<z.ZodEnum<["A", "B", "C", "D", "E", "F", "G", "H", "I", "S"]>, "many">;
+            description: z.ZodOptional<z.ZodString>;
+            customLevel: z.ZodOptional<z.ZodNativeEnum<typeof InferenceLevel>>;
+        }, "strip", z.ZodTypeAny, {
+            type?: "custom" | "count" | "classification" | "aggregate" | "average" | "entity-extraction" | "relationship-inference" | "pattern-prediction" | "sentiment-analysis" | "summarization";
+            description?: string;
+            sourceDomains?: ("H" | "A" | "B" | "C" | "D" | "F" | "E" | "G" | "I" | "S")[];
+            customLevel?: InferenceLevel;
+        }, {
+            type?: "custom" | "count" | "classification" | "aggregate" | "average" | "entity-extraction" | "relationship-inference" | "pattern-prediction" | "sentiment-analysis" | "summarization";
+            description?: string;
+            sourceDomains?: ("H" | "A" | "B" | "C" | "D" | "F" | "E" | "G" | "I" | "S")[];
+            customLevel?: InferenceLevel;
+        }>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        params?: Record<string, unknown>;
+        type?: string;
+        target?: string;
+        instruction?: string;
+        contextSources?: {
+            content?: unknown;
+            providerId?: string;
+            signature?: string;
+        }[];
+        inferenceOperations?: {
+            type?: "custom" | "count" | "classification" | "aggregate" | "average" | "entity-extraction" | "relationship-inference" | "pattern-prediction" | "sentiment-analysis" | "summarization";
+            description?: string;
+            sourceDomains?: ("H" | "A" | "B" | "C" | "D" | "F" | "E" | "G" | "I" | "S")[];
+            customLevel?: InferenceLevel;
+        }[];
+    }, {
+        params?: Record<string, unknown>;
+        type?: string;
+        target?: string;
+        instruction?: string;
+        contextSources?: {
+            content?: unknown;
+            providerId?: string;
+            signature?: string;
+        }[];
+        inferenceOperations?: {
+            type?: "custom" | "count" | "classification" | "aggregate" | "average" | "entity-extraction" | "relationship-inference" | "pattern-prediction" | "sentiment-analysis" | "summarization";
+            description?: string;
+            sourceDomains?: ("H" | "A" | "B" | "C" | "D" | "F" | "E" | "G" | "I" | "S")[];
+            customLevel?: InferenceLevel;
+        }[];
+    }>, z.ZodObject<{
+        type: z.ZodString;
+        target: z.ZodOptional<z.ZodString>;
+        output: z.ZodUnknown;
+        derivedKnowledge: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            type: z.ZodEnum<["aggregate", "count", "average", "entity-extraction", "relationship-inference", "pattern-prediction", "sentiment-analysis", "classification", "summarization", "custom"]>;
+            sourceIds: z.ZodArray<z.ZodString, "many">;
+            sourceDomains: z.ZodArray<z.ZodEnum<["A", "B", "C", "D", "E", "F", "G", "H", "I", "S"]>, "many">;
+            content: z.ZodUnknown;
+            createdAt: z.ZodDate;
+            inferenceLevel: z.ZodNativeEnum<typeof InferenceLevel>;
+        }, "strip", z.ZodTypeAny, {
+            id?: string;
+            type?: "custom" | "count" | "classification" | "aggregate" | "average" | "entity-extraction" | "relationship-inference" | "pattern-prediction" | "sentiment-analysis" | "summarization";
+            createdAt?: Date;
+            content?: unknown;
+            sourceDomains?: ("H" | "A" | "B" | "C" | "D" | "F" | "E" | "G" | "I" | "S")[];
+            sourceIds?: string[];
+            inferenceLevel?: InferenceLevel;
+        }, {
+            id?: string;
+            type?: "custom" | "count" | "classification" | "aggregate" | "average" | "entity-extraction" | "relationship-inference" | "pattern-prediction" | "sentiment-analysis" | "summarization";
+            createdAt?: Date;
+            content?: unknown;
+            sourceDomains?: ("H" | "A" | "B" | "C" | "D" | "F" | "E" | "G" | "I" | "S")[];
+            sourceIds?: string[];
+            inferenceLevel?: InferenceLevel;
+        }>, "many">>;
+        externalEndpoints: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        durationMs: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        type?: string;
+        target?: string;
+        durationMs?: number;
+        output?: unknown;
+        derivedKnowledge?: {
+            id?: string;
+            type?: "custom" | "count" | "classification" | "aggregate" | "average" | "entity-extraction" | "relationship-inference" | "pattern-prediction" | "sentiment-analysis" | "summarization";
+            createdAt?: Date;
+            content?: unknown;
+            sourceDomains?: ("H" | "A" | "B" | "C" | "D" | "F" | "E" | "G" | "I" | "S")[];
+            sourceIds?: string[];
+            inferenceLevel?: InferenceLevel;
+        }[];
+        externalEndpoints?: string[];
+    }, {
+        type?: string;
+        target?: string;
+        durationMs?: number;
+        output?: unknown;
+        derivedKnowledge?: {
+            id?: string;
+            type?: "custom" | "count" | "classification" | "aggregate" | "average" | "entity-extraction" | "relationship-inference" | "pattern-prediction" | "sentiment-analysis" | "summarization";
+            createdAt?: Date;
+            content?: unknown;
+            sourceDomains?: ("H" | "A" | "B" | "C" | "D" | "F" | "E" | "G" | "I" | "S")[];
+            sourceIds?: string[];
+            inferenceLevel?: InferenceLevel;
+        }[];
+        externalEndpoints?: string[];
+    }>]>>;
+}, "strip", z.ZodTypeAny, {
+    id?: string;
+    message?: {
+        timestamp?: Date;
+        content?: string;
+        source?: string;
+        authenticated?: boolean;
+    };
+    agent?: {
+        did?: string;
+        trustTier?: TrustTier;
+        domains?: ("H" | "A" | "B" | "C" | "D" | "F" | "E" | "G" | "I" | "S")[];
+        carId?: string;
+        serviceEndpoint?: string;
+    };
+    context?: {
+        timestamp?: Date;
+        content?: unknown;
+        providerId?: string;
+        signature?: string;
+    }[];
+    action?: {
+        params?: Record<string, unknown>;
+        type?: string;
+        target?: string;
+        instruction?: string;
+        contextSources?: {
+            content?: unknown;
+            providerId?: string;
+            signature?: string;
+        }[];
+        inferenceOperations?: {
+            type?: "custom" | "count" | "classification" | "aggregate" | "average" | "entity-extraction" | "relationship-inference" | "pattern-prediction" | "sentiment-analysis" | "summarization";
+            description?: string;
+            sourceDomains?: ("H" | "A" | "B" | "C" | "D" | "F" | "E" | "G" | "I" | "S")[];
+            customLevel?: InferenceLevel;
+        }[];
+    } | {
+        type?: string;
+        target?: string;
+        durationMs?: number;
+        output?: unknown;
+        derivedKnowledge?: {
+            id?: string;
+            type?: "custom" | "count" | "classification" | "aggregate" | "average" | "entity-extraction" | "relationship-inference" | "pattern-prediction" | "sentiment-analysis" | "summarization";
+            createdAt?: Date;
+            content?: unknown;
+            sourceDomains?: ("H" | "A" | "B" | "C" | "D" | "F" | "E" | "G" | "I" | "S")[];
+            sourceIds?: string[];
+            inferenceLevel?: InferenceLevel;
+        }[];
+        externalEndpoints?: string[];
+    };
+    instruction?: string;
+}, {
+    id?: string;
+    message?: {
+        timestamp?: Date;
+        content?: string;
+        source?: string;
+        authenticated?: boolean;
+    };
+    agent?: {
+        did?: string;
+        trustTier?: TrustTier;
+        domains?: ("H" | "A" | "B" | "C" | "D" | "F" | "E" | "G" | "I" | "S")[];
+        carId?: string;
+        serviceEndpoint?: string;
+    };
+    context?: {
+        timestamp?: Date;
+        content?: unknown;
+        providerId?: string;
+        signature?: string;
+    }[];
+    action?: {
+        params?: Record<string, unknown>;
+        type?: string;
+        target?: string;
+        instruction?: string;
+        contextSources?: {
+            content?: unknown;
+            providerId?: string;
+            signature?: string;
+        }[];
+        inferenceOperations?: {
+            type?: "custom" | "count" | "classification" | "aggregate" | "average" | "entity-extraction" | "relationship-inference" | "pattern-prediction" | "sentiment-analysis" | "summarization";
+            description?: string;
+            sourceDomains?: ("H" | "A" | "B" | "C" | "D" | "F" | "E" | "G" | "I" | "S")[];
+            customLevel?: InferenceLevel;
+        }[];
+    } | {
+        type?: string;
+        target?: string;
+        durationMs?: number;
+        output?: unknown;
+        derivedKnowledge?: {
+            id?: string;
+            type?: "custom" | "count" | "classification" | "aggregate" | "average" | "entity-extraction" | "relationship-inference" | "pattern-prediction" | "sentiment-analysis" | "summarization";
+            createdAt?: Date;
+            content?: unknown;
+            sourceDomains?: ("H" | "A" | "B" | "C" | "D" | "F" | "E" | "G" | "I" | "S")[];
+            sourceIds?: string[];
+            inferenceLevel?: InferenceLevel;
+        }[];
+        externalEndpoints?: string[];
+    };
+    instruction?: string;
+}>;
+/**
+ * Pre-action validation result
+ */
+export interface PreActionResult {
+    /** Whether action is allowed to proceed */
+    allowed: boolean;
+    /** Reason for rejection */
+    reason?: string;
+    /** Instruction validation result */
+    instructionValidation?: InstructionValidationResult;
+    /** Context validation results */
+    contextValidations?: ContextValidationResult[];
+    /** Inference validation results */
+    inferenceValidations?: InferenceValidationResult[];
+    /** Channel enforcement result */
+    channelEnforcement?: EnforcementResult;
+    /** Warnings (action allowed but with caveats) */
+    warnings?: string[];
+}
+export declare const PreActionResultSchema: z.ZodObject<{
+    allowed: z.ZodBoolean;
+    reason: z.ZodOptional<z.ZodString>;
+    instructionValidation: z.ZodOptional<z.ZodObject<{
+        valid: z.ZodBoolean;
+        method: z.ZodOptional<z.ZodEnum<["exact-match", "template-match", "signed-source"]>>;
+        templateId: z.ZodOptional<z.ZodString>;
+        reason: z.ZodOptional<z.ZodString>;
+        instructionHash: z.ZodOptional<z.ZodString>;
+        extractedParams: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strip", z.ZodTypeAny, {
+        valid?: boolean;
+        method?: "exact-match" | "template-match" | "signed-source";
+        reason?: string;
+        templateId?: string;
+        instructionHash?: string;
+        extractedParams?: Record<string, unknown>;
+    }, {
+        valid?: boolean;
+        method?: "exact-match" | "template-match" | "signed-source";
+        reason?: string;
+        templateId?: string;
+        instructionHash?: string;
+        extractedParams?: Record<string, unknown>;
+    }>>;
+    contextValidations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        valid: z.ZodBoolean;
+        reason: z.ZodOptional<z.ZodString>;
+        providerValidation: z.ZodOptional<z.ZodObject<{
+            valid: z.ZodBoolean;
+            providerId: z.ZodString;
+            trustTier: z.ZodOptional<z.ZodNativeEnum<typeof TrustTier>>;
+            reason: z.ZodOptional<z.ZodString>;
+            blocked: z.ZodOptional<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            valid?: boolean;
+            providerId?: string;
+            reason?: string;
+            blocked?: boolean;
+            trustTier?: TrustTier;
+        }, {
+            valid?: boolean;
+            providerId?: string;
+            reason?: string;
+            blocked?: boolean;
+            trustTier?: TrustTier;
+        }>>;
+        contentValidation: z.ZodOptional<z.ZodObject<{
+            valid: z.ZodBoolean;
+            signatureValid: z.ZodOptional<z.ZodBoolean>;
+            ageSeconds: z.ZodOptional<z.ZodNumber>;
+            format: z.ZodOptional<z.ZodString>;
+            reason: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            valid?: boolean;
+            reason?: string;
+            format?: string;
+            signatureValid?: boolean;
+            ageSeconds?: number;
+        }, {
+            valid?: boolean;
+            reason?: string;
+            format?: string;
+            signatureValid?: boolean;
+            ageSeconds?: number;
+        }>>;
+        injectionScan: z.ZodOptional<z.ZodObject<{
+            detected: z.ZodBoolean;
+            patterns: z.ZodArray<z.ZodString, "many">;
+            severity: z.ZodOptional<z.ZodEnum<["low", "medium", "high", "critical"]>>;
+            descriptions: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            severity?: "low" | "medium" | "high" | "critical";
+            detected?: boolean;
+            patterns?: string[];
+            descriptions?: string[];
+        }, {
+            severity?: "low" | "medium" | "high" | "critical";
+            detected?: boolean;
+            patterns?: string[];
+            descriptions?: string[];
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        valid?: boolean;
+        reason?: string;
+        providerValidation?: {
+            valid?: boolean;
+            providerId?: string;
+            reason?: string;
+            blocked?: boolean;
+            trustTier?: TrustTier;
+        };
+        contentValidation?: {
+            valid?: boolean;
+            reason?: string;
+            format?: string;
+            signatureValid?: boolean;
+            ageSeconds?: number;
+        };
+        injectionScan?: {
+            severity?: "low" | "medium" | "high" | "critical";
+            detected?: boolean;
+            patterns?: string[];
+            descriptions?: string[];
+        };
+    }, {
+        valid?: boolean;
+        reason?: string;
+        providerValidation?: {
+            valid?: boolean;
+            providerId?: string;
+            reason?: string;
+            blocked?: boolean;
+            trustTier?: TrustTier;
+        };
+        contentValidation?: {
+            valid?: boolean;
+            reason?: string;
+            format?: string;
+            signatureValid?: boolean;
+            ageSeconds?: number;
+        };
+        injectionScan?: {
+            severity?: "low" | "medium" | "high" | "critical";
+            detected?: boolean;
+            patterns?: string[];
+            descriptions?: string[];
+        };
+    }>, "many">>;
+    inferenceValidations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        valid: z.ZodBoolean;
+        reason: z.ZodOptional<z.ZodString>;
+        requiredLevel: z.ZodOptional<z.ZodNativeEnum<typeof InferenceLevel>>;
+        agentLevel: z.ZodOptional<z.ZodNativeEnum<typeof InferenceLevel>>;
+        restrictedDomain: z.ZodOptional<z.ZodEnum<["A", "B", "C", "D", "E", "F", "G", "H", "I", "S"]>>;
+    }, "strip", z.ZodTypeAny, {
+        valid?: boolean;
+        reason?: string;
+        requiredLevel?: InferenceLevel;
+        agentLevel?: InferenceLevel;
+        restrictedDomain?: "H" | "A" | "B" | "C" | "D" | "F" | "E" | "G" | "I" | "S";
+    }, {
+        valid?: boolean;
+        reason?: string;
+        requiredLevel?: InferenceLevel;
+        agentLevel?: InferenceLevel;
+        restrictedDomain?: "H" | "A" | "B" | "C" | "D" | "F" | "E" | "G" | "I" | "S";
+    }>, "many">>;
+    channelEnforcement: z.ZodOptional<z.ZodObject<{
+        allowed: z.ZodBoolean;
+        action: z.ZodEnum<["pass", "block", "sanitize", "warn"]>;
+        reason: z.ZodOptional<z.ZodString>;
+        sanitizedContent: z.ZodOptional<z.ZodString>;
+        strippedInstructions: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        reason?: string;
+        action?: "warn" | "block" | "pass" | "sanitize";
+        allowed?: boolean;
+        sanitizedContent?: string;
+        strippedInstructions?: string[];
+    }, {
+        reason?: string;
+        action?: "warn" | "block" | "pass" | "sanitize";
+        allowed?: boolean;
+        sanitizedContent?: string;
+        strippedInstructions?: string[];
+    }>>;
+    warnings: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    reason?: string;
+    allowed?: boolean;
+    warnings?: string[];
+    instructionValidation?: {
+        valid?: boolean;
+        method?: "exact-match" | "template-match" | "signed-source";
+        reason?: string;
+        templateId?: string;
+        instructionHash?: string;
+        extractedParams?: Record<string, unknown>;
+    };
+    contextValidations?: {
+        valid?: boolean;
+        reason?: string;
+        providerValidation?: {
+            valid?: boolean;
+            providerId?: string;
+            reason?: string;
+            blocked?: boolean;
+            trustTier?: TrustTier;
+        };
+        contentValidation?: {
+            valid?: boolean;
+            reason?: string;
+            format?: string;
+            signatureValid?: boolean;
+            ageSeconds?: number;
+        };
+        injectionScan?: {
+            severity?: "low" | "medium" | "high" | "critical";
+            detected?: boolean;
+            patterns?: string[];
+            descriptions?: string[];
+        };
+    }[];
+    inferenceValidations?: {
+        valid?: boolean;
+        reason?: string;
+        requiredLevel?: InferenceLevel;
+        agentLevel?: InferenceLevel;
+        restrictedDomain?: "H" | "A" | "B" | "C" | "D" | "F" | "E" | "G" | "I" | "S";
+    }[];
+    channelEnforcement?: {
+        reason?: string;
+        action?: "warn" | "block" | "pass" | "sanitize";
+        allowed?: boolean;
+        sanitizedContent?: string;
+        strippedInstructions?: string[];
+    };
+}, {
+    reason?: string;
+    allowed?: boolean;
+    warnings?: string[];
+    instructionValidation?: {
+        valid?: boolean;
+        method?: "exact-match" | "template-match" | "signed-source";
+        reason?: string;
+        templateId?: string;
+        instructionHash?: string;
+        extractedParams?: Record<string, unknown>;
+    };
+    contextValidations?: {
+        valid?: boolean;
+        reason?: string;
+        providerValidation?: {
+            valid?: boolean;
+            providerId?: string;
+            reason?: string;
+            blocked?: boolean;
+            trustTier?: TrustTier;
+        };
+        contentValidation?: {
+            valid?: boolean;
+            reason?: string;
+            format?: string;
+            signatureValid?: boolean;
+            ageSeconds?: number;
+        };
+        injectionScan?: {
+            severity?: "low" | "medium" | "high" | "critical";
+            detected?: boolean;
+            patterns?: string[];
+            descriptions?: string[];
+        };
+    }[];
+    inferenceValidations?: {
+        valid?: boolean;
+        reason?: string;
+        requiredLevel?: InferenceLevel;
+        agentLevel?: InferenceLevel;
+        restrictedDomain?: "H" | "A" | "B" | "C" | "D" | "F" | "E" | "G" | "I" | "S";
+    }[];
+    channelEnforcement?: {
+        reason?: string;
+        action?: "warn" | "block" | "pass" | "sanitize";
+        allowed?: boolean;
+        sanitizedContent?: string;
+        strippedInstructions?: string[];
+    };
+}>;
+/**
+ * Post-action validation result
+ */
+export interface PostActionResult {
+    /** Whether action result is valid */
+    valid: boolean;
+    /** Reason for rejection */
+    reason?: string;
+    /** Output validation result */
+    outputValidation?: OutputValidationResult;
+    /** Inference validation results */
+    inferenceValidations?: InferenceValidationResult[];
+    /** PII check results */
+    piiChecks?: PIICheckResult[];
+    /** Sanitized output (if modified) */
+    sanitizedOutput?: unknown;
+    /** Warnings */
+    warnings?: string[];
+}
+export declare const PostActionResultSchema: z.ZodObject<{
+    valid: z.ZodBoolean;
+    reason: z.ZodOptional<z.ZodString>;
+    outputValidation: z.ZodOptional<z.ZodObject<{
+        valid: z.ZodBoolean;
+        modified: z.ZodOptional<z.ZodBoolean>;
+        output: z.ZodOptional<z.ZodUnknown>;
+        schemaId: z.ZodOptional<z.ZodString>;
+        reason: z.ZodOptional<z.ZodString>;
+        patternScan: z.ZodOptional<z.ZodObject<{
+            detected: z.ZodBoolean;
+            patterns: z.ZodArray<z.ZodObject<{
+                type: z.ZodEnum<["regex", "keyword", "semantic"]>;
+                pattern: z.ZodString;
+                description: z.ZodString;
+                matches: z.ZodArray<z.ZodString, "many">;
+                severity: z.ZodOptional<z.ZodEnum<["low", "medium", "high", "critical"]>>;
+            }, "strip", z.ZodTypeAny, {
+                type?: "regex" | "keyword" | "semantic";
+                pattern?: string;
+                description?: string;
+                severity?: "low" | "medium" | "high" | "critical";
+                matches?: string[];
+            }, {
+                type?: "regex" | "keyword" | "semantic";
+                pattern?: string;
+                description?: string;
+                severity?: "low" | "medium" | "high" | "critical";
+                matches?: string[];
+            }>, "many">;
+            severity: z.ZodOptional<z.ZodEnum<["low", "medium", "high", "critical"]>>;
+        }, "strip", z.ZodTypeAny, {
+            severity?: "low" | "medium" | "high" | "critical";
+            detected?: boolean;
+            patterns?: {
+                type?: "regex" | "keyword" | "semantic";
+                pattern?: string;
+                description?: string;
+                severity?: "low" | "medium" | "high" | "critical";
+                matches?: string[];
+            }[];
+        }, {
+            severity?: "low" | "medium" | "high" | "critical";
+            detected?: boolean;
+            patterns?: {
+                type?: "regex" | "keyword" | "semantic";
+                pattern?: string;
+                description?: string;
+                severity?: "low" | "medium" | "high" | "critical";
+                matches?: string[];
+            }[];
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        valid?: boolean;
+        reason?: string;
+        output?: unknown;
+        modified?: boolean;
+        schemaId?: string;
+        patternScan?: {
+            severity?: "low" | "medium" | "high" | "critical";
+            detected?: boolean;
+            patterns?: {
+                type?: "regex" | "keyword" | "semantic";
+                pattern?: string;
+                description?: string;
+                severity?: "low" | "medium" | "high" | "critical";
+                matches?: string[];
+            }[];
+        };
+    }, {
+        valid?: boolean;
+        reason?: string;
+        output?: unknown;
+        modified?: boolean;
+        schemaId?: string;
+        patternScan?: {
+            severity?: "low" | "medium" | "high" | "critical";
+            detected?: boolean;
+            patterns?: {
+                type?: "regex" | "keyword" | "semantic";
+                pattern?: string;
+                description?: string;
+                severity?: "low" | "medium" | "high" | "critical";
+                matches?: string[];
+            }[];
+        };
+    }>>;
+    inferenceValidations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        valid: z.ZodBoolean;
+        reason: z.ZodOptional<z.ZodString>;
+        requiredLevel: z.ZodOptional<z.ZodNativeEnum<typeof InferenceLevel>>;
+        agentLevel: z.ZodOptional<z.ZodNativeEnum<typeof InferenceLevel>>;
+        restrictedDomain: z.ZodOptional<z.ZodEnum<["A", "B", "C", "D", "E", "F", "G", "H", "I", "S"]>>;
+    }, "strip", z.ZodTypeAny, {
+        valid?: boolean;
+        reason?: string;
+        requiredLevel?: InferenceLevel;
+        agentLevel?: InferenceLevel;
+        restrictedDomain?: "H" | "A" | "B" | "C" | "D" | "F" | "E" | "G" | "I" | "S";
+    }, {
+        valid?: boolean;
+        reason?: string;
+        requiredLevel?: InferenceLevel;
+        agentLevel?: InferenceLevel;
+        restrictedDomain?: "H" | "A" | "B" | "C" | "D" | "F" | "E" | "G" | "I" | "S";
+    }>, "many">>;
+    piiChecks: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        containsPII: z.ZodBoolean;
+        piiTypes: z.ZodArray<z.ZodString, "many">;
+        action: z.ZodEnum<["allowed", "blocked", "redacted", "hashed"]>;
+        modifiedData: z.ZodOptional<z.ZodUnknown>;
+    }, "strip", z.ZodTypeAny, {
+        action?: "blocked" | "redacted" | "allowed" | "hashed";
+        containsPII?: boolean;
+        piiTypes?: string[];
+        modifiedData?: unknown;
+    }, {
+        action?: "blocked" | "redacted" | "allowed" | "hashed";
+        containsPII?: boolean;
+        piiTypes?: string[];
+        modifiedData?: unknown;
+    }>, "many">>;
+    sanitizedOutput: z.ZodOptional<z.ZodUnknown>;
+    warnings: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    valid?: boolean;
+    reason?: string;
+    warnings?: string[];
+    inferenceValidations?: {
+        valid?: boolean;
+        reason?: string;
+        requiredLevel?: InferenceLevel;
+        agentLevel?: InferenceLevel;
+        restrictedDomain?: "H" | "A" | "B" | "C" | "D" | "F" | "E" | "G" | "I" | "S";
+    }[];
+    outputValidation?: {
+        valid?: boolean;
+        reason?: string;
+        output?: unknown;
+        modified?: boolean;
+        schemaId?: string;
+        patternScan?: {
+            severity?: "low" | "medium" | "high" | "critical";
+            detected?: boolean;
+            patterns?: {
+                type?: "regex" | "keyword" | "semantic";
+                pattern?: string;
+                description?: string;
+                severity?: "low" | "medium" | "high" | "critical";
+                matches?: string[];
+            }[];
+        };
+    };
+    piiChecks?: {
+        action?: "blocked" | "redacted" | "allowed" | "hashed";
+        containsPII?: boolean;
+        piiTypes?: string[];
+        modifiedData?: unknown;
+    }[];
+    sanitizedOutput?: unknown;
+}, {
+    valid?: boolean;
+    reason?: string;
+    warnings?: string[];
+    inferenceValidations?: {
+        valid?: boolean;
+        reason?: string;
+        requiredLevel?: InferenceLevel;
+        agentLevel?: InferenceLevel;
+        restrictedDomain?: "H" | "A" | "B" | "C" | "D" | "F" | "E" | "G" | "I" | "S";
+    }[];
+    outputValidation?: {
+        valid?: boolean;
+        reason?: string;
+        output?: unknown;
+        modified?: boolean;
+        schemaId?: string;
+        patternScan?: {
+            severity?: "low" | "medium" | "high" | "critical";
+            detected?: boolean;
+            patterns?: {
+                type?: "regex" | "keyword" | "semantic";
+                pattern?: string;
+                description?: string;
+                severity?: "low" | "medium" | "high" | "critical";
+                matches?: string[];
+            }[];
+        };
+    };
+    piiChecks?: {
+        action?: "blocked" | "redacted" | "allowed" | "hashed";
+        containsPII?: boolean;
+        piiTypes?: string[];
+        modifiedData?: unknown;
+    }[];
+    sanitizedOutput?: unknown;
+}>;
+/**
+ * Complete semantic validation result
+ */
+export interface SemanticValidationResult {
+    /** Whether interaction is valid */
+    valid: boolean;
+    /** Interaction ID */
+    interactionId: string;
+    /** Agent DID */
+    agentDid: string;
+    /** Pre-action result */
+    preAction?: PreActionResult;
+    /** Post-action result */
+    postAction?: PostActionResult;
+    /** Overall reason for failure */
+    reason?: string;
+    /** Validation timestamp */
+    validatedAt: Date;
+    /** Validation duration in ms */
+    durationMs: number;
+}
+export declare const SemanticValidationResultSchema: z.ZodObject<{
+    valid: z.ZodBoolean;
+    interactionId: z.ZodString;
+    agentDid: z.ZodString;
+    preAction: z.ZodOptional<z.ZodObject<{
+        allowed: z.ZodBoolean;
+        reason: z.ZodOptional<z.ZodString>;
+        instructionValidation: z.ZodOptional<z.ZodObject<{
+            valid: z.ZodBoolean;
+            method: z.ZodOptional<z.ZodEnum<["exact-match", "template-match", "signed-source"]>>;
+            templateId: z.ZodOptional<z.ZodString>;
+            reason: z.ZodOptional<z.ZodString>;
+            instructionHash: z.ZodOptional<z.ZodString>;
+            extractedParams: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, "strip", z.ZodTypeAny, {
+            valid?: boolean;
+            method?: "exact-match" | "template-match" | "signed-source";
+            reason?: string;
+            templateId?: string;
+            instructionHash?: string;
+            extractedParams?: Record<string, unknown>;
+        }, {
+            valid?: boolean;
+            method?: "exact-match" | "template-match" | "signed-source";
+            reason?: string;
+            templateId?: string;
+            instructionHash?: string;
+            extractedParams?: Record<string, unknown>;
+        }>>;
+        contextValidations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            valid: z.ZodBoolean;
+            reason: z.ZodOptional<z.ZodString>;
+            providerValidation: z.ZodOptional<z.ZodObject<{
+                valid: z.ZodBoolean;
+                providerId: z.ZodString;
+                trustTier: z.ZodOptional<z.ZodNativeEnum<typeof TrustTier>>;
+                reason: z.ZodOptional<z.ZodString>;
+                blocked: z.ZodOptional<z.ZodBoolean>;
+            }, "strip", z.ZodTypeAny, {
+                valid?: boolean;
+                providerId?: string;
+                reason?: string;
+                blocked?: boolean;
+                trustTier?: TrustTier;
+            }, {
+                valid?: boolean;
+                providerId?: string;
+                reason?: string;
+                blocked?: boolean;
+                trustTier?: TrustTier;
+            }>>;
+            contentValidation: z.ZodOptional<z.ZodObject<{
+                valid: z.ZodBoolean;
+                signatureValid: z.ZodOptional<z.ZodBoolean>;
+                ageSeconds: z.ZodOptional<z.ZodNumber>;
+                format: z.ZodOptional<z.ZodString>;
+                reason: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                valid?: boolean;
+                reason?: string;
+                format?: string;
+                signatureValid?: boolean;
+                ageSeconds?: number;
+            }, {
+                valid?: boolean;
+                reason?: string;
+                format?: string;
+                signatureValid?: boolean;
+                ageSeconds?: number;
+            }>>;
+            injectionScan: z.ZodOptional<z.ZodObject<{
+                detected: z.ZodBoolean;
+                patterns: z.ZodArray<z.ZodString, "many">;
+                severity: z.ZodOptional<z.ZodEnum<["low", "medium", "high", "critical"]>>;
+                descriptions: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            }, "strip", z.ZodTypeAny, {
+                severity?: "low" | "medium" | "high" | "critical";
+                detected?: boolean;
+                patterns?: string[];
+                descriptions?: string[];
+            }, {
+                severity?: "low" | "medium" | "high" | "critical";
+                detected?: boolean;
+                patterns?: string[];
+                descriptions?: string[];
+            }>>;
+        }, "strip", z.ZodTypeAny, {
+            valid?: boolean;
+            reason?: string;
+            providerValidation?: {
+                valid?: boolean;
+                providerId?: string;
+                reason?: string;
+                blocked?: boolean;
+                trustTier?: TrustTier;
+            };
+            contentValidation?: {
+                valid?: boolean;
+                reason?: string;
+                format?: string;
+                signatureValid?: boolean;
+                ageSeconds?: number;
+            };
+            injectionScan?: {
+                severity?: "low" | "medium" | "high" | "critical";
+                detected?: boolean;
+                patterns?: string[];
+                descriptions?: string[];
+            };
+        }, {
+            valid?: boolean;
+            reason?: string;
+            providerValidation?: {
+                valid?: boolean;
+                providerId?: string;
+                reason?: string;
+                blocked?: boolean;
+                trustTier?: TrustTier;
+            };
+            contentValidation?: {
+                valid?: boolean;
+                reason?: string;
+                format?: string;
+                signatureValid?: boolean;
+                ageSeconds?: number;
+            };
+            injectionScan?: {
+                severity?: "low" | "medium" | "high" | "critical";
+                detected?: boolean;
+                patterns?: string[];
+                descriptions?: string[];
+            };
+        }>, "many">>;
+        inferenceValidations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            valid: z.ZodBoolean;
+            reason: z.ZodOptional<z.ZodString>;
+            requiredLevel: z.ZodOptional<z.ZodNativeEnum<typeof InferenceLevel>>;
+            agentLevel: z.ZodOptional<z.ZodNativeEnum<typeof InferenceLevel>>;
+            restrictedDomain: z.ZodOptional<z.ZodEnum<["A", "B", "C", "D", "E", "F", "G", "H", "I", "S"]>>;
+        }, "strip", z.ZodTypeAny, {
+            valid?: boolean;
+            reason?: string;
+            requiredLevel?: InferenceLevel;
+            agentLevel?: InferenceLevel;
+            restrictedDomain?: "H" | "A" | "B" | "C" | "D" | "F" | "E" | "G" | "I" | "S";
+        }, {
+            valid?: boolean;
+            reason?: string;
+            requiredLevel?: InferenceLevel;
+            agentLevel?: InferenceLevel;
+            restrictedDomain?: "H" | "A" | "B" | "C" | "D" | "F" | "E" | "G" | "I" | "S";
+        }>, "many">>;
+        channelEnforcement: z.ZodOptional<z.ZodObject<{
+            allowed: z.ZodBoolean;
+            action: z.ZodEnum<["pass", "block", "sanitize", "warn"]>;
+            reason: z.ZodOptional<z.ZodString>;
+            sanitizedContent: z.ZodOptional<z.ZodString>;
+            strippedInstructions: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            reason?: string;
+            action?: "warn" | "block" | "pass" | "sanitize";
+            allowed?: boolean;
+            sanitizedContent?: string;
+            strippedInstructions?: string[];
+        }, {
+            reason?: string;
+            action?: "warn" | "block" | "pass" | "sanitize";
+            allowed?: boolean;
+            sanitizedContent?: string;
+            strippedInstructions?: string[];
+        }>>;
+        warnings: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        reason?: string;
+        allowed?: boolean;
+        warnings?: string[];
+        instructionValidation?: {
+            valid?: boolean;
+            method?: "exact-match" | "template-match" | "signed-source";
+            reason?: string;
+            templateId?: string;
+            instructionHash?: string;
+            extractedParams?: Record<string, unknown>;
+        };
+        contextValidations?: {
+            valid?: boolean;
+            reason?: string;
+            providerValidation?: {
+                valid?: boolean;
+                providerId?: string;
+                reason?: string;
+                blocked?: boolean;
+                trustTier?: TrustTier;
+            };
+            contentValidation?: {
+                valid?: boolean;
+                reason?: string;
+                format?: string;
+                signatureValid?: boolean;
+                ageSeconds?: number;
+            };
+            injectionScan?: {
+                severity?: "low" | "medium" | "high" | "critical";
+                detected?: boolean;
+                patterns?: string[];
+                descriptions?: string[];
+            };
+        }[];
+        inferenceValidations?: {
+            valid?: boolean;
+            reason?: string;
+            requiredLevel?: InferenceLevel;
+            agentLevel?: InferenceLevel;
+            restrictedDomain?: "H" | "A" | "B" | "C" | "D" | "F" | "E" | "G" | "I" | "S";
+        }[];
+        channelEnforcement?: {
+            reason?: string;
+            action?: "warn" | "block" | "pass" | "sanitize";
+            allowed?: boolean;
+            sanitizedContent?: string;
+            strippedInstructions?: string[];
+        };
+    }, {
+        reason?: string;
+        allowed?: boolean;
+        warnings?: string[];
+        instructionValidation?: {
+            valid?: boolean;
+            method?: "exact-match" | "template-match" | "signed-source";
+            reason?: string;
+            templateId?: string;
+            instructionHash?: string;
+            extractedParams?: Record<string, unknown>;
+        };
+        contextValidations?: {
+            valid?: boolean;
+            reason?: string;
+            providerValidation?: {
+                valid?: boolean;
+                providerId?: string;
+                reason?: string;
+                blocked?: boolean;
+                trustTier?: TrustTier;
+            };
+            contentValidation?: {
+                valid?: boolean;
+                reason?: string;
+                format?: string;
+                signatureValid?: boolean;
+                ageSeconds?: number;
+            };
+            injectionScan?: {
+                severity?: "low" | "medium" | "high" | "critical";
+                detected?: boolean;
+                patterns?: string[];
+                descriptions?: string[];
+            };
+        }[];
+        inferenceValidations?: {
+            valid?: boolean;
+            reason?: string;
+            requiredLevel?: InferenceLevel;
+            agentLevel?: InferenceLevel;
+            restrictedDomain?: "H" | "A" | "B" | "C" | "D" | "F" | "E" | "G" | "I" | "S";
+        }[];
+        channelEnforcement?: {
+            reason?: string;
+            action?: "warn" | "block" | "pass" | "sanitize";
+            allowed?: boolean;
+            sanitizedContent?: string;
+            strippedInstructions?: string[];
+        };
+    }>>;
+    postAction: z.ZodOptional<z.ZodObject<{
+        valid: z.ZodBoolean;
+        reason: z.ZodOptional<z.ZodString>;
+        outputValidation: z.ZodOptional<z.ZodObject<{
+            valid: z.ZodBoolean;
+            modified: z.ZodOptional<z.ZodBoolean>;
+            output: z.ZodOptional<z.ZodUnknown>;
+            schemaId: z.ZodOptional<z.ZodString>;
+            reason: z.ZodOptional<z.ZodString>;
+            patternScan: z.ZodOptional<z.ZodObject<{
+                detected: z.ZodBoolean;
+                patterns: z.ZodArray<z.ZodObject<{
+                    type: z.ZodEnum<["regex", "keyword", "semantic"]>;
+                    pattern: z.ZodString;
+                    description: z.ZodString;
+                    matches: z.ZodArray<z.ZodString, "many">;
+                    severity: z.ZodOptional<z.ZodEnum<["low", "medium", "high", "critical"]>>;
+                }, "strip", z.ZodTypeAny, {
+                    type?: "regex" | "keyword" | "semantic";
+                    pattern?: string;
+                    description?: string;
+                    severity?: "low" | "medium" | "high" | "critical";
+                    matches?: string[];
+                }, {
+                    type?: "regex" | "keyword" | "semantic";
+                    pattern?: string;
+                    description?: string;
+                    severity?: "low" | "medium" | "high" | "critical";
+                    matches?: string[];
+                }>, "many">;
+                severity: z.ZodOptional<z.ZodEnum<["low", "medium", "high", "critical"]>>;
+            }, "strip", z.ZodTypeAny, {
+                severity?: "low" | "medium" | "high" | "critical";
+                detected?: boolean;
+                patterns?: {
+                    type?: "regex" | "keyword" | "semantic";
+                    pattern?: string;
+                    description?: string;
+                    severity?: "low" | "medium" | "high" | "critical";
+                    matches?: string[];
+                }[];
+            }, {
+                severity?: "low" | "medium" | "high" | "critical";
+                detected?: boolean;
+                patterns?: {
+                    type?: "regex" | "keyword" | "semantic";
+                    pattern?: string;
+                    description?: string;
+                    severity?: "low" | "medium" | "high" | "critical";
+                    matches?: string[];
+                }[];
+            }>>;
+        }, "strip", z.ZodTypeAny, {
+            valid?: boolean;
+            reason?: string;
+            output?: unknown;
+            modified?: boolean;
+            schemaId?: string;
+            patternScan?: {
+                severity?: "low" | "medium" | "high" | "critical";
+                detected?: boolean;
+                patterns?: {
+                    type?: "regex" | "keyword" | "semantic";
+                    pattern?: string;
+                    description?: string;
+                    severity?: "low" | "medium" | "high" | "critical";
+                    matches?: string[];
+                }[];
+            };
+        }, {
+            valid?: boolean;
+            reason?: string;
+            output?: unknown;
+            modified?: boolean;
+            schemaId?: string;
+            patternScan?: {
+                severity?: "low" | "medium" | "high" | "critical";
+                detected?: boolean;
+                patterns?: {
+                    type?: "regex" | "keyword" | "semantic";
+                    pattern?: string;
+                    description?: string;
+                    severity?: "low" | "medium" | "high" | "critical";
+                    matches?: string[];
+                }[];
+            };
+        }>>;
+        inferenceValidations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            valid: z.ZodBoolean;
+            reason: z.ZodOptional<z.ZodString>;
+            requiredLevel: z.ZodOptional<z.ZodNativeEnum<typeof InferenceLevel>>;
+            agentLevel: z.ZodOptional<z.ZodNativeEnum<typeof InferenceLevel>>;
+            restrictedDomain: z.ZodOptional<z.ZodEnum<["A", "B", "C", "D", "E", "F", "G", "H", "I", "S"]>>;
+        }, "strip", z.ZodTypeAny, {
+            valid?: boolean;
+            reason?: string;
+            requiredLevel?: InferenceLevel;
+            agentLevel?: InferenceLevel;
+            restrictedDomain?: "H" | "A" | "B" | "C" | "D" | "F" | "E" | "G" | "I" | "S";
+        }, {
+            valid?: boolean;
+            reason?: string;
+            requiredLevel?: InferenceLevel;
+            agentLevel?: InferenceLevel;
+            restrictedDomain?: "H" | "A" | "B" | "C" | "D" | "F" | "E" | "G" | "I" | "S";
+        }>, "many">>;
+        piiChecks: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            containsPII: z.ZodBoolean;
+            piiTypes: z.ZodArray<z.ZodString, "many">;
+            action: z.ZodEnum<["allowed", "blocked", "redacted", "hashed"]>;
+            modifiedData: z.ZodOptional<z.ZodUnknown>;
+        }, "strip", z.ZodTypeAny, {
+            action?: "blocked" | "redacted" | "allowed" | "hashed";
+            containsPII?: boolean;
+            piiTypes?: string[];
+            modifiedData?: unknown;
+        }, {
+            action?: "blocked" | "redacted" | "allowed" | "hashed";
+            containsPII?: boolean;
+            piiTypes?: string[];
+            modifiedData?: unknown;
+        }>, "many">>;
+        sanitizedOutput: z.ZodOptional<z.ZodUnknown>;
+        warnings: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        valid?: boolean;
+        reason?: string;
+        warnings?: string[];
+        inferenceValidations?: {
+            valid?: boolean;
+            reason?: string;
+            requiredLevel?: InferenceLevel;
+            agentLevel?: InferenceLevel;
+            restrictedDomain?: "H" | "A" | "B" | "C" | "D" | "F" | "E" | "G" | "I" | "S";
+        }[];
+        outputValidation?: {
+            valid?: boolean;
+            reason?: string;
+            output?: unknown;
+            modified?: boolean;
+            schemaId?: string;
+            patternScan?: {
+                severity?: "low" | "medium" | "high" | "critical";
+                detected?: boolean;
+                patterns?: {
+                    type?: "regex" | "keyword" | "semantic";
+                    pattern?: string;
+                    description?: string;
+                    severity?: "low" | "medium" | "high" | "critical";
+                    matches?: string[];
+                }[];
+            };
+        };
+        piiChecks?: {
+            action?: "blocked" | "redacted" | "allowed" | "hashed";
+            containsPII?: boolean;
+            piiTypes?: string[];
+            modifiedData?: unknown;
+        }[];
+        sanitizedOutput?: unknown;
+    }, {
+        valid?: boolean;
+        reason?: string;
+        warnings?: string[];
+        inferenceValidations?: {
+            valid?: boolean;
+            reason?: string;
+            requiredLevel?: InferenceLevel;
+            agentLevel?: InferenceLevel;
+            restrictedDomain?: "H" | "A" | "B" | "C" | "D" | "F" | "E" | "G" | "I" | "S";
+        }[];
+        outputValidation?: {
+            valid?: boolean;
+            reason?: string;
+            output?: unknown;
+            modified?: boolean;
+            schemaId?: string;
+            patternScan?: {
+                severity?: "low" | "medium" | "high" | "critical";
+                detected?: boolean;
+                patterns?: {
+                    type?: "regex" | "keyword" | "semantic";
+                    pattern?: string;
+                    description?: string;
+                    severity?: "low" | "medium" | "high" | "critical";
+                    matches?: string[];
+                }[];
+            };
+        };
+        piiChecks?: {
+            action?: "blocked" | "redacted" | "allowed" | "hashed";
+            containsPII?: boolean;
+            piiTypes?: string[];
+            modifiedData?: unknown;
+        }[];
+        sanitizedOutput?: unknown;
+    }>>;
+    reason: z.ZodOptional<z.ZodString>;
+    validatedAt: z.ZodDate;
+    durationMs: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    valid?: boolean;
+    reason?: string;
+    durationMs?: number;
+    agentDid?: string;
+    preAction?: {
+        reason?: string;
+        allowed?: boolean;
+        warnings?: string[];
+        instructionValidation?: {
+            valid?: boolean;
+            method?: "exact-match" | "template-match" | "signed-source";
+            reason?: string;
+            templateId?: string;
+            instructionHash?: string;
+            extractedParams?: Record<string, unknown>;
+        };
+        contextValidations?: {
+            valid?: boolean;
+            reason?: string;
+            providerValidation?: {
+                valid?: boolean;
+                providerId?: string;
+                reason?: string;
+                blocked?: boolean;
+                trustTier?: TrustTier;
+            };
+            contentValidation?: {
+                valid?: boolean;
+                reason?: string;
+                format?: string;
+                signatureValid?: boolean;
+                ageSeconds?: number;
+            };
+            injectionScan?: {
+                severity?: "low" | "medium" | "high" | "critical";
+                detected?: boolean;
+                patterns?: string[];
+                descriptions?: string[];
+            };
+        }[];
+        inferenceValidations?: {
+            valid?: boolean;
+            reason?: string;
+            requiredLevel?: InferenceLevel;
+            agentLevel?: InferenceLevel;
+            restrictedDomain?: "H" | "A" | "B" | "C" | "D" | "F" | "E" | "G" | "I" | "S";
+        }[];
+        channelEnforcement?: {
+            reason?: string;
+            action?: "warn" | "block" | "pass" | "sanitize";
+            allowed?: boolean;
+            sanitizedContent?: string;
+            strippedInstructions?: string[];
+        };
+    };
+    postAction?: {
+        valid?: boolean;
+        reason?: string;
+        warnings?: string[];
+        inferenceValidations?: {
+            valid?: boolean;
+            reason?: string;
+            requiredLevel?: InferenceLevel;
+            agentLevel?: InferenceLevel;
+            restrictedDomain?: "H" | "A" | "B" | "C" | "D" | "F" | "E" | "G" | "I" | "S";
+        }[];
+        outputValidation?: {
+            valid?: boolean;
+            reason?: string;
+            output?: unknown;
+            modified?: boolean;
+            schemaId?: string;
+            patternScan?: {
+                severity?: "low" | "medium" | "high" | "critical";
+                detected?: boolean;
+                patterns?: {
+                    type?: "regex" | "keyword" | "semantic";
+                    pattern?: string;
+                    description?: string;
+                    severity?: "low" | "medium" | "high" | "critical";
+                    matches?: string[];
+                }[];
+            };
+        };
+        piiChecks?: {
+            action?: "blocked" | "redacted" | "allowed" | "hashed";
+            containsPII?: boolean;
+            piiTypes?: string[];
+            modifiedData?: unknown;
+        }[];
+        sanitizedOutput?: unknown;
+    };
+    interactionId?: string;
+    validatedAt?: Date;
+}, {
+    valid?: boolean;
+    reason?: string;
+    durationMs?: number;
+    agentDid?: string;
+    preAction?: {
+        reason?: string;
+        allowed?: boolean;
+        warnings?: string[];
+        instructionValidation?: {
+            valid?: boolean;
+            method?: "exact-match" | "template-match" | "signed-source";
+            reason?: string;
+            templateId?: string;
+            instructionHash?: string;
+            extractedParams?: Record<string, unknown>;
+        };
+        contextValidations?: {
+            valid?: boolean;
+            reason?: string;
+            providerValidation?: {
+                valid?: boolean;
+                providerId?: string;
+                reason?: string;
+                blocked?: boolean;
+                trustTier?: TrustTier;
+            };
+            contentValidation?: {
+                valid?: boolean;
+                reason?: string;
+                format?: string;
+                signatureValid?: boolean;
+                ageSeconds?: number;
+            };
+            injectionScan?: {
+                severity?: "low" | "medium" | "high" | "critical";
+                detected?: boolean;
+                patterns?: string[];
+                descriptions?: string[];
+            };
+        }[];
+        inferenceValidations?: {
+            valid?: boolean;
+            reason?: string;
+            requiredLevel?: InferenceLevel;
+            agentLevel?: InferenceLevel;
+            restrictedDomain?: "H" | "A" | "B" | "C" | "D" | "F" | "E" | "G" | "I" | "S";
+        }[];
+        channelEnforcement?: {
+            reason?: string;
+            action?: "warn" | "block" | "pass" | "sanitize";
+            allowed?: boolean;
+            sanitizedContent?: string;
+            strippedInstructions?: string[];
+        };
+    };
+    postAction?: {
+        valid?: boolean;
+        reason?: string;
+        warnings?: string[];
+        inferenceValidations?: {
+            valid?: boolean;
+            reason?: string;
+            requiredLevel?: InferenceLevel;
+            agentLevel?: InferenceLevel;
+            restrictedDomain?: "H" | "A" | "B" | "C" | "D" | "F" | "E" | "G" | "I" | "S";
+        }[];
+        outputValidation?: {
+            valid?: boolean;
+            reason?: string;
+            output?: unknown;
+            modified?: boolean;
+            schemaId?: string;
+            patternScan?: {
+                severity?: "low" | "medium" | "high" | "critical";
+                detected?: boolean;
+                patterns?: {
+                    type?: "regex" | "keyword" | "semantic";
+                    pattern?: string;
+                    description?: string;
+                    severity?: "low" | "medium" | "high" | "critical";
+                    matches?: string[];
+                }[];
+            };
+        };
+        piiChecks?: {
+            action?: "blocked" | "redacted" | "allowed" | "hashed";
+            containsPII?: boolean;
+            piiTypes?: string[];
+            modifiedData?: unknown;
+        }[];
+        sanitizedOutput?: unknown;
+    };
+    interactionId?: string;
+    validatedAt?: Date;
+}>;
+/**
+ * Semantic governance configuration for creating credentials
+ */
+export interface SemanticGovernanceConfig {
+    /** Instruction integrity configuration */
+    instructionIntegrity?: Partial<InstructionIntegrity>;
+    /** Output binding configuration */
+    outputBinding?: Partial<OutputBinding>;
+    /** Inference scope configuration */
+    inferenceScope?: Partial<InferenceScope>;
+    /** Context authentication configuration */
+    contextAuthentication?: Partial<ContextAuthenticationRequirements>;
+    /** Dual-channel configuration */
+    dualChannel?: Partial<DualChannelConfig>;
+}
+export declare const SemanticGovernanceConfigSchema: z.ZodObject<{
+    instructionIntegrity: z.ZodOptional<z.ZodObject<{
+        allowedInstructionHashes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        instructionTemplates: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            hash: z.ZodString;
+            description: z.ZodString;
+            parameterSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, "strip", z.ZodTypeAny, {
+            id?: string;
+            description?: string;
+            hash?: string;
+            parameterSchema?: Record<string, unknown>;
+        }, {
+            id?: string;
+            description?: string;
+            hash?: string;
+            parameterSchema?: Record<string, unknown>;
+        }>, "many">>;
+        instructionSource: z.ZodOptional<z.ZodObject<{
+            allowedSources: z.ZodArray<z.ZodString, "many">;
+            requireSignature: z.ZodBoolean;
+        }, "strip", z.ZodTypeAny, {
+            allowedSources?: string[];
+            requireSignature?: boolean;
+        }, {
+            allowedSources?: string[];
+            requireSignature?: boolean;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        allowedInstructionHashes?: string[];
+        instructionTemplates?: {
+            id?: string;
+            description?: string;
+            hash?: string;
+            parameterSchema?: Record<string, unknown>;
+        }[];
+        instructionSource?: {
+            allowedSources?: string[];
+            requireSignature?: boolean;
+        };
+    }, {
+        allowedInstructionHashes?: string[];
+        instructionTemplates?: {
+            id?: string;
+            description?: string;
+            hash?: string;
+            parameterSchema?: Record<string, unknown>;
+        }[];
+        instructionSource?: {
+            allowedSources?: string[];
+            requireSignature?: boolean;
+        };
+    }>>;
+    outputBinding: z.ZodOptional<z.ZodObject<{
+        allowedSchemas: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            description: z.ZodString;
+            jsonSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, "strip", z.ZodTypeAny, {
+            id?: string;
+            description?: string;
+            jsonSchema?: Record<string, unknown>;
+        }, {
+            id?: string;
+            description?: string;
+            jsonSchema?: Record<string, unknown>;
+        }>, "many">>;
+        prohibitedPatterns: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            type: z.ZodEnum<["regex", "keyword", "semantic"]>;
+            pattern: z.ZodString;
+            description: z.ZodString;
+            severity: z.ZodOptional<z.ZodEnum<["low", "medium", "high", "critical"]>>;
+        }, "strip", z.ZodTypeAny, {
+            type?: "regex" | "keyword" | "semantic";
+            pattern?: string;
+            description?: string;
+            severity?: "low" | "medium" | "high" | "critical";
+        }, {
+            type?: "regex" | "keyword" | "semantic";
+            pattern?: string;
+            description?: string;
+            severity?: "low" | "medium" | "high" | "critical";
+        }>, "many">>;
+        allowedExternalEndpoints: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        blockedExternalEndpoints: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        allowedSchemas?: {
+            id?: string;
+            description?: string;
+            jsonSchema?: Record<string, unknown>;
+        }[];
+        prohibitedPatterns?: {
+            type?: "regex" | "keyword" | "semantic";
+            pattern?: string;
+            description?: string;
+            severity?: "low" | "medium" | "high" | "critical";
+        }[];
+        allowedExternalEndpoints?: string[];
+        blockedExternalEndpoints?: string[];
+    }, {
+        allowedSchemas?: {
+            id?: string;
+            description?: string;
+            jsonSchema?: Record<string, unknown>;
+        }[];
+        prohibitedPatterns?: {
+            type?: "regex" | "keyword" | "semantic";
+            pattern?: string;
+            description?: string;
+            severity?: "low" | "medium" | "high" | "critical";
+        }[];
+        allowedExternalEndpoints?: string[];
+        blockedExternalEndpoints?: string[];
+    }>>;
+    inferenceScope: z.ZodOptional<z.ZodObject<{
+        globalLevel: z.ZodOptional<z.ZodNativeEnum<typeof InferenceLevel>>;
+        domainOverrides: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            domain: z.ZodEnum<["A", "B", "C", "D", "E", "F", "G", "H", "I", "S"]>;
+            level: z.ZodNativeEnum<typeof InferenceLevel>;
+            reason: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            level?: InferenceLevel;
+            domain?: "H" | "A" | "B" | "C" | "D" | "F" | "E" | "G" | "I" | "S";
+            reason?: string;
+        }, {
+            level?: InferenceLevel;
+            domain?: "H" | "A" | "B" | "C" | "D" | "F" | "E" | "G" | "I" | "S";
+            reason?: string;
+        }>, "many">>;
+        derivedKnowledgeHandling: z.ZodOptional<z.ZodObject<{
+            retention: z.ZodEnum<["none", "session", "persistent"]>;
+            allowedRecipients: z.ZodArray<z.ZodString, "many">;
+            crossContextSharing: z.ZodBoolean;
+        }, "strip", z.ZodTypeAny, {
+            retention?: "none" | "session" | "persistent";
+            allowedRecipients?: string[];
+            crossContextSharing?: boolean;
+        }, {
+            retention?: "none" | "session" | "persistent";
+            allowedRecipients?: string[];
+            crossContextSharing?: boolean;
+        }>>;
+        piiInference: z.ZodOptional<z.ZodObject<{
+            allowed: z.ZodBoolean;
+            handling: z.ZodEnum<["block", "redact", "hash"]>;
+        }, "strip", z.ZodTypeAny, {
+            allowed?: boolean;
+            handling?: "block" | "hash" | "redact";
+        }, {
+            allowed?: boolean;
+            handling?: "block" | "hash" | "redact";
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        globalLevel?: InferenceLevel;
+        domainOverrides?: {
+            level?: InferenceLevel;
+            domain?: "H" | "A" | "B" | "C" | "D" | "F" | "E" | "G" | "I" | "S";
+            reason?: string;
+        }[];
+        derivedKnowledgeHandling?: {
+            retention?: "none" | "session" | "persistent";
+            allowedRecipients?: string[];
+            crossContextSharing?: boolean;
+        };
+        piiInference?: {
+            allowed?: boolean;
+            handling?: "block" | "hash" | "redact";
+        };
+    }, {
+        globalLevel?: InferenceLevel;
+        domainOverrides?: {
+            level?: InferenceLevel;
+            domain?: "H" | "A" | "B" | "C" | "D" | "F" | "E" | "G" | "I" | "S";
+            reason?: string;
+        }[];
+        derivedKnowledgeHandling?: {
+            retention?: "none" | "session" | "persistent";
+            allowedRecipients?: string[];
+            crossContextSharing?: boolean;
+        };
+        piiInference?: {
+            allowed?: boolean;
+            handling?: "block" | "hash" | "redact";
+        };
+    }>>;
+    contextAuthentication: z.ZodOptional<z.ZodObject<{
+        required: z.ZodOptional<z.ZodBoolean>;
+        minTrustTier: z.ZodOptional<z.ZodNativeEnum<typeof TrustTier>>;
+        requiredDomains: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodEnum<["A", "B", "C", "D", "E", "F", "G", "H", "I", "S"]>, "many">>>;
+        allowedProviders: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        blockedProviders: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        contentIntegrity: z.ZodOptional<z.ZodObject<{
+            signatureRequired: z.ZodBoolean;
+            maxAge: z.ZodNumber;
+            allowedFormats: z.ZodArray<z.ZodString, "many">;
+        }, "strip", z.ZodTypeAny, {
+            maxAge?: number;
+            signatureRequired?: boolean;
+            allowedFormats?: string[];
+        }, {
+            maxAge?: number;
+            signatureRequired?: boolean;
+            allowedFormats?: string[];
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        required?: boolean;
+        requiredDomains?: ("H" | "A" | "B" | "C" | "D" | "F" | "E" | "G" | "I" | "S")[];
+        minTrustTier?: TrustTier;
+        allowedProviders?: string[];
+        blockedProviders?: string[];
+        contentIntegrity?: {
+            maxAge?: number;
+            signatureRequired?: boolean;
+            allowedFormats?: string[];
+        };
+    }, {
+        required?: boolean;
+        requiredDomains?: ("H" | "A" | "B" | "C" | "D" | "F" | "E" | "G" | "I" | "S")[];
+        minTrustTier?: TrustTier;
+        allowedProviders?: string[];
+        blockedProviders?: string[];
+        contentIntegrity?: {
+            maxAge?: number;
+            signatureRequired?: boolean;
+            allowedFormats?: string[];
+        };
+    }>>;
+    dualChannel: z.ZodOptional<z.ZodObject<{
+        enforced: z.ZodOptional<z.ZodBoolean>;
+        controlPlaneSources: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        dataPlaneTreatment: z.ZodOptional<z.ZodEnum<["block", "sanitize", "warn"]>>;
+    }, "strip", z.ZodTypeAny, {
+        enforced?: boolean;
+        controlPlaneSources?: string[];
+        dataPlaneTreatment?: "warn" | "block" | "sanitize";
+    }, {
+        enforced?: boolean;
+        controlPlaneSources?: string[];
+        dataPlaneTreatment?: "warn" | "block" | "sanitize";
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    instructionIntegrity?: {
+        allowedInstructionHashes?: string[];
+        instructionTemplates?: {
+            id?: string;
+            description?: string;
+            hash?: string;
+            parameterSchema?: Record<string, unknown>;
+        }[];
+        instructionSource?: {
+            allowedSources?: string[];
+            requireSignature?: boolean;
+        };
+    };
+    outputBinding?: {
+        allowedSchemas?: {
+            id?: string;
+            description?: string;
+            jsonSchema?: Record<string, unknown>;
+        }[];
+        prohibitedPatterns?: {
+            type?: "regex" | "keyword" | "semantic";
+            pattern?: string;
+            description?: string;
+            severity?: "low" | "medium" | "high" | "critical";
+        }[];
+        allowedExternalEndpoints?: string[];
+        blockedExternalEndpoints?: string[];
+    };
+    inferenceScope?: {
+        globalLevel?: InferenceLevel;
+        domainOverrides?: {
+            level?: InferenceLevel;
+            domain?: "H" | "A" | "B" | "C" | "D" | "F" | "E" | "G" | "I" | "S";
+            reason?: string;
+        }[];
+        derivedKnowledgeHandling?: {
+            retention?: "none" | "session" | "persistent";
+            allowedRecipients?: string[];
+            crossContextSharing?: boolean;
+        };
+        piiInference?: {
+            allowed?: boolean;
+            handling?: "block" | "hash" | "redact";
+        };
+    };
+    contextAuthentication?: {
+        required?: boolean;
+        requiredDomains?: ("H" | "A" | "B" | "C" | "D" | "F" | "E" | "G" | "I" | "S")[];
+        minTrustTier?: TrustTier;
+        allowedProviders?: string[];
+        blockedProviders?: string[];
+        contentIntegrity?: {
+            maxAge?: number;
+            signatureRequired?: boolean;
+            allowedFormats?: string[];
+        };
+    };
+    dualChannel?: {
+        enforced?: boolean;
+        controlPlaneSources?: string[];
+        dataPlaneTreatment?: "warn" | "block" | "sanitize";
+    };
+}, {
+    instructionIntegrity?: {
+        allowedInstructionHashes?: string[];
+        instructionTemplates?: {
+            id?: string;
+            description?: string;
+            hash?: string;
+            parameterSchema?: Record<string, unknown>;
+        }[];
+        instructionSource?: {
+            allowedSources?: string[];
+            requireSignature?: boolean;
+        };
+    };
+    outputBinding?: {
+        allowedSchemas?: {
+            id?: string;
+            description?: string;
+            jsonSchema?: Record<string, unknown>;
+        }[];
+        prohibitedPatterns?: {
+            type?: "regex" | "keyword" | "semantic";
+            pattern?: string;
+            description?: string;
+            severity?: "low" | "medium" | "high" | "critical";
+        }[];
+        allowedExternalEndpoints?: string[];
+        blockedExternalEndpoints?: string[];
+    };
+    inferenceScope?: {
+        globalLevel?: InferenceLevel;
+        domainOverrides?: {
+            level?: InferenceLevel;
+            domain?: "H" | "A" | "B" | "C" | "D" | "F" | "E" | "G" | "I" | "S";
+            reason?: string;
+        }[];
+        derivedKnowledgeHandling?: {
+            retention?: "none" | "session" | "persistent";
+            allowedRecipients?: string[];
+            crossContextSharing?: boolean;
+        };
+        piiInference?: {
+            allowed?: boolean;
+            handling?: "block" | "hash" | "redact";
+        };
+    };
+    contextAuthentication?: {
+        required?: boolean;
+        requiredDomains?: ("H" | "A" | "B" | "C" | "D" | "F" | "E" | "G" | "I" | "S")[];
+        minTrustTier?: TrustTier;
+        allowedProviders?: string[];
+        blockedProviders?: string[];
+        contentIntegrity?: {
+            maxAge?: number;
+            signatureRequired?: boolean;
+            allowedFormats?: string[];
+        };
+    };
+    dualChannel?: {
+        enforced?: boolean;
+        controlPlaneSources?: string[];
+        dataPlaneTreatment?: "warn" | "block" | "sanitize";
+    };
+}>;
+/**
+ * Default instruction integrity configuration
+ */
+export declare const DEFAULT_INSTRUCTION_INTEGRITY: InstructionIntegrity;
+/**
+ * Default output binding configuration
+ */
+export declare const DEFAULT_OUTPUT_BINDING: OutputBinding;
+/**
+ * Default inference scope configuration
+ */
+export declare const DEFAULT_INFERENCE_SCOPE: InferenceScope;
+/**
+ * Default context authentication configuration
+ */
+export declare const DEFAULT_CONTEXT_AUTHENTICATION: ContextAuthenticationRequirements;
+/**
+ * Default dual-channel configuration
+ */
+export declare const DEFAULT_DUAL_CHANNEL: DualChannelConfig;
+//# sourceMappingURL=types.d.ts.map