@llm-dev-ops/agentics-cli 1.4.26 → 1.4.29

package/dist/bundled-agents/data-vault-agents/dist/platform/integration.d.ts

@@ -0,0 +1,875 @@
+/**
+ * Platform Integration Hooks for LLM-Data-Vault Agents
+ *
+ * Provides integration with the LLM-Dev-Ops ecosystem:
+ * - LLM-Policy-Engine: Receives and applies data access policies
+ * - LLM-Orchestrator: Handles dataset requests
+ * - LLM-Inference-Gateway: Provides approved/anonymized datasets
+ * - Governance: Consumes and emits DecisionEvents
+ *
+ * @module platform/integration
+ */
+import { z } from 'zod';
+/**
+ * DecisionEvent schema - standard governance event format
+ */
+export declare const DecisionEventSchema: z.ZodObject<{
+    eventId: z.ZodString;
+    eventType: z.ZodLiteral<"DecisionEvent">;
+    version: z.ZodString;
+    timestamp: z.ZodString;
+    source: z.ZodObject<{
+        agentId: z.ZodString;
+        agentName: z.ZodString;
+        agentVersion: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        agentId: string;
+        agentVersion: string;
+        agentName: string;
+    }, {
+        agentId: string;
+        agentVersion: string;
+        agentName: string;
+    }>;
+    decision: z.ZodObject<{
+        type: z.ZodEnum<["ALLOW", "DENY", "TRANSFORM", "AUDIT"]>;
+        reason: z.ZodString;
+        confidence: z.ZodNumber;
+        policyIds: z.ZodArray<z.ZodString, "many">;
+        appliedRules: z.ZodArray<z.ZodObject<{
+            ruleId: z.ZodString;
+            ruleName: z.ZodString;
+            action: z.ZodString;
+            matched: z.ZodBoolean;
+        }, "strip", z.ZodTypeAny, {
+            action: string;
+            ruleId: string;
+            ruleName: string;
+            matched: boolean;
+        }, {
+            action: string;
+            ruleId: string;
+            ruleName: string;
+            matched: boolean;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        type: "ALLOW" | "DENY" | "TRANSFORM" | "AUDIT";
+        confidence: number;
+        reason: string;
+        policyIds: string[];
+        appliedRules: {
+            action: string;
+            ruleId: string;
+            ruleName: string;
+            matched: boolean;
+        }[];
+    }, {
+        type: "ALLOW" | "DENY" | "TRANSFORM" | "AUDIT";
+        confidence: number;
+        reason: string;
+        policyIds: string[];
+        appliedRules: {
+            action: string;
+            ruleId: string;
+            ruleName: string;
+            matched: boolean;
+        }[];
+    }>;
+    context: z.ZodObject<{
+        requestId: z.ZodString;
+        correlationId: z.ZodOptional<z.ZodString>;
+        userId: z.ZodOptional<z.ZodString>;
+        datasetId: z.ZodOptional<z.ZodString>;
+        operation: z.ZodString;
+        resourceType: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        operation: string;
+        requestId: string;
+        resourceType: string;
+        correlationId?: string | undefined;
+        userId?: string | undefined;
+        datasetId?: string | undefined;
+    }, {
+        operation: string;
+        requestId: string;
+        resourceType: string;
+        correlationId?: string | undefined;
+        userId?: string | undefined;
+        datasetId?: string | undefined;
+    }>;
+    audit: z.ZodObject<{
+        inputHash: z.ZodString;
+        outputHash: z.ZodOptional<z.ZodString>;
+        processingTimeMs: z.ZodNumber;
+        bytesProcessed: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        inputHash: string;
+        processingTimeMs: number;
+        bytesProcessed: number;
+        outputHash?: string | undefined;
+    }, {
+        inputHash: string;
+        processingTimeMs: number;
+        bytesProcessed: number;
+        outputHash?: string | undefined;
+    }>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    timestamp: string;
+    context: {
+        operation: string;
+        requestId: string;
+        resourceType: string;
+        correlationId?: string | undefined;
+        userId?: string | undefined;
+        datasetId?: string | undefined;
+    };
+    decision: {
+        type: "ALLOW" | "DENY" | "TRANSFORM" | "AUDIT";
+        confidence: number;
+        reason: string;
+        policyIds: string[];
+        appliedRules: {
+            action: string;
+            ruleId: string;
+            ruleName: string;
+            matched: boolean;
+        }[];
+    };
+    version: string;
+    audit: {
+        inputHash: string;
+        processingTimeMs: number;
+        bytesProcessed: number;
+        outputHash?: string | undefined;
+    };
+    eventId: string;
+    eventType: "DecisionEvent";
+    source: {
+        agentId: string;
+        agentVersion: string;
+        agentName: string;
+    };
+    metadata?: Record<string, unknown> | undefined;
+}, {
+    timestamp: string;
+    context: {
+        operation: string;
+        requestId: string;
+        resourceType: string;
+        correlationId?: string | undefined;
+        userId?: string | undefined;
+        datasetId?: string | undefined;
+    };
+    decision: {
+        type: "ALLOW" | "DENY" | "TRANSFORM" | "AUDIT";
+        confidence: number;
+        reason: string;
+        policyIds: string[];
+        appliedRules: {
+            action: string;
+            ruleId: string;
+            ruleName: string;
+            matched: boolean;
+        }[];
+    };
+    version: string;
+    audit: {
+        inputHash: string;
+        processingTimeMs: number;
+        bytesProcessed: number;
+        outputHash?: string | undefined;
+    };
+    eventId: string;
+    eventType: "DecisionEvent";
+    source: {
+        agentId: string;
+        agentVersion: string;
+        agentName: string;
+    };
+    metadata?: Record<string, unknown> | undefined;
+}>;
+export type DecisionEvent = z.infer<typeof DecisionEventSchema>;
+/**
+ * TelemetryEvent schema - observability event format
+ */
+export declare const TelemetryEventSchema: z.ZodObject<{
+    eventId: z.ZodString;
+    eventType: z.ZodLiteral<"TelemetryEvent">;
+    version: z.ZodString;
+    timestamp: z.ZodString;
+    source: z.ZodObject<{
+        service: z.ZodString;
+        instance: z.ZodString;
+        version: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        service: string;
+        version: string;
+        instance: string;
+    }, {
+        service: string;
+        version: string;
+        instance: string;
+    }>;
+    metrics: z.ZodObject<{
+        name: z.ZodString;
+        value: z.ZodNumber;
+        unit: z.ZodEnum<["count", "ms", "bytes", "percent"]>;
+        tags: z.ZodRecord<z.ZodString, z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        value: number;
+        name: string;
+        tags: Record<string, string>;
+        unit: "count" | "ms" | "bytes" | "percent";
+    }, {
+        value: number;
+        name: string;
+        tags: Record<string, string>;
+        unit: "count" | "ms" | "bytes" | "percent";
+    }>;
+    trace: z.ZodOptional<z.ZodObject<{
+        traceId: z.ZodString;
+        spanId: z.ZodString;
+        parentSpanId: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        traceId: string;
+        spanId: string;
+        parentSpanId?: string | undefined;
+    }, {
+        traceId: string;
+        spanId: string;
+        parentSpanId?: string | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    timestamp: string;
+    version: string;
+    metrics: {
+        value: number;
+        name: string;
+        tags: Record<string, string>;
+        unit: "count" | "ms" | "bytes" | "percent";
+    };
+    eventId: string;
+    eventType: "TelemetryEvent";
+    source: {
+        service: string;
+        version: string;
+        instance: string;
+    };
+    trace?: {
+        traceId: string;
+        spanId: string;
+        parentSpanId?: string | undefined;
+    } | undefined;
+}, {
+    timestamp: string;
+    version: string;
+    metrics: {
+        value: number;
+        name: string;
+        tags: Record<string, string>;
+        unit: "count" | "ms" | "bytes" | "percent";
+    };
+    eventId: string;
+    eventType: "TelemetryEvent";
+    source: {
+        service: string;
+        version: string;
+        instance: string;
+    };
+    trace?: {
+        traceId: string;
+        spanId: string;
+        parentSpanId?: string | undefined;
+    } | undefined;
+}>;
+export type TelemetryEvent = z.infer<typeof TelemetryEventSchema>;
+/**
+ * Policy received from LLM-Policy-Engine
+ */
+export declare const PolicySchema: z.ZodObject<{
+    policyId: z.ZodString;
+    name: z.ZodString;
+    version: z.ZodString;
+    rules: z.ZodArray<z.ZodObject<{
+        ruleId: z.ZodString;
+        condition: z.ZodObject<{
+            field: z.ZodString;
+            operator: z.ZodEnum<["eq", "neq", "contains", "regex", "gt", "lt", "in"]>;
+            value: z.ZodUnknown;
+        }, "strip", z.ZodTypeAny, {
+            field: string;
+            operator: "gt" | "lt" | "contains" | "regex" | "in" | "eq" | "neq";
+            value?: unknown;
+        }, {
+            field: string;
+            operator: "gt" | "lt" | "contains" | "regex" | "in" | "eq" | "neq";
+            value?: unknown;
+        }>;
+        action: z.ZodEnum<["allow", "deny", "transform", "audit"]>;
+        transformations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            type: z.ZodEnum<["redact", "mask", "hash", "encrypt", "generalize"]>;
+            field: z.ZodString;
+            config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, "strip", z.ZodTypeAny, {
+            type: "redact" | "mask" | "hash" | "generalize" | "encrypt";
+            field: string;
+            config?: Record<string, unknown> | undefined;
+        }, {
+            type: "redact" | "mask" | "hash" | "generalize" | "encrypt";
+            field: string;
+            config?: Record<string, unknown> | undefined;
+        }>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        action: "allow" | "deny" | "transform" | "audit";
+        ruleId: string;
+        condition: {
+            field: string;
+            operator: "gt" | "lt" | "contains" | "regex" | "in" | "eq" | "neq";
+            value?: unknown;
+        };
+        transformations?: {
+            type: "redact" | "mask" | "hash" | "generalize" | "encrypt";
+            field: string;
+            config?: Record<string, unknown> | undefined;
+        }[] | undefined;
+    }, {
+        action: "allow" | "deny" | "transform" | "audit";
+        ruleId: string;
+        condition: {
+            field: string;
+            operator: "gt" | "lt" | "contains" | "regex" | "in" | "eq" | "neq";
+            value?: unknown;
+        };
+        transformations?: {
+            type: "redact" | "mask" | "hash" | "generalize" | "encrypt";
+            field: string;
+            config?: Record<string, unknown> | undefined;
+        }[] | undefined;
+    }>, "many">;
+    scope: z.ZodObject<{
+        datasets: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        users: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        operations: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        operations?: string[] | undefined;
+        datasets?: string[] | undefined;
+        users?: string[] | undefined;
+    }, {
+        operations?: string[] | undefined;
+        datasets?: string[] | undefined;
+        users?: string[] | undefined;
+    }>;
+    effectiveFrom: z.ZodString;
+    effectiveUntil: z.ZodOptional<z.ZodString>;
+    priority: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    priority: number;
+    rules: {
+        action: "allow" | "deny" | "transform" | "audit";
+        ruleId: string;
+        condition: {
+            field: string;
+            operator: "gt" | "lt" | "contains" | "regex" | "in" | "eq" | "neq";
+            value?: unknown;
+        };
+        transformations?: {
+            type: "redact" | "mask" | "hash" | "generalize" | "encrypt";
+            field: string;
+            config?: Record<string, unknown> | undefined;
+        }[] | undefined;
+    }[];
+    version: string;
+    policyId: string;
+    scope: {
+        operations?: string[] | undefined;
+        datasets?: string[] | undefined;
+        users?: string[] | undefined;
+    };
+    effectiveFrom: string;
+    effectiveUntil?: string | undefined;
+}, {
+    name: string;
+    priority: number;
+    rules: {
+        action: "allow" | "deny" | "transform" | "audit";
+        ruleId: string;
+        condition: {
+            field: string;
+            operator: "gt" | "lt" | "contains" | "regex" | "in" | "eq" | "neq";
+            value?: unknown;
+        };
+        transformations?: {
+            type: "redact" | "mask" | "hash" | "generalize" | "encrypt";
+            field: string;
+            config?: Record<string, unknown> | undefined;
+        }[] | undefined;
+    }[];
+    version: string;
+    policyId: string;
+    scope: {
+        operations?: string[] | undefined;
+        datasets?: string[] | undefined;
+        users?: string[] | undefined;
+    };
+    effectiveFrom: string;
+    effectiveUntil?: string | undefined;
+}>;
+export type Policy = z.infer<typeof PolicySchema>;
+/**
+ * Policy Engine integration client
+ */
+export declare class PolicyEngineIntegration {
+    private readonly baseUrl;
+    private policies;
+    constructor(config: {
+        baseUrl: string;
+    });
+    /**
+     * Fetches policies from LLM-Policy-Engine
+     * This agent RECEIVES policies - it does NOT create them
+     */
+    fetchPolicies(scope?: {
+        datasetId?: string;
+        operation?: string;
+    }): Promise<Policy[]>;
+    /**
+     * Subscribes to policy update events
+     */
+    subscribeToPolicyUpdates(callback: (policy: Policy) => void): Promise<{
+        unsubscribe: () => void;
+    }>;
+    /**
+     * Gets a cached policy by ID
+     */
+    getPolicy(policyId: string): Policy | undefined;
+}
+/**
+ * Dataset request from LLM-Orchestrator
+ */
+export declare const DatasetRequestSchema: z.ZodObject<{
+    requestId: z.ZodString;
+    correlationId: z.ZodString;
+    requester: z.ZodObject<{
+        serviceId: z.ZodString;
+        userId: z.ZodOptional<z.ZodString>;
+        purpose: z.ZodEnum<["training", "inference", "evaluation", "analysis"]>;
+    }, "strip", z.ZodTypeAny, {
+        purpose: "evaluation" | "inference" | "training" | "analysis";
+        serviceId: string;
+        userId?: string | undefined;
+    }, {
+        purpose: "evaluation" | "inference" | "training" | "analysis";
+        serviceId: string;
+        userId?: string | undefined;
+    }>;
+    dataset: z.ZodObject<{
+        datasetId: z.ZodString;
+        version: z.ZodOptional<z.ZodString>;
+        filters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        fields: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        limit: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        datasetId: string;
+        version?: string | undefined;
+        limit?: number | undefined;
+        filters?: Record<string, unknown> | undefined;
+        fields?: string[] | undefined;
+    }, {
+        datasetId: string;
+        version?: string | undefined;
+        limit?: number | undefined;
+        filters?: Record<string, unknown> | undefined;
+        fields?: string[] | undefined;
+    }>;
+    requirements: z.ZodObject<{
+        anonymizationLevel: z.ZodEnum<["none", "basic", "strict", "full"]>;
+        encryptionRequired: z.ZodBoolean;
+        auditRequired: z.ZodBoolean;
+        lineageRequired: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        anonymizationLevel: "none" | "basic" | "strict" | "full";
+        encryptionRequired: boolean;
+        auditRequired: boolean;
+        lineageRequired: boolean;
+    }, {
+        anonymizationLevel: "none" | "basic" | "strict" | "full";
+        encryptionRequired: boolean;
+        auditRequired: boolean;
+        lineageRequired: boolean;
+    }>;
+    deadline: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    requester: {
+        purpose: "evaluation" | "inference" | "training" | "analysis";
+        serviceId: string;
+        userId?: string | undefined;
+    };
+    dataset: {
+        datasetId: string;
+        version?: string | undefined;
+        limit?: number | undefined;
+        filters?: Record<string, unknown> | undefined;
+        fields?: string[] | undefined;
+    };
+    requestId: string;
+    correlationId: string;
+    requirements: {
+        anonymizationLevel: "none" | "basic" | "strict" | "full";
+        encryptionRequired: boolean;
+        auditRequired: boolean;
+        lineageRequired: boolean;
+    };
+    deadline?: string | undefined;
+}, {
+    requester: {
+        purpose: "evaluation" | "inference" | "training" | "analysis";
+        serviceId: string;
+        userId?: string | undefined;
+    };
+    dataset: {
+        datasetId: string;
+        version?: string | undefined;
+        limit?: number | undefined;
+        filters?: Record<string, unknown> | undefined;
+        fields?: string[] | undefined;
+    };
+    requestId: string;
+    correlationId: string;
+    requirements: {
+        anonymizationLevel: "none" | "basic" | "strict" | "full";
+        encryptionRequired: boolean;
+        auditRequired: boolean;
+        lineageRequired: boolean;
+    };
+    deadline?: string | undefined;
+}>;
+export type DatasetRequest = z.infer<typeof DatasetRequestSchema>;
+/**
+ * Dataset response to LLM-Orchestrator
+ */
+export declare const DatasetResponseSchema: z.ZodObject<{
+    requestId: z.ZodString;
+    correlationId: z.ZodString;
+    status: z.ZodEnum<["approved", "denied", "partial", "pending"]>;
+    dataset: z.ZodOptional<z.ZodObject<{
+        datasetId: z.ZodString;
+        version: z.ZodString;
+        recordCount: z.ZodNumber;
+        sizeBytes: z.ZodNumber;
+        checksum: z.ZodString;
+        location: z.ZodOptional<z.ZodString>;
+        expiresAt: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        version: string;
+        datasetId: string;
+        recordCount: number;
+        sizeBytes: number;
+        checksum: string;
+        location?: string | undefined;
+        expiresAt?: string | undefined;
+    }, {
+        version: string;
+        datasetId: string;
+        recordCount: number;
+        sizeBytes: number;
+        checksum: string;
+        location?: string | undefined;
+        expiresAt?: string | undefined;
+    }>>;
+    transformations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        type: z.ZodString;
+        fieldsAffected: z.ZodArray<z.ZodString, "many">;
+        recordsAffected: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        type: string;
+        fieldsAffected: string[];
+        recordsAffected: number;
+    }, {
+        type: string;
+        fieldsAffected: string[];
+        recordsAffected: number;
+    }>, "many">>;
+    decision: z.ZodObject<{
+        decisionEventId: z.ZodString;
+        policyIds: z.ZodArray<z.ZodString, "many">;
+        reason: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        reason: string;
+        policyIds: string[];
+        decisionEventId: string;
+    }, {
+        reason: string;
+        policyIds: string[];
+        decisionEventId: string;
+    }>;
+    error: z.ZodOptional<z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        code: string;
+        message: string;
+    }, {
+        code: string;
+        message: string;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    status: "approved" | "denied" | "partial" | "pending";
+    decision: {
+        reason: string;
+        policyIds: string[];
+        decisionEventId: string;
+    };
+    requestId: string;
+    correlationId: string;
+    error?: {
+        code: string;
+        message: string;
+    } | undefined;
+    dataset?: {
+        version: string;
+        datasetId: string;
+        recordCount: number;
+        sizeBytes: number;
+        checksum: string;
+        location?: string | undefined;
+        expiresAt?: string | undefined;
+    } | undefined;
+    transformations?: {
+        type: string;
+        fieldsAffected: string[];
+        recordsAffected: number;
+    }[] | undefined;
+}, {
+    status: "approved" | "denied" | "partial" | "pending";
+    decision: {
+        reason: string;
+        policyIds: string[];
+        decisionEventId: string;
+    };
+    requestId: string;
+    correlationId: string;
+    error?: {
+        code: string;
+        message: string;
+    } | undefined;
+    dataset?: {
+        version: string;
+        datasetId: string;
+        recordCount: number;
+        sizeBytes: number;
+        checksum: string;
+        location?: string | undefined;
+        expiresAt?: string | undefined;
+    } | undefined;
+    transformations?: {
+        type: string;
+        fieldsAffected: string[];
+        recordsAffected: number;
+    }[] | undefined;
+}>;
+export type DatasetResponse = z.infer<typeof DatasetResponseSchema>;
+/**
+ * Orchestrator integration client
+ */
+export declare class OrchestratorIntegration {
+    private readonly callbackUrl;
+    constructor(config: {
+        callbackUrl: string;
+    });
+    /**
+     * Handles a dataset request from the orchestrator
+     * This agent processes the request - it does NOT orchestrate workflows
+     */
+    handleDatasetRequest(request: DatasetRequest, processCallback: (req: DatasetRequest) => Promise<{
+        approved: boolean;
+        data?: unknown;
+        transformations?: DatasetResponse['transformations'];
+        error?: {
+            code: string;
+            message: string;
+        };
+    }>): Promise<DatasetResponse>;
+    /**
+     * Sends response back to orchestrator
+     */
+    sendResponse(response: DatasetResponse): Promise<void>;
+    private computeChecksum;
+}
+/**
+ * Approved dataset for LLM-Inference-Gateway
+ */
+export declare const ApprovedDatasetSchema: z.ZodObject<{
+    datasetId: z.ZodString;
+    version: z.ZodString;
+    approvalId: z.ZodString;
+    approvedAt: z.ZodString;
+    expiresAt: z.ZodString;
+    accessToken: z.ZodString;
+    constraints: z.ZodObject<{
+        maxRecords: z.ZodOptional<z.ZodNumber>;
+        allowedFields: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        rateLimit: z.ZodOptional<z.ZodObject<{
+            requestsPerMinute: z.ZodNumber;
+            bytesPerMinute: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            requestsPerMinute: number;
+            bytesPerMinute: number;
+        }, {
+            requestsPerMinute: number;
+            bytesPerMinute: number;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        maxRecords?: number | undefined;
+        allowedFields?: string[] | undefined;
+        rateLimit?: {
+            requestsPerMinute: number;
+            bytesPerMinute: number;
+        } | undefined;
+    }, {
+        maxRecords?: number | undefined;
+        allowedFields?: string[] | undefined;
+        rateLimit?: {
+            requestsPerMinute: number;
+            bytesPerMinute: number;
+        } | undefined;
+    }>;
+    endpoint: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    version: string;
+    constraints: {
+        maxRecords?: number | undefined;
+        allowedFields?: string[] | undefined;
+        rateLimit?: {
+            requestsPerMinute: number;
+            bytesPerMinute: number;
+        } | undefined;
+    };
+    endpoint: string;
+    datasetId: string;
+    expiresAt: string;
+    approvalId: string;
+    approvedAt: string;
+    accessToken: string;
+}, {
+    version: string;
+    constraints: {
+        maxRecords?: number | undefined;
+        allowedFields?: string[] | undefined;
+        rateLimit?: {
+            requestsPerMinute: number;
+            bytesPerMinute: number;
+        } | undefined;
+    };
+    endpoint: string;
+    datasetId: string;
+    expiresAt: string;
+    approvalId: string;
+    approvedAt: string;
+    accessToken: string;
+}>;
+export type ApprovedDataset = z.infer<typeof ApprovedDatasetSchema>;
+/**
+ * Inference Gateway integration client
+ */
+export declare class InferenceGatewayIntegration {
+    private readonly gatewayUrl;
+    private approvedDatasets;
+    constructor(config: {
+        gatewayUrl: string;
+    });
+    /**
+     * Registers an approved dataset with the inference gateway
+     * This makes anonymized data available for inference
+     */
+    registerApprovedDataset(approval: {
+        datasetId: string;
+        version: string;
+        approvalId: string;
+        validityMinutes: number;
+        constraints?: ApprovedDataset['constraints'];
+    }): Promise<ApprovedDataset>;
+    /**
+     * Revokes access to a dataset
+     */
+    revokeDatasetAccess(datasetId: string, reason: string): Promise<void>;
+    private generateAccessToken;
+}
+/**
+ * Event emitter for governance events
+ */
+export declare class GovernanceEventEmitter {
+    private readonly eventStoreUrl;
+    private readonly instanceId;
+    constructor(config: {
+        eventStoreUrl: string;
+        instanceId: string;
+    });
+    /**
+     * Emits a DecisionEvent to the governance event store
+     */
+    emitDecisionEvent(params: {
+        requestId: string;
+        correlationId?: string;
+        userId?: string;
+        datasetId?: string;
+        operation: string;
+        resourceType: string;
+        decision: DecisionEvent['decision'];
+        inputHash: string;
+        outputHash?: string;
+        processingTimeMs: number;
+        bytesProcessed: number;
+        metadata?: Record<string, unknown>;
+    }): Promise<DecisionEvent>;
+    /**
+     * Emits a TelemetryEvent for observability
+     */
+    emitTelemetryEvent(params: {
+        metricName: string;
+        value: number;
+        unit: TelemetryEvent['metrics']['unit'];
+        tags: Record<string, string>;
+        traceId?: string;
+        spanId?: string;
+    }): Promise<TelemetryEvent>;
+}
+/**
+ * Event consumer for governance events from other agents
+ */
+export declare class GovernanceEventConsumer {
+    private readonly eventStoreUrl;
+    private handlers;
+    constructor(config: {
+        eventStoreUrl: string;
+    });
+    /**
+     * Subscribes to DecisionEvents from other agents
+     */
+    onDecisionEvent(handler: (event: DecisionEvent) => Promise<void>): void;
+    /**
+     * Starts consuming events from the event store
+     */
+    startConsuming(): Promise<{
+        stop: () => void;
+    }>;
+}
+export interface IntegrationConfig {
+    policyEngineUrl: string;
+    orchestratorCallbackUrl: string;
+    inferenceGatewayUrl: string;
+    eventStoreUrl: string;
+    instanceId: string;
+}
+/**
+ * Creates all integration clients with the provided configuration
+ */
+export declare function createIntegrations(config: IntegrationConfig): {
+    policyEngine: PolicyEngineIntegration;
+    orchestrator: OrchestratorIntegration;
+    inferenceGateway: InferenceGatewayIntegration;
+    eventEmitter: GovernanceEventEmitter;
+    eventConsumer: GovernanceEventConsumer;
+};
+//# sourceMappingURL=integration.d.ts.map