@x12i/memorix-scoper-contracts 1.0.0

package/dist/schemas.d.ts

@@ -0,0 +1,1077 @@
+import { z } from "zod";
+export declare const ScoperBudgetsSchema: z.ZodObject<{
+    maxWallTimeMs: z.ZodNumber;
+    maxSdkCalls: z.ZodNumber;
+    maxPages: z.ZodNumber;
+    maxRecords: z.ZodNumber;
+    maxBytes: z.ZodNumber;
+    maxEvidenceItems: z.ZodNumber;
+    maxRelationshipDepth: z.ZodNumber;
+    maxReasoningRounds: z.ZodNumber;
+    maxParallelCalls: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    maxEvidenceItems: number;
+    maxParallelCalls: number;
+    maxWallTimeMs: number;
+    maxSdkCalls: number;
+    maxPages: number;
+    maxRecords: number;
+    maxBytes: number;
+    maxRelationshipDepth: number;
+    maxReasoningRounds: number;
+}, {
+    maxEvidenceItems: number;
+    maxParallelCalls: number;
+    maxWallTimeMs: number;
+    maxSdkCalls: number;
+    maxPages: number;
+    maxRecords: number;
+    maxBytes: number;
+    maxRelationshipDepth: number;
+    maxReasoningRounds: number;
+}>;
+export type ScoperBudgets = z.infer<typeof ScoperBudgetsSchema>;
+export declare const ScopeRequestSchema: z.ZodEffects<z.ZodObject<{
+    objective: z.ZodString;
+    seeds: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        kind: z.ZodString;
+        id: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        kind: string;
+        id: string;
+    }, {
+        kind: string;
+        id: string;
+    }>, "many">>;
+    domains: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    timeRange: z.ZodOptional<z.ZodObject<{
+        from: z.ZodString;
+        to: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        from: string;
+        to: string;
+    }, {
+        from: string;
+        to: string;
+    }>>;
+    freshness: z.ZodOptional<z.ZodObject<{
+        includeStable: z.ZodOptional<z.ZodBoolean>;
+        includeLive: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        includeStable?: boolean | undefined;
+        includeLive?: boolean | undefined;
+    }, {
+        includeStable?: boolean | undefined;
+        includeLive?: boolean | undefined;
+    }>>;
+    requestedLimits: z.ZodOptional<z.ZodObject<{
+        maxEvidenceItems: z.ZodOptional<z.ZodNumber>;
+        maxRelationshipDepth: z.ZodOptional<z.ZodNumber>;
+        deadlineMs: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        maxEvidenceItems?: number | undefined;
+        maxRelationshipDepth?: number | undefined;
+        deadlineMs?: number | undefined;
+    }, {
+        maxEvidenceItems?: number | undefined;
+        maxRelationshipDepth?: number | undefined;
+        deadlineMs?: number | undefined;
+    }>>;
+    responseMode: z.ZodOptional<z.ZodLiteral<"evidence-bundle">>;
+}, "strip", z.ZodTypeAny, {
+    objective: string;
+    seeds?: {
+        kind: string;
+        id: string;
+    }[] | undefined;
+    domains?: string[] | undefined;
+    timeRange?: {
+        from: string;
+        to: string;
+    } | undefined;
+    freshness?: {
+        includeStable?: boolean | undefined;
+        includeLive?: boolean | undefined;
+    } | undefined;
+    requestedLimits?: {
+        maxEvidenceItems?: number | undefined;
+        maxRelationshipDepth?: number | undefined;
+        deadlineMs?: number | undefined;
+    } | undefined;
+    responseMode?: "evidence-bundle" | undefined;
+}, {
+    objective: string;
+    seeds?: {
+        kind: string;
+        id: string;
+    }[] | undefined;
+    domains?: string[] | undefined;
+    timeRange?: {
+        from: string;
+        to: string;
+    } | undefined;
+    freshness?: {
+        includeStable?: boolean | undefined;
+        includeLive?: boolean | undefined;
+    } | undefined;
+    requestedLimits?: {
+        maxEvidenceItems?: number | undefined;
+        maxRelationshipDepth?: number | undefined;
+        deadlineMs?: number | undefined;
+    } | undefined;
+    responseMode?: "evidence-bundle" | undefined;
+}>, {
+    objective: string;
+    seeds?: {
+        kind: string;
+        id: string;
+    }[] | undefined;
+    domains?: string[] | undefined;
+    timeRange?: {
+        from: string;
+        to: string;
+    } | undefined;
+    freshness?: {
+        includeStable?: boolean | undefined;
+        includeLive?: boolean | undefined;
+    } | undefined;
+    requestedLimits?: {
+        maxEvidenceItems?: number | undefined;
+        maxRelationshipDepth?: number | undefined;
+        deadlineMs?: number | undefined;
+    } | undefined;
+    responseMode?: "evidence-bundle" | undefined;
+}, {
+    objective: string;
+    seeds?: {
+        kind: string;
+        id: string;
+    }[] | undefined;
+    domains?: string[] | undefined;
+    timeRange?: {
+        from: string;
+        to: string;
+    } | undefined;
+    freshness?: {
+        includeStable?: boolean | undefined;
+        includeLive?: boolean | undefined;
+    } | undefined;
+    requestedLimits?: {
+        maxEvidenceItems?: number | undefined;
+        maxRelationshipDepth?: number | undefined;
+        deadlineMs?: number | undefined;
+    } | undefined;
+    responseMode?: "evidence-bundle" | undefined;
+}>;
+export type ScopeRequest = z.infer<typeof ScopeRequestSchema>;
+export declare const TrustedExecutionContextSchema: z.ZodObject<{
+    orgId: z.ZodString;
+    agentIds: z.ZodArray<z.ZodString, "many">;
+    callerId: z.ZodString;
+    principalId: z.ZodOptional<z.ZodString>;
+    permissions: z.ZodArray<z.ZodString, "many">;
+    classificationCeiling: z.ZodString;
+    traceId: z.ZodString;
+    deadlineAt: z.ZodString;
+    budgets: z.ZodObject<{
+        maxWallTimeMs: z.ZodNumber;
+        maxSdkCalls: z.ZodNumber;
+        maxPages: z.ZodNumber;
+        maxRecords: z.ZodNumber;
+        maxBytes: z.ZodNumber;
+        maxEvidenceItems: z.ZodNumber;
+        maxRelationshipDepth: z.ZodNumber;
+        maxReasoningRounds: z.ZodNumber;
+        maxParallelCalls: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        maxEvidenceItems: number;
+        maxParallelCalls: number;
+        maxWallTimeMs: number;
+        maxSdkCalls: number;
+        maxPages: number;
+        maxRecords: number;
+        maxBytes: number;
+        maxRelationshipDepth: number;
+        maxReasoningRounds: number;
+    }, {
+        maxEvidenceItems: number;
+        maxParallelCalls: number;
+        maxWallTimeMs: number;
+        maxSdkCalls: number;
+        maxPages: number;
+        maxRecords: number;
+        maxBytes: number;
+        maxRelationshipDepth: number;
+        maxReasoningRounds: number;
+    }>;
+    flags: z.ZodObject<{
+        bagsOnly: z.ZodBoolean;
+        nexumExploreEnabled: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        bagsOnly: boolean;
+        nexumExploreEnabled: boolean;
+    }, {
+        bagsOnly: boolean;
+        nexumExploreEnabled: boolean;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    orgId: string;
+    agentIds: string[];
+    traceId: string;
+    budgets: {
+        maxEvidenceItems: number;
+        maxParallelCalls: number;
+        maxWallTimeMs: number;
+        maxSdkCalls: number;
+        maxPages: number;
+        maxRecords: number;
+        maxBytes: number;
+        maxRelationshipDepth: number;
+        maxReasoningRounds: number;
+    };
+    callerId: string;
+    permissions: string[];
+    classificationCeiling: string;
+    deadlineAt: string;
+    flags: {
+        bagsOnly: boolean;
+        nexumExploreEnabled: boolean;
+    };
+    principalId?: string | undefined;
+}, {
+    orgId: string;
+    agentIds: string[];
+    traceId: string;
+    budgets: {
+        maxEvidenceItems: number;
+        maxParallelCalls: number;
+        maxWallTimeMs: number;
+        maxSdkCalls: number;
+        maxPages: number;
+        maxRecords: number;
+        maxBytes: number;
+        maxRelationshipDepth: number;
+        maxReasoningRounds: number;
+    };
+    callerId: string;
+    permissions: string[];
+    classificationCeiling: string;
+    deadlineAt: string;
+    flags: {
+        bagsOnly: boolean;
+        nexumExploreEnabled: boolean;
+    };
+    principalId?: string | undefined;
+}>;
+export type TrustedExecutionContext = z.infer<typeof TrustedExecutionContextSchema>;
+export declare const ConflictItemSchema: z.ZodObject<{
+    description: z.ZodString;
+    evidenceIds: z.ZodArray<z.ZodString, "many">;
+    resolution: z.ZodEnum<["unresolved", "source-precedence", "different-context"]>;
+}, "strip", z.ZodTypeAny, {
+    evidenceIds: string[];
+    description: string;
+    resolution: "unresolved" | "source-precedence" | "different-context";
+}, {
+    evidenceIds: string[];
+    description: string;
+    resolution: "unresolved" | "source-precedence" | "different-context";
+}>;
+export declare const UnknownItemSchema: z.ZodObject<{
+    question: z.ZodString;
+    reason: z.ZodString;
+    missingDatasets: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    question: string;
+    reason: string;
+    missingDatasets?: string[] | undefined;
+}, {
+    question: string;
+    reason: string;
+    missingDatasets?: string[] | undefined;
+}>;
+export declare const WarningItemSchema: z.ZodObject<{
+    code: z.ZodString;
+    message: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    code: string;
+    message: string;
+}, {
+    code: string;
+    message: string;
+}>;
+export type WarningItem = z.infer<typeof WarningItemSchema>;
+export type ConflictItem = z.infer<typeof ConflictItemSchema>;
+export type UnknownItem = z.infer<typeof UnknownItemSchema>;
+export type Continuation = z.infer<typeof ContinuationSchema>;
+export declare const ContinuationSchema: z.ZodObject<{
+    kind: z.ZodEnum<["cursor", "refinement-required", "budget-exhausted"]>;
+    token: z.ZodOptional<z.ZodString>;
+    suggestion: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    kind: "cursor" | "refinement-required" | "budget-exhausted";
+    token?: string | undefined;
+    suggestion?: string | undefined;
+}, {
+    kind: "cursor" | "refinement-required" | "budget-exhausted";
+    token?: string | undefined;
+    suggestion?: string | undefined;
+}>;
+export declare const EvidenceBundleSchema: z.ZodObject<{
+    requestId: z.ZodString;
+    status: z.ZodEnum<["complete", "partial", "unavailable", "rejected"]>;
+    interpretation: z.ZodObject<{
+        objective: z.ZodString;
+        assumptions: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        objective: string;
+        assumptions: string[];
+    }, {
+        objective: string;
+        assumptions: string[];
+    }>;
+    execution: z.ZodObject<{
+        catalogVersion: z.ZodString;
+        profiles: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            version: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            id: string;
+            version: string;
+        }, {
+            id: string;
+            version: string;
+        }>, "many">;
+        surfaces: z.ZodArray<z.ZodEnum<["estate-bag", "subject", "knowledge-explore"]>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        catalogVersion: string;
+        profiles: {
+            id: string;
+            version: string;
+        }[];
+        surfaces: ("subject" | "estate-bag" | "knowledge-explore")[];
+    }, {
+        catalogVersion: string;
+        profiles: {
+            id: string;
+            version: string;
+        }[];
+        surfaces: ("subject" | "estate-bag" | "knowledge-explore")[];
+    }>;
+    evidence: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        ref: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+            kind: z.ZodLiteral<"subject">;
+            orgId: z.ZodString;
+            objectType: z.ZodString;
+            contentType: z.ZodString;
+            recordId: z.ZodString;
+            revision: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodString]>>;
+        }, "strip", z.ZodTypeAny, {
+            kind: "subject";
+            orgId: string;
+            objectType: string;
+            contentType: string;
+            recordId: string;
+            revision?: string | number | undefined;
+        }, {
+            kind: "subject";
+            orgId: string;
+            objectType: string;
+            contentType: string;
+            recordId: string;
+            revision?: string | number | undefined;
+        }>, z.ZodObject<{
+            kind: z.ZodLiteral<"estate-bag">;
+            orgId: z.ZodString;
+            sessionId: z.ZodString;
+            bagId: z.ZodString;
+            path: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            kind: "estate-bag";
+            orgId: string;
+            sessionId: string;
+            bagId: string;
+            path?: string | undefined;
+        }, {
+            kind: "estate-bag";
+            orgId: string;
+            sessionId: string;
+            bagId: string;
+            path?: string | undefined;
+        }>, z.ZodObject<{
+            kind: z.ZodLiteral<"knowledge-explore">;
+            orgId: z.ZodString;
+            exploreQueryId: z.ZodString;
+            nodeIds: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            kind: "knowledge-explore";
+            orgId: string;
+            exploreQueryId: string;
+            nodeIds?: string[] | undefined;
+        }, {
+            kind: "knowledge-explore";
+            orgId: string;
+            exploreQueryId: string;
+            nodeIds?: string[] | undefined;
+        }>]>;
+        summary: z.ZodString;
+        epistemic: z.ZodEnum<["OBSERVED", "INFERRED", "POLICY_CANDIDATE", "REACHABLE", "UNKNOWN", "CONFLICTING"]>;
+        confidence: z.ZodOptional<z.ZodNumber>;
+        payload: z.ZodOptional<z.ZodUnknown>;
+        tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        ref: {
+            kind: "subject";
+            orgId: string;
+            objectType: string;
+            contentType: string;
+            recordId: string;
+            revision?: string | number | undefined;
+        } | {
+            kind: "estate-bag";
+            orgId: string;
+            sessionId: string;
+            bagId: string;
+            path?: string | undefined;
+        } | {
+            kind: "knowledge-explore";
+            orgId: string;
+            exploreQueryId: string;
+            nodeIds?: string[] | undefined;
+        };
+        summary: string;
+        epistemic: "OBSERVED" | "INFERRED" | "POLICY_CANDIDATE" | "REACHABLE" | "UNKNOWN" | "CONFLICTING";
+        confidence?: number | undefined;
+        payload?: unknown;
+        tags?: string[] | undefined;
+    }, {
+        id: string;
+        ref: {
+            kind: "subject";
+            orgId: string;
+            objectType: string;
+            contentType: string;
+            recordId: string;
+            revision?: string | number | undefined;
+        } | {
+            kind: "estate-bag";
+            orgId: string;
+            sessionId: string;
+            bagId: string;
+            path?: string | undefined;
+        } | {
+            kind: "knowledge-explore";
+            orgId: string;
+            exploreQueryId: string;
+            nodeIds?: string[] | undefined;
+        };
+        summary: string;
+        epistemic: "OBSERVED" | "INFERRED" | "POLICY_CANDIDATE" | "REACHABLE" | "UNKNOWN" | "CONFLICTING";
+        confidence?: number | undefined;
+        payload?: unknown;
+        tags?: string[] | undefined;
+    }>, "many">;
+    coverage: z.ZodObject<{
+        complete: z.ZodBoolean;
+        datasetsRead: z.ZodArray<z.ZodString, "many">;
+        datasetsSkipped: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            reason: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            id: string;
+            reason: string;
+        }, {
+            id: string;
+            reason: string;
+        }>, "many">;
+        countChecks: z.ZodArray<z.ZodObject<{
+            dataset: z.ZodString;
+            expected: z.ZodOptional<z.ZodNumber>;
+            actual: z.ZodNumber;
+            matched: z.ZodBoolean;
+        }, "strip", z.ZodTypeAny, {
+            dataset: string;
+            actual: number;
+            matched: boolean;
+            expected?: number | undefined;
+        }, {
+            dataset: string;
+            actual: number;
+            matched: boolean;
+            expected?: number | undefined;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        complete: boolean;
+        datasetsRead: string[];
+        datasetsSkipped: {
+            id: string;
+            reason: string;
+        }[];
+        countChecks: {
+            dataset: string;
+            actual: number;
+            matched: boolean;
+            expected?: number | undefined;
+        }[];
+    }, {
+        complete: boolean;
+        datasetsRead: string[];
+        datasetsSkipped: {
+            id: string;
+            reason: string;
+        }[];
+        countChecks: {
+            dataset: string;
+            actual: number;
+            matched: boolean;
+            expected?: number | undefined;
+        }[];
+    }>;
+    conflicts: z.ZodArray<z.ZodObject<{
+        description: z.ZodString;
+        evidenceIds: z.ZodArray<z.ZodString, "many">;
+        resolution: z.ZodEnum<["unresolved", "source-precedence", "different-context"]>;
+    }, "strip", z.ZodTypeAny, {
+        evidenceIds: string[];
+        description: string;
+        resolution: "unresolved" | "source-precedence" | "different-context";
+    }, {
+        evidenceIds: string[];
+        description: string;
+        resolution: "unresolved" | "source-precedence" | "different-context";
+    }>, "many">;
+    unknowns: z.ZodArray<z.ZodObject<{
+        question: z.ZodString;
+        reason: z.ZodString;
+        missingDatasets: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        question: string;
+        reason: string;
+        missingDatasets?: string[] | undefined;
+    }, {
+        question: string;
+        reason: string;
+        missingDatasets?: string[] | undefined;
+    }>, "many">;
+    warnings: z.ZodArray<z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        code: string;
+        message: string;
+    }, {
+        code: string;
+        message: string;
+    }>, "many">;
+    continuation: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        kind: z.ZodEnum<["cursor", "refinement-required", "budget-exhausted"]>;
+        token: z.ZodOptional<z.ZodString>;
+        suggestion: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        kind: "cursor" | "refinement-required" | "budget-exhausted";
+        token?: string | undefined;
+        suggestion?: string | undefined;
+    }, {
+        kind: "cursor" | "refinement-required" | "budget-exhausted";
+        token?: string | undefined;
+        suggestion?: string | undefined;
+    }>>>;
+    traceId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    status: "complete" | "partial" | "unavailable" | "rejected";
+    conflicts: {
+        evidenceIds: string[];
+        description: string;
+        resolution: "unresolved" | "source-precedence" | "different-context";
+    }[];
+    unknowns: {
+        question: string;
+        reason: string;
+        missingDatasets?: string[] | undefined;
+    }[];
+    warnings: {
+        code: string;
+        message: string;
+    }[];
+    traceId: string;
+    requestId: string;
+    interpretation: {
+        objective: string;
+        assumptions: string[];
+    };
+    execution: {
+        catalogVersion: string;
+        profiles: {
+            id: string;
+            version: string;
+        }[];
+        surfaces: ("subject" | "estate-bag" | "knowledge-explore")[];
+    };
+    evidence: {
+        id: string;
+        ref: {
+            kind: "subject";
+            orgId: string;
+            objectType: string;
+            contentType: string;
+            recordId: string;
+            revision?: string | number | undefined;
+        } | {
+            kind: "estate-bag";
+            orgId: string;
+            sessionId: string;
+            bagId: string;
+            path?: string | undefined;
+        } | {
+            kind: "knowledge-explore";
+            orgId: string;
+            exploreQueryId: string;
+            nodeIds?: string[] | undefined;
+        };
+        summary: string;
+        epistemic: "OBSERVED" | "INFERRED" | "POLICY_CANDIDATE" | "REACHABLE" | "UNKNOWN" | "CONFLICTING";
+        confidence?: number | undefined;
+        payload?: unknown;
+        tags?: string[] | undefined;
+    }[];
+    coverage: {
+        complete: boolean;
+        datasetsRead: string[];
+        datasetsSkipped: {
+            id: string;
+            reason: string;
+        }[];
+        countChecks: {
+            dataset: string;
+            actual: number;
+            matched: boolean;
+            expected?: number | undefined;
+        }[];
+    };
+    continuation?: {
+        kind: "cursor" | "refinement-required" | "budget-exhausted";
+        token?: string | undefined;
+        suggestion?: string | undefined;
+    } | null | undefined;
+}, {
+    status: "complete" | "partial" | "unavailable" | "rejected";
+    conflicts: {
+        evidenceIds: string[];
+        description: string;
+        resolution: "unresolved" | "source-precedence" | "different-context";
+    }[];
+    unknowns: {
+        question: string;
+        reason: string;
+        missingDatasets?: string[] | undefined;
+    }[];
+    warnings: {
+        code: string;
+        message: string;
+    }[];
+    traceId: string;
+    requestId: string;
+    interpretation: {
+        objective: string;
+        assumptions: string[];
+    };
+    execution: {
+        catalogVersion: string;
+        profiles: {
+            id: string;
+            version: string;
+        }[];
+        surfaces: ("subject" | "estate-bag" | "knowledge-explore")[];
+    };
+    evidence: {
+        id: string;
+        ref: {
+            kind: "subject";
+            orgId: string;
+            objectType: string;
+            contentType: string;
+            recordId: string;
+            revision?: string | number | undefined;
+        } | {
+            kind: "estate-bag";
+            orgId: string;
+            sessionId: string;
+            bagId: string;
+            path?: string | undefined;
+        } | {
+            kind: "knowledge-explore";
+            orgId: string;
+            exploreQueryId: string;
+            nodeIds?: string[] | undefined;
+        };
+        summary: string;
+        epistemic: "OBSERVED" | "INFERRED" | "POLICY_CANDIDATE" | "REACHABLE" | "UNKNOWN" | "CONFLICTING";
+        confidence?: number | undefined;
+        payload?: unknown;
+        tags?: string[] | undefined;
+    }[];
+    coverage: {
+        complete: boolean;
+        datasetsRead: string[];
+        datasetsSkipped: {
+            id: string;
+            reason: string;
+        }[];
+        countChecks: {
+            dataset: string;
+            actual: number;
+            matched: boolean;
+            expected?: number | undefined;
+        }[];
+    };
+    continuation?: {
+        kind: "cursor" | "refinement-required" | "budget-exhausted";
+        token?: string | undefined;
+        suggestion?: string | undefined;
+    } | null | undefined;
+}>;
+export type EvidenceBundle = z.infer<typeof EvidenceBundleSchema>;
+export declare const RetrievalStepSchema: z.ZodObject<{
+    stepId: z.ZodString;
+    operationId: z.ZodString;
+    arguments: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    dependsOn: z.ZodArray<z.ZodString, "many">;
+    purpose: z.ZodString;
+    optional: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    stepId: string;
+    operationId: string;
+    arguments: Record<string, unknown>;
+    dependsOn: string[];
+    purpose: string;
+    optional: boolean;
+}, {
+    stepId: string;
+    operationId: string;
+    arguments: Record<string, unknown>;
+    dependsOn: string[];
+    purpose: string;
+    optional: boolean;
+}>;
+export declare const RetrievalPlanSchema: z.ZodObject<{
+    planId: z.ZodString;
+    objective: z.ZodString;
+    profiles: z.ZodArray<z.ZodString, "many">;
+    steps: z.ZodArray<z.ZodObject<{
+        stepId: z.ZodString;
+        operationId: z.ZodString;
+        arguments: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        dependsOn: z.ZodArray<z.ZodString, "many">;
+        purpose: z.ZodString;
+        optional: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        stepId: string;
+        operationId: string;
+        arguments: Record<string, unknown>;
+        dependsOn: string[];
+        purpose: string;
+        optional: boolean;
+    }, {
+        stepId: string;
+        operationId: string;
+        arguments: Record<string, unknown>;
+        dependsOn: string[];
+        purpose: string;
+        optional: boolean;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    planId: string;
+    steps: {
+        stepId: string;
+        operationId: string;
+        arguments: Record<string, unknown>;
+        dependsOn: string[];
+        purpose: string;
+        optional: boolean;
+    }[];
+    objective: string;
+    profiles: string[];
+}, {
+    planId: string;
+    steps: {
+        stepId: string;
+        operationId: string;
+        arguments: Record<string, unknown>;
+        dependsOn: string[];
+        purpose: string;
+        optional: boolean;
+    }[];
+    objective: string;
+    profiles: string[];
+}>;
+export type RetrievalPlan = z.infer<typeof RetrievalPlanSchema>;
+export type RetrievalStep = z.infer<typeof RetrievalStepSchema>;
+export declare const EvidenceSelectionSchema: z.ZodObject<{
+    selectedEvidenceIds: z.ZodArray<z.ZodString, "many">;
+    conflicts: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        description: z.ZodString;
+        evidenceIds: z.ZodArray<z.ZodString, "many">;
+        resolution: z.ZodEnum<["unresolved", "source-precedence", "different-context"]>;
+    }, "strip", z.ZodTypeAny, {
+        evidenceIds: string[];
+        description: string;
+        resolution: "unresolved" | "source-precedence" | "different-context";
+    }, {
+        evidenceIds: string[];
+        description: string;
+        resolution: "unresolved" | "source-precedence" | "different-context";
+    }>, "many">>;
+    unknowns: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        question: z.ZodString;
+        reason: z.ZodString;
+        missingDatasets: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        question: string;
+        reason: string;
+        missingDatasets?: string[] | undefined;
+    }, {
+        question: string;
+        reason: string;
+        missingDatasets?: string[] | undefined;
+    }>, "many">>;
+    notes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    selectedEvidenceIds: string[];
+    conflicts?: {
+        evidenceIds: string[];
+        description: string;
+        resolution: "unresolved" | "source-precedence" | "different-context";
+    }[] | undefined;
+    unknowns?: {
+        question: string;
+        reason: string;
+        missingDatasets?: string[] | undefined;
+    }[] | undefined;
+    notes?: string[] | undefined;
+}, {
+    selectedEvidenceIds: string[];
+    conflicts?: {
+        evidenceIds: string[];
+        description: string;
+        resolution: "unresolved" | "source-precedence" | "different-context";
+    }[] | undefined;
+    unknowns?: {
+        question: string;
+        reason: string;
+        missingDatasets?: string[] | undefined;
+    }[] | undefined;
+    notes?: string[] | undefined;
+}>;
+export type EvidenceSelection = z.infer<typeof EvidenceSelectionSchema>;
+export declare const IdentifierDescriptorSchema: z.ZodObject<{
+    name: z.ZodString;
+    kind: z.ZodString;
+    required: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    kind: string;
+    name: string;
+    required?: boolean | undefined;
+}, {
+    kind: string;
+    name: string;
+    required?: boolean | undefined;
+}>;
+export declare const RelationshipDescriptorSchema: z.ZodObject<{
+    name: z.ZodString;
+    target: z.ZodString;
+    cardinality: z.ZodString;
+    strength: z.ZodEnum<["identity", "authoritative-relation", "weak-correlation"]>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    target: string;
+    cardinality: string;
+    strength: "identity" | "authoritative-relation" | "weak-correlation";
+}, {
+    name: string;
+    target: string;
+    cardinality: string;
+    strength: "identity" | "authoritative-relation" | "weak-correlation";
+}>;
+export declare const CatalogEntrySchema: z.ZodObject<{
+    id: z.ZodString;
+    version: z.ZodString;
+    description: z.ZodString;
+    surface: z.ZodEnum<["estate-bag", "subject", "knowledge-explore"]>;
+    operation: z.ZodString;
+    physicalContractVersion: z.ZodString;
+    identifiers: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        kind: z.ZodString;
+        required: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        kind: string;
+        name: string;
+        required?: boolean | undefined;
+    }, {
+        kind: string;
+        name: string;
+        required?: boolean | undefined;
+    }>, "many">;
+    relationships: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        target: z.ZodString;
+        cardinality: z.ZodString;
+        strength: z.ZodEnum<["identity", "authoritative-relation", "weak-correlation"]>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        target: string;
+        cardinality: string;
+        strength: "identity" | "authoritative-relation" | "weak-correlation";
+    }, {
+        name: string;
+        target: string;
+        cardinality: string;
+        strength: "identity" | "authoritative-relation" | "weak-correlation";
+    }>, "many">;
+    clock: z.ZodOptional<z.ZodEnum<["stable", "live"]>>;
+    epistemicPlanes: z.ZodArray<z.ZodString, "many">;
+    limits: z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodNumber, z.ZodString, z.ZodBoolean]>>;
+    classification: z.ZodString;
+    requiredPermissions: z.ZodArray<z.ZodString, "many">;
+    mayBeMissing: z.ZodBoolean;
+    limitations: z.ZodArray<z.ZodString, "many">;
+    prohibitedInferences: z.ZodArray<z.ZodString, "many">;
+    owner: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    description: string;
+    version: string;
+    surface: "subject" | "estate-bag" | "knowledge-explore";
+    operation: string;
+    physicalContractVersion: string;
+    identifiers: {
+        kind: string;
+        name: string;
+        required?: boolean | undefined;
+    }[];
+    relationships: {
+        name: string;
+        target: string;
+        cardinality: string;
+        strength: "identity" | "authoritative-relation" | "weak-correlation";
+    }[];
+    epistemicPlanes: string[];
+    limits: Record<string, string | number | boolean>;
+    classification: string;
+    requiredPermissions: string[];
+    mayBeMissing: boolean;
+    limitations: string[];
+    prohibitedInferences: string[];
+    owner: string;
+    clock?: "stable" | "live" | undefined;
+}, {
+    id: string;
+    description: string;
+    version: string;
+    surface: "subject" | "estate-bag" | "knowledge-explore";
+    operation: string;
+    physicalContractVersion: string;
+    identifiers: {
+        kind: string;
+        name: string;
+        required?: boolean | undefined;
+    }[];
+    relationships: {
+        name: string;
+        target: string;
+        cardinality: string;
+        strength: "identity" | "authoritative-relation" | "weak-correlation";
+    }[];
+    epistemicPlanes: string[];
+    limits: Record<string, string | number | boolean>;
+    classification: string;
+    requiredPermissions: string[];
+    mayBeMissing: boolean;
+    limitations: string[];
+    prohibitedInferences: string[];
+    owner: string;
+    clock?: "stable" | "live" | undefined;
+}>;
+export type CatalogEntry = z.infer<typeof CatalogEntrySchema>;
+export declare const ScoperProfileSchema: z.ZodObject<{
+    id: z.ZodString;
+    version: z.ZodString;
+    description: z.ZodString;
+    domains: z.ZodArray<z.ZodString, "many">;
+    requiredCatalogEntries: z.ZodArray<z.ZodString, "many">;
+    retrievalGuidance: z.ZodArray<z.ZodString, "many">;
+    prohibitedInferences: z.ZodArray<z.ZodString, "many">;
+    defaultBudgets: z.ZodObject<{
+        maxWallTimeMs: z.ZodOptional<z.ZodNumber>;
+        maxSdkCalls: z.ZodOptional<z.ZodNumber>;
+        maxPages: z.ZodOptional<z.ZodNumber>;
+        maxRecords: z.ZodOptional<z.ZodNumber>;
+        maxBytes: z.ZodOptional<z.ZodNumber>;
+        maxEvidenceItems: z.ZodOptional<z.ZodNumber>;
+        maxRelationshipDepth: z.ZodOptional<z.ZodNumber>;
+        maxReasoningRounds: z.ZodOptional<z.ZodNumber>;
+        maxParallelCalls: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        maxEvidenceItems?: number | undefined;
+        maxParallelCalls?: number | undefined;
+        maxWallTimeMs?: number | undefined;
+        maxSdkCalls?: number | undefined;
+        maxPages?: number | undefined;
+        maxRecords?: number | undefined;
+        maxBytes?: number | undefined;
+        maxRelationshipDepth?: number | undefined;
+        maxReasoningRounds?: number | undefined;
+    }, {
+        maxEvidenceItems?: number | undefined;
+        maxParallelCalls?: number | undefined;
+        maxWallTimeMs?: number | undefined;
+        maxSdkCalls?: number | undefined;
+        maxPages?: number | undefined;
+        maxRecords?: number | undefined;
+        maxBytes?: number | undefined;
+        maxRelationshipDepth?: number | undefined;
+        maxReasoningRounds?: number | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    description: string;
+    version: string;
+    defaultBudgets: {
+        maxEvidenceItems?: number | undefined;
+        maxParallelCalls?: number | undefined;
+        maxWallTimeMs?: number | undefined;
+        maxSdkCalls?: number | undefined;
+        maxPages?: number | undefined;
+        maxRecords?: number | undefined;
+        maxBytes?: number | undefined;
+        maxRelationshipDepth?: number | undefined;
+        maxReasoningRounds?: number | undefined;
+    };
+    domains: string[];
+    prohibitedInferences: string[];
+    requiredCatalogEntries: string[];
+    retrievalGuidance: string[];
+}, {
+    id: string;
+    description: string;
+    version: string;
+    defaultBudgets: {
+        maxEvidenceItems?: number | undefined;
+        maxParallelCalls?: number | undefined;
+        maxWallTimeMs?: number | undefined;
+        maxSdkCalls?: number | undefined;
+        maxPages?: number | undefined;
+        maxRecords?: number | undefined;
+        maxBytes?: number | undefined;
+        maxRelationshipDepth?: number | undefined;
+        maxReasoningRounds?: number | undefined;
+    };
+    domains: string[];
+    prohibitedInferences: string[];
+    requiredCatalogEntries: string[];
+    retrievalGuidance: string[];
+}>;
+export type ScoperProfile = z.infer<typeof ScoperProfileSchema>;
+//# sourceMappingURL=schemas.d.ts.map