@native-knowledge/knowledge-sdk 0.0.0-stage → 0.1.0-rc.2

package/dist/internal/contracts/currentness.js

@@ -0,0 +1,221 @@
+import { z } from 'zod';
+import { isoDateTimeSchema, projectKeySchema, schemaVersionSchema, stableUriSchema } from './common.js';
+export const currentnessStateSchema = z.enum(['CURRENT', 'DUE', 'STALE', 'BLOCKED', 'UNKNOWN']);
+export const currentnessActionSchema = z.enum(['ALLOW', 'REVIEW_REQUIRED', 'DENY']);
+export const currentnessSubjectKindSchema = z.enum(['SOURCE', 'EVIDENCE', 'ARTIFACT']);
+export const currentnessPolicySchema = z.object({
+    schemaVersion: schemaVersionSchema,
+    dueAfterSeconds: z.number().int().min(60).max(366 * 24 * 60 * 60),
+    staleAfterSeconds: z.number().int().min(60).max(5 * 366 * 24 * 60 * 60),
+    staleAction: currentnessActionSchema.default('REVIEW_REQUIRED'),
+    unknownAction: currentnessActionSchema.default('REVIEW_REQUIRED'),
+    blockedAction: currentnessActionSchema.default('REVIEW_REQUIRED'),
+}).strict().superRefine((value, ctx) => {
+    if (value.staleAfterSeconds < value.dueAfterSeconds) {
+        ctx.addIssue({ code: 'custom', path: ['staleAfterSeconds'], message: 'staleAfterSeconds must be >= dueAfterSeconds' });
+    }
+});
+export const currentnessReasonCodeSchema = z.enum([
+    'CURRENT_WITHIN_CADENCE',
+    'REFRESH_DUE',
+    'STALE_AFTER_THRESHOLD',
+    'SOURCE_BLOCKED',
+    'SOURCE_CONTENT_CHANGED',
+    'NO_SUCCESSFUL_OBSERVATION',
+]);
+export const currentnessAssessmentSchema = z.object({
+    schemaVersion: schemaVersionSchema,
+    subjectRef: stableUriSchema,
+    subjectKind: currentnessSubjectKindSchema,
+    projectRef: stableUriSchema.optional(),
+    sourceRevisionRef: stableUriSchema.optional(),
+    basisRef: stableUriSchema.nullable().default(null),
+    state: currentnessStateSchema,
+    action: currentnessActionSchema,
+    assessedAt: isoDateTimeSchema,
+    observedAt: isoDateTimeSchema.nullable().default(null),
+    lastSuccessAt: isoDateTimeSchema.nullable().default(null),
+    lastAttemptAt: isoDateTimeSchema.nullable().default(null),
+    dueAt: isoDateTimeSchema.nullable().default(null),
+    staleAt: isoDateTimeSchema.nullable().default(null),
+    ageSeconds: z.number().int().nonnegative().nullable().default(null),
+    reasonCode: currentnessReasonCodeSchema,
+    policy: currentnessPolicySchema,
+}).strict();
+export const claimCurrentnessStatusSchema = z.enum([
+    'CURRENT',
+    'PARTIALLY_SUPERSEDED',
+    'SUPERSEDED',
+    'PENDING_CURRENTNESS_REVIEW',
+    'HISTORICAL_REFERENCE',
+    'DYNAMIC_CURRENT',
+    'DYNAMIC_EXPIRED',
+]);
+export const claimCurrentnessRiskSchema = z.enum(['STANDARD', 'HIGH']);
+export const claimTimeSensitivitySchema = z.enum(['DURABLE', 'TIME_SENSITIVE', 'DYNAMIC']);
+export const claimReviewTriggerSchema = z.enum([
+    'SCHEDULED_REFRESH',
+    'SAME_URL_DIFFERENT_HASH',
+    'LATER_OFFICIAL_SOURCE',
+    'REGULATORY_ACTION',
+    'OPERATOR_TRANSITION',
+    'CORRECTION',
+    'DYNAMIC_EXPIRY',
+    'INITIAL_REVIEW',
+]);
+const evidenceUriSchema = stableUriSchema.refine((value) => value.toLowerCase().startsWith('evidence://'), 'claim provenance must use EvidenceRef');
+const claimIdSchema = z.string().trim().min(1).max(128).regex(/^[A-Za-z0-9][A-Za-z0-9._:-]*$/);
+export const claimCurrentnessChangeSchema = z.object({
+    schemaVersion: schemaVersionSchema,
+    artifactRef: stableUriSchema,
+    claimId: claimIdSchema,
+    scope: z.string().trim().min(1).max(1000),
+    status: claimCurrentnessStatusSchema,
+    risk: claimCurrentnessRiskSchema.default('STANDARD'),
+    timeSensitivity: claimTimeSensitivitySchema.default('DURABLE'),
+    effectiveFrom: isoDateTimeSchema.nullable().default(null),
+    effectiveUntil: isoDateTimeSchema.nullable().default(null),
+    discoveredAt: isoDateTimeSchema,
+    reviewTrigger: claimReviewTriggerSchema,
+    previousEvidenceRefs: z.array(evidenceUriSchema).max(64).default([]),
+    currentEvidenceRefs: z.array(evidenceUriSchema).max(64).default([]),
+    replacementArtifactRef: stableUriSchema.nullable().default(null),
+    reason: z.string().trim().min(1).max(4000),
+}).strict().superRefine((value, ctx) => {
+    const prior = new Set(value.previousEvidenceRefs);
+    const current = new Set(value.currentEvidenceRefs);
+    if (prior.size !== value.previousEvidenceRefs.length)
+        ctx.addIssue({ code: 'custom', path: ['previousEvidenceRefs'], message: 'duplicate previous EvidenceRef' });
+    if (current.size !== value.currentEvidenceRefs.length)
+        ctx.addIssue({ code: 'custom', path: ['currentEvidenceRefs'], message: 'duplicate current EvidenceRef' });
+    if ([...prior].some((ref) => current.has(ref)))
+        ctx.addIssue({ code: 'custom', path: ['currentEvidenceRefs'], message: 'previous and current EvidenceRefs must be distinct' });
+    if (value.effectiveFrom && value.effectiveUntil && Date.parse(value.effectiveUntil) <= Date.parse(value.effectiveFrom)) {
+        ctx.addIssue({ code: 'custom', path: ['effectiveUntil'], message: 'effectiveUntil must be later than effectiveFrom' });
+    }
+    if (value.timeSensitivity === 'TIME_SENSITIVE' && value.status !== 'PENDING_CURRENTNESS_REVIEW' && !value.effectiveFrom) {
+        ctx.addIssue({ code: 'custom', path: ['effectiveFrom'], message: 'time-sensitive reviewed claims require source-grounded effectiveFrom' });
+    }
+    if (value.timeSensitivity === 'DYNAMIC' && !value.effectiveUntil) {
+        ctx.addIssue({ code: 'custom', path: ['effectiveUntil'], message: 'dynamic claims require an explicit expiry boundary' });
+    }
+    if (value.status === 'DYNAMIC_CURRENT' && value.effectiveUntil && Date.parse(value.effectiveUntil) <= Date.parse(value.discoveredAt)) {
+        ctx.addIssue({ code: 'custom', path: ['effectiveUntil'], message: 'dynamic current claim must still be valid when discovered' });
+    }
+    if (value.status === 'DYNAMIC_EXPIRED' && value.effectiveUntil && Date.parse(value.discoveredAt) < Date.parse(value.effectiveUntil)) {
+        ctx.addIssue({ code: 'custom', path: ['effectiveUntil'], message: 'dynamic expired claim requires discovery at or after expiry' });
+    }
+    if (['CURRENT', 'DYNAMIC_CURRENT'].includes(value.status) && value.currentEvidenceRefs.length === 0) {
+        ctx.addIssue({ code: 'custom', path: ['currentEvidenceRefs'], message: 'current claim requires exact current EvidenceRef' });
+    }
+    if (['PARTIALLY_SUPERSEDED', 'SUPERSEDED'].includes(value.status)) {
+        if (value.previousEvidenceRefs.length === 0)
+            ctx.addIssue({ code: 'custom', path: ['previousEvidenceRefs'], message: 'supersession requires previous EvidenceRef' });
+        if (value.currentEvidenceRefs.length === 0)
+            ctx.addIssue({ code: 'custom', path: ['currentEvidenceRefs'], message: 'supersession requires replacement/current EvidenceRef' });
+    }
+    if (['HISTORICAL_REFERENCE', 'DYNAMIC_EXPIRED'].includes(value.status) && value.previousEvidenceRefs.length === 0) {
+        ctx.addIssue({ code: 'custom', path: ['previousEvidenceRefs'], message: 'historical/expired claim requires retained prior EvidenceRef' });
+    }
+    if (value.status === 'PENDING_CURRENTNESS_REVIEW' && value.previousEvidenceRefs.length === 0 && value.currentEvidenceRefs.length === 0) {
+        ctx.addIssue({ code: 'custom', path: ['currentEvidenceRefs'], message: 'pending currentness review requires at least one exact EvidenceRef' });
+    }
+});
+export const claimCurrentnessDecisionSchema = claimCurrentnessChangeSchema.safeExtend({
+    reviewedAt: isoDateTimeSchema,
+}).superRefine((value, ctx) => {
+    if (Date.parse(value.reviewedAt) < Date.parse(value.discoveredAt)) {
+        ctx.addIssue({ code: 'custom', path: ['reviewedAt'], message: 'reviewedAt must not precede discoveredAt' });
+    }
+    if (value.status === 'DYNAMIC_CURRENT' && value.effectiveUntil && Date.parse(value.reviewedAt) >= Date.parse(value.effectiveUntil)) {
+        ctx.addIssue({ code: 'custom', path: ['effectiveUntil'], message: 'dynamic current claim must not already be expired at review time' });
+    }
+});
+export const claimCurrentnessProposalSchema = z.object({
+    schemaVersion: schemaVersionSchema,
+    type: z.literal('CLAIM_CURRENTNESS_PROPOSAL'),
+    projectKey: projectKeySchema,
+    proposalId: z.string().trim().min(3).max(80).regex(/^[a-z0-9][a-z0-9._-]*$/),
+    artifactRef: stableUriSchema,
+    createdAt: isoDateTimeSchema,
+    changes: z.array(claimCurrentnessChangeSchema).min(1).max(256),
+}).strict().superRefine((value, ctx) => {
+    const ids = new Set();
+    value.changes.forEach((change, index) => {
+        if (change.artifactRef !== value.artifactRef)
+            ctx.addIssue({ code: 'custom', path: ['changes', index, 'artifactRef'], message: 'claim change artifactRef must match proposal artifactRef' });
+        if (ids.has(change.claimId))
+            ctx.addIssue({ code: 'custom', path: ['changes', index, 'claimId'], message: 'duplicate claimId in proposal' });
+        ids.add(change.claimId);
+        if (Date.parse(change.discoveredAt) > Date.parse(value.createdAt))
+            ctx.addIssue({ code: 'custom', path: ['changes', index, 'discoveredAt'], message: 'discoveredAt must not be after proposal createdAt' });
+    });
+});
+export const claimCurrentnessLedgerSchema = z.object({
+    schemaVersion: schemaVersionSchema,
+    ledgerId: z.string().regex(/^sha256:[a-f0-9]{64}$/),
+    projectKey: projectKeySchema,
+    artifactRef: stableUriSchema,
+    proposalRef: stableUriSchema,
+    reviewRef: stableUriSchema,
+    reviewedAt: isoDateTimeSchema,
+    decisionsHash: z.string().regex(/^sha256:[a-f0-9]{64}$/),
+    decisions: z.array(claimCurrentnessDecisionSchema).min(1).max(256),
+}).strict().superRefine((value, ctx) => {
+    const ids = new Set();
+    value.decisions.forEach((decision, index) => {
+        if (decision.artifactRef !== value.artifactRef)
+            ctx.addIssue({ code: 'custom', path: ['decisions', index, 'artifactRef'], message: 'decision artifactRef must match ledger artifactRef' });
+        if (decision.reviewedAt !== value.reviewedAt)
+            ctx.addIssue({ code: 'custom', path: ['decisions', index, 'reviewedAt'], message: 'decision reviewedAt must match ledger review' });
+        if (ids.has(decision.claimId))
+            ctx.addIssue({ code: 'custom', path: ['decisions', index, 'claimId'], message: 'duplicate claimId in ledger' });
+        ids.add(decision.claimId);
+    });
+});
+export const artifactSemanticStatusSchema = z.enum(['REVIEWED', 'SUPERSEDED']);
+export const artifactSupportStateSchema = z.enum([
+    'CURRENTLY_SUPPORTED',
+    'REFRESH_DUE',
+    'CURRENTNESS_REVIEW_REQUIRED',
+    'CURRENTNESS_DENIED',
+    'SUPERSEDED',
+]);
+export const artifactSupportEvidenceSchema = z.object({
+    evidenceRef: stableUriSchema,
+    state: currentnessStateSchema,
+    action: currentnessActionSchema,
+    assessedAt: isoDateTimeSchema,
+    lastSuccessAt: isoDateTimeSchema.nullable(),
+    reasonCode: currentnessReasonCodeSchema,
+}).strict();
+export const artifactSupportAssessmentSchema = z.object({
+    schemaVersion: schemaVersionSchema,
+    artifactRef: stableUriSchema,
+    identityRef: stableUriSchema,
+    projectKey: projectKeySchema,
+    artifactKind: z.enum(['KNOWLEDGE', 'INSIGHT']),
+    semanticStatus: artifactSemanticStatusSchema,
+    supportState: artifactSupportStateSchema,
+    action: currentnessActionSchema,
+    assessedAt: isoDateTimeSchema,
+    validUntil: isoDateTimeSchema.nullable(),
+    evidence: z.array(artifactSupportEvidenceSchema).max(256),
+    claims: z.array(claimCurrentnessDecisionSchema).max(256).default([]),
+    missingEvidenceRefs: z.array(stableUriSchema).max(256),
+    reasonCodes: z.array(z.enum([
+        'ALL_EVIDENCE_CURRENT',
+        'EVIDENCE_REFRESH_DUE',
+        'EVIDENCE_REVIEW_REQUIRED',
+        'EVIDENCE_DENIED',
+        'EVIDENCE_CURRENTNESS_MISSING',
+        'ARTIFACT_EVIDENCE_REQUIRED',
+        'ARTIFACT_VALIDITY_EXPIRED',
+        'ARTIFACT_EXPLICITLY_SUPERSEDED',
+        'CLAIM_PARTIALLY_SUPERSEDED',
+        'CLAIM_PENDING_CURRENTNESS_REVIEW',
+        'CLAIM_SUPERSEDED',
+        'CLAIM_HISTORICAL_REFERENCE',
+        'CLAIM_DYNAMIC_EXPIRED',
+    ])).min(1).max(32),
+}).strict();

package/dist/internal/contracts/event.d.ts

@@ -0,0 +1,60 @@
+import { z } from 'zod';
+export declare const knowledgeEventTypeSchema: z.ZodEnum<{
+    SOURCE_CHANGED: "SOURCE_CHANGED";
+    SOURCE_FAILURE: "SOURCE_FAILURE";
+    REVIEW_READY: "REVIEW_READY";
+    APPROVAL_READY: "APPROVAL_READY";
+    MATERIAL_DRIFT: "MATERIAL_DRIFT";
+    BOUNDARY_RISK: "BOUNDARY_RISK";
+    CURRENTNESS_RISK: "CURRENTNESS_RISK";
+    CLOSURE_MILESTONE: "CLOSURE_MILESTONE";
+    SCHEDULER_FAILURE: "SCHEDULER_FAILURE";
+    SIGNAL_READY: "SIGNAL_READY";
+    GAP_READY: "GAP_READY";
+    PROGRAM_EVOLUTION_READY: "PROGRAM_EVOLUTION_READY";
+}>;
+export declare const eventSeveritySchema: z.ZodEnum<{
+    INFO: "INFO";
+    NORMAL: "NORMAL";
+    WARNING: "WARNING";
+    CRITICAL: "CRITICAL";
+}>;
+export declare const knowledgeEventSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    eventId: z.ZodString;
+    projectKey: z.ZodOptional<z.ZodString>;
+    projectRef: z.ZodOptional<z.ZodString>;
+    sourceRef: z.ZodOptional<z.ZodString>;
+    sourceRevisionRef: z.ZodOptional<z.ZodString>;
+    collectionBatchRef: z.ZodOptional<z.ZodString>;
+    type: z.ZodEnum<{
+        SOURCE_CHANGED: "SOURCE_CHANGED";
+        SOURCE_FAILURE: "SOURCE_FAILURE";
+        REVIEW_READY: "REVIEW_READY";
+        APPROVAL_READY: "APPROVAL_READY";
+        MATERIAL_DRIFT: "MATERIAL_DRIFT";
+        BOUNDARY_RISK: "BOUNDARY_RISK";
+        CURRENTNESS_RISK: "CURRENTNESS_RISK";
+        CLOSURE_MILESTONE: "CLOSURE_MILESTONE";
+        SCHEDULER_FAILURE: "SCHEDULER_FAILURE";
+        SIGNAL_READY: "SIGNAL_READY";
+        GAP_READY: "GAP_READY";
+        PROGRAM_EVOLUTION_READY: "PROGRAM_EVOLUTION_READY";
+    }>;
+    severity: z.ZodEnum<{
+        INFO: "INFO";
+        NORMAL: "NORMAL";
+        WARNING: "WARNING";
+        CRITICAL: "CRITICAL";
+    }>;
+    createdAt: z.ZodISODateTime;
+    runtimeNodeId: z.ZodOptional<z.ZodString>;
+    artifactRef: z.ZodOptional<z.ZodString>;
+    evidenceRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    contentHash: z.ZodOptional<z.ZodString>;
+    requiresUserAction: z.ZodBoolean;
+    dedupeKey: z.ZodString;
+}, z.core.$strict>;
+export type KnowledgeEventType = z.infer<typeof knowledgeEventTypeSchema>;
+export type EventSeverity = z.infer<typeof eventSeveritySchema>;
+export type KnowledgeEvent = z.infer<typeof knowledgeEventSchema>;

package/dist/internal/contracts/event.js

@@ -0,0 +1,35 @@
+import { z } from 'zod';
+import { idSchema, isoDateTimeSchema, projectKeySchema, schemaVersionSchema, sha256Schema, stableUriSchema, } from './common.js';
+export const knowledgeEventTypeSchema = z.enum([
+    'SOURCE_CHANGED',
+    'SOURCE_FAILURE',
+    'REVIEW_READY',
+    'APPROVAL_READY',
+    'MATERIAL_DRIFT',
+    'BOUNDARY_RISK',
+    'CURRENTNESS_RISK',
+    'CLOSURE_MILESTONE',
+    'SCHEDULER_FAILURE',
+    'SIGNAL_READY',
+    'GAP_READY',
+    'PROGRAM_EVOLUTION_READY',
+]);
+export const eventSeveritySchema = z.enum(['INFO', 'NORMAL', 'WARNING', 'CRITICAL']);
+export const knowledgeEventSchema = z.object({
+    schemaVersion: schemaVersionSchema,
+    eventId: idSchema,
+    projectKey: projectKeySchema.optional(),
+    projectRef: stableUriSchema.optional(),
+    sourceRef: stableUriSchema.optional(),
+    sourceRevisionRef: stableUriSchema.optional(),
+    collectionBatchRef: stableUriSchema.optional(),
+    type: knowledgeEventTypeSchema,
+    severity: eventSeveritySchema,
+    createdAt: isoDateTimeSchema,
+    runtimeNodeId: idSchema.optional(),
+    artifactRef: stableUriSchema.optional(),
+    evidenceRefs: z.array(stableUriSchema).max(256).default([]),
+    contentHash: sha256Schema.optional(),
+    requiresUserAction: z.boolean(),
+    dedupeKey: z.string().trim().min(1).max(512),
+}).strict();

package/dist/internal/contracts/evidence.d.ts

@@ -0,0 +1,202 @@
+import { z } from 'zod';
+export declare const evidenceModalitySchema: z.ZodEnum<{
+    TEXT: "TEXT";
+    PDF: "PDF";
+    IMAGE: "IMAGE";
+    AUDIO: "AUDIO";
+    VIDEO: "VIDEO";
+    BINARY: "BINARY";
+}>;
+export declare const evidenceReviewModeSchema: z.ZodEnum<{
+    TEXT_NATIVE: "TEXT_NATIVE";
+    MULTIMODAL_NATIVE: "MULTIMODAL_NATIVE";
+    EXTERNAL_EXTRACTOR_REQUIRED: "EXTERNAL_EXTRACTOR_REQUIRED";
+}>;
+export declare const evidenceReviewInstructionSchema: z.ZodEnum<{
+    READ_ORIGINAL_TEXT: "READ_ORIGINAL_TEXT";
+    INSPECT_ORIGINAL_DOCUMENT: "INSPECT_ORIGINAL_DOCUMENT";
+    INSPECT_ORIGINAL_IMAGE: "INSPECT_ORIGINAL_IMAGE";
+    LISTEN_TO_ORIGINAL_AUDIO: "LISTEN_TO_ORIGINAL_AUDIO";
+    INSPECT_ORIGINAL_VIDEO: "INSPECT_ORIGINAL_VIDEO";
+    USE_APPROVED_EXTERNAL_EXTRACTOR: "USE_APPROVED_EXTERNAL_EXTRACTOR";
+}>;
+export declare const evidenceReviewHintsSchema: z.ZodObject<{
+    pageRanges: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        startPage: z.ZodNumber;
+        endPage: z.ZodNumber;
+    }, z.core.$strict>>>;
+    timeRanges: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        startMs: z.ZodNumber;
+        endMs: z.ZodNumber;
+    }, z.core.$strict>>>;
+    frameTimestampsMs: z.ZodDefault<z.ZodArray<z.ZodNumber>>;
+}, z.core.$strict>;
+export declare const evidenceReviewAttachmentSchema: z.ZodObject<{
+    evidenceRef: z.ZodString;
+    contentHash: z.ZodString;
+    mediaType: z.ZodString;
+    byteLength: z.ZodNullable<z.ZodNumber>;
+    modality: z.ZodEnum<{
+        TEXT: "TEXT";
+        PDF: "PDF";
+        IMAGE: "IMAGE";
+        AUDIO: "AUDIO";
+        VIDEO: "VIDEO";
+        BINARY: "BINARY";
+    }>;
+    reviewMode: z.ZodEnum<{
+        TEXT_NATIVE: "TEXT_NATIVE";
+        MULTIMODAL_NATIVE: "MULTIMODAL_NATIVE";
+        EXTERNAL_EXTRACTOR_REQUIRED: "EXTERNAL_EXTRACTOR_REQUIRED";
+    }>;
+    instruction: z.ZodEnum<{
+        READ_ORIGINAL_TEXT: "READ_ORIGINAL_TEXT";
+        INSPECT_ORIGINAL_DOCUMENT: "INSPECT_ORIGINAL_DOCUMENT";
+        INSPECT_ORIGINAL_IMAGE: "INSPECT_ORIGINAL_IMAGE";
+        LISTEN_TO_ORIGINAL_AUDIO: "LISTEN_TO_ORIGINAL_AUDIO";
+        INSPECT_ORIGINAL_VIDEO: "INSPECT_ORIGINAL_VIDEO";
+        USE_APPROVED_EXTERNAL_EXTRACTOR: "USE_APPROVED_EXTERNAL_EXTRACTOR";
+    }>;
+    rawBytesEmbedded: z.ZodLiteral<false>;
+    materializationRequired: z.ZodLiteral<true>;
+    reviewHints: z.ZodOptional<z.ZodObject<{
+        pageRanges: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            startPage: z.ZodNumber;
+            endPage: z.ZodNumber;
+        }, z.core.$strict>>>;
+        timeRanges: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            startMs: z.ZodNumber;
+            endMs: z.ZodNumber;
+        }, z.core.$strict>>>;
+        frameTimestampsMs: z.ZodDefault<z.ZodArray<z.ZodNumber>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const evidenceMaterializationReceiptSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    evidenceRef: z.ZodString;
+    contentHash: z.ZodString;
+    mediaType: z.ZodString;
+    byteLength: z.ZodNumber;
+    modality: z.ZodEnum<{
+        TEXT: "TEXT";
+        PDF: "PDF";
+        IMAGE: "IMAGE";
+        AUDIO: "AUDIO";
+        VIDEO: "VIDEO";
+        BINARY: "BINARY";
+    }>;
+    reviewMode: z.ZodEnum<{
+        TEXT_NATIVE: "TEXT_NATIVE";
+        MULTIMODAL_NATIVE: "MULTIMODAL_NATIVE";
+        EXTERNAL_EXTRACTOR_REQUIRED: "EXTERNAL_EXTRACTOR_REQUIRED";
+    }>;
+    instruction: z.ZodEnum<{
+        READ_ORIGINAL_TEXT: "READ_ORIGINAL_TEXT";
+        INSPECT_ORIGINAL_DOCUMENT: "INSPECT_ORIGINAL_DOCUMENT";
+        INSPECT_ORIGINAL_IMAGE: "INSPECT_ORIGINAL_IMAGE";
+        LISTEN_TO_ORIGINAL_AUDIO: "LISTEN_TO_ORIGINAL_AUDIO";
+        INSPECT_ORIGINAL_VIDEO: "INSPECT_ORIGINAL_VIDEO";
+        USE_APPROVED_EXTERNAL_EXTRACTOR: "USE_APPROVED_EXTERNAL_EXTRACTOR";
+    }>;
+    reviewHints: z.ZodOptional<z.ZodObject<{
+        pageRanges: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            startPage: z.ZodNumber;
+            endPage: z.ZodNumber;
+        }, z.core.$strict>>>;
+        timeRanges: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            startMs: z.ZodNumber;
+            endMs: z.ZodNumber;
+        }, z.core.$strict>>>;
+        frameTimestampsMs: z.ZodDefault<z.ZodArray<z.ZodNumber>>;
+    }, z.core.$strict>>;
+    access: z.ZodEnum<{
+        PUBLIC: "PUBLIC";
+        PUBLIC_METADATA: "PUBLIC_METADATA";
+        TENANT: "TENANT";
+        INTERNAL: "INTERNAL";
+        FDE_INTERNAL: "FDE_INTERNAL";
+        ACCESS_CONTROLLED: "ACCESS_CONTROLLED";
+        UNKNOWN: "UNKNOWN";
+    }>;
+    runtimeNodeId: z.ZodString;
+    materializedAt: z.ZodISODateTime;
+    runtimeLocalPath: z.ZodString;
+    reused: z.ZodBoolean;
+}, z.core.$strict>;
+export declare const collectorIdentitySchema: z.ZodObject<{
+    collectorId: z.ZodString;
+    version: z.ZodString;
+}, z.core.$strict>;
+/** 附属媒体沿用 Source 身份，但不能替代该 Source 的主文档。 */
+export declare const RICH_MEDIA_COLLECTOR_ID = "knowledge-v2.rich-document-media";
+export declare const evidenceRequestSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    method: z.ZodLiteral<"POST">;
+    bodyContentHash: z.ZodString;
+    bodyMediaType: z.ZodLiteral<"application/x-www-form-urlencoded">;
+    bodyByteLength: z.ZodNumber;
+}, z.core.$strict>;
+export declare const evidenceRefSchema: z.ZodObject<{
+    recoveryProvenance: z.ZodOptional<z.ZodObject<{
+        mode: z.ZodLiteral<"REUSED_PRIOR_EVIDENCE">;
+        originEvidenceRef: z.ZodString;
+        originProjectRef: z.ZodString;
+        originSourceRevisionRef: z.ZodString;
+        originRuntimeNodeId: z.ZodString;
+        handoffReceiptRef: z.ZodString;
+    }, z.core.$strict>>;
+    request: z.ZodOptional<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<1>;
+        method: z.ZodLiteral<"POST">;
+        bodyContentHash: z.ZodString;
+        bodyMediaType: z.ZodLiteral<"application/x-www-form-urlencoded">;
+        bodyByteLength: z.ZodNumber;
+    }, z.core.$strict>>;
+    schemaVersion: z.ZodLiteral<1>;
+    evidenceId: z.ZodString;
+    sourceId: z.ZodString;
+    sourceIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    projectKey: z.ZodOptional<z.ZodString>;
+    projectRef: z.ZodOptional<z.ZodString>;
+    collector: z.ZodObject<{
+        collectorId: z.ZodString;
+        version: z.ZodString;
+    }, z.core.$strict>;
+    contentHash: z.ZodString;
+    observedAt: z.ZodISODateTime;
+    runtimeNodeId: z.ZodString;
+    access: z.ZodEnum<{
+        PUBLIC: "PUBLIC";
+        PUBLIC_METADATA: "PUBLIC_METADATA";
+        TENANT: "TENANT";
+        INTERNAL: "INTERNAL";
+        FDE_INTERNAL: "FDE_INTERNAL";
+        ACCESS_CONTROLLED: "ACCESS_CONTROLLED";
+        UNKNOWN: "UNKNOWN";
+    }>;
+    canonicalUri: z.ZodOptional<z.ZodString>;
+    mediaType: z.ZodOptional<z.ZodString>;
+    byteLength: z.ZodOptional<z.ZodNumber>;
+    sourceSetRef: z.ZodOptional<z.ZodString>;
+    sourceItemId: z.ZodOptional<z.ZodString>;
+    sourceRevisionRef: z.ZodOptional<z.ZodString>;
+    collectionBatchRef: z.ZodOptional<z.ZodString>;
+    collectionTaskId: z.ZodOptional<z.ZodString>;
+    reviewHints: z.ZodOptional<z.ZodObject<{
+        pageRanges: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            startPage: z.ZodNumber;
+            endPage: z.ZodNumber;
+        }, z.core.$strict>>>;
+        timeRanges: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            startMs: z.ZodNumber;
+            endMs: z.ZodNumber;
+        }, z.core.$strict>>>;
+        frameTimestampsMs: z.ZodDefault<z.ZodArray<z.ZodNumber>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type CollectorIdentity = z.infer<typeof collectorIdentitySchema>;
+export type EvidenceRef = z.infer<typeof evidenceRefSchema>;
+export type EvidenceModality = z.infer<typeof evidenceModalitySchema>;
+export type EvidenceReviewMode = z.infer<typeof evidenceReviewModeSchema>;
+export type EvidenceReviewAttachment = z.infer<typeof evidenceReviewAttachmentSchema>;
+export type EvidenceMaterializationReceipt = z.infer<typeof evidenceMaterializationReceiptSchema>;