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

package/dist/internal/contracts/artifact.js

@@ -0,0 +1,103 @@
+import { z } from 'zod';
+import { accessClassificationSchema, isoDateTimeSchema, projectKeySchema, schemaVersionSchema, sha256Schema, stableUriSchema, } from './common.js';
+export const artifactIdSchema = z.string().trim().min(1).max(128).regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/);
+export const artifactKindSchema = z.enum([
+    'SIGNAL_GENERATION',
+    'RESEARCH',
+    'REVIEW',
+    'KNOWLEDGE',
+    'INSIGHT',
+]);
+export const artifactStatusSchema = z.enum([
+    'GENERATED',
+    'DRAFT',
+    'READY_FOR_REVIEW',
+    'REWORK_REQUIRED',
+    'APPROVED',
+    'REJECTED',
+    'SUPERSEDED',
+]);
+export const artifactManifestSchema = z.object({
+    schemaVersion: schemaVersionSchema,
+    artifactId: artifactIdSchema,
+    kind: artifactKindSchema,
+    projectKey: projectKeySchema,
+    projectRef: stableUriSchema.optional(),
+    version: z.number().int().positive(),
+    ref: stableUriSchema,
+    identityRef: stableUriSchema,
+    status: artifactStatusSchema,
+    access: accessClassificationSchema.default('INTERNAL'),
+    title: z.string().trim().min(1).max(500).optional(),
+    createdAt: isoDateTimeSchema,
+    observedAt: isoDateTimeSchema.nullable().default(null),
+    validUntil: isoDateTimeSchema.nullable().default(null),
+    contentHash: sha256Schema,
+    mediaType: z.string().trim().min(1).max(256),
+    byteLength: z.number().int().nonnegative(),
+    evidenceRefs: z.array(stableUriSchema).max(256).default([]),
+    relatedRefs: z.array(stableUriSchema).max(256).default([]),
+    supersedesRef: stableUriSchema.nullable().default(null),
+}).strict().superRefine((value, ctx) => {
+    if (value.projectRef) {
+        try {
+            const url = new URL(value.projectRef);
+            if (url.protocol !== 'knowledge-project:' || url.hostname.toLowerCase() !== value.projectKey.toLowerCase())
+                ctx.addIssue({ code: 'custom', path: ['projectRef'], message: 'projectRef project must match Artifact project' });
+        }
+        catch {
+            ctx.addIssue({ code: 'custom', path: ['projectRef'], message: 'Invalid projectRef' });
+        }
+    }
+    if (value.validUntil && value.observedAt && Date.parse(value.validUntil) < Date.parse(value.observedAt)) {
+        ctx.addIssue({ code: 'custom', path: ['validUntil'], message: 'validUntil must not precede observedAt' });
+    }
+    if (value.kind === 'SIGNAL_GENERATION' && (value.version !== 1 || value.status !== 'GENERATED')) {
+        ctx.addIssue({ code: 'custom', path: ['version'], message: 'Signal generations are immutable generated artifacts at version 1' });
+    }
+    if (['KNOWLEDGE', 'INSIGHT'].includes(value.kind) && value.status === 'GENERATED') {
+        ctx.addIssue({ code: 'custom', path: ['status'], message: 'Knowledge/Insight cannot use GENERATED status' });
+    }
+});
+export const artifactWriteMetadataSchema = z.object({
+    schemaVersion: schemaVersionSchema,
+    artifactId: artifactIdSchema,
+    kind: artifactKindSchema,
+    projectKey: projectKeySchema,
+    projectRef: stableUriSchema.optional(),
+    version: z.number().int().positive(),
+    status: artifactStatusSchema,
+    access: accessClassificationSchema.default('INTERNAL'),
+    title: z.string().trim().min(1).max(500).optional(),
+    createdAt: isoDateTimeSchema,
+    observedAt: isoDateTimeSchema.nullable().default(null),
+    validUntil: isoDateTimeSchema.nullable().default(null),
+    mediaType: z.string().trim().min(1).max(256),
+    evidenceRefs: z.array(stableUriSchema).max(256).default([]),
+    relatedRefs: z.array(stableUriSchema).max(256).default([]),
+    supersedesRef: stableUriSchema.nullable().default(null),
+}).strict().superRefine((value, ctx) => {
+    if (value.validUntil && value.observedAt && Date.parse(value.validUntil) < Date.parse(value.observedAt)) {
+        ctx.addIssue({ code: 'custom', path: ['validUntil'], message: 'validUntil must not precede observedAt' });
+    }
+    if (value.kind === 'SIGNAL_GENERATION') {
+        ctx.addIssue({ code: 'custom', path: ['kind'], message: 'Signal generations are produced only by the signal composer' });
+    }
+    if (value.kind === 'REVIEW') {
+        ctx.addIssue({ code: 'custom', path: ['kind'], message: 'Review artifacts are produced only by the review lifecycle' });
+    }
+    if (['KNOWLEDGE', 'INSIGHT'].includes(value.kind) && value.status !== 'DRAFT') {
+        ctx.addIssue({ code: 'custom', path: ['status'], message: 'Knowledge/Insight manual writes must enter as DRAFT' });
+    }
+    if (value.kind === 'RESEARCH' && value.status !== 'DRAFT') {
+        ctx.addIssue({ code: 'custom', path: ['status'], message: 'Research manual writes must enter as DRAFT' });
+    }
+});
+export const reviewDecisionSchema = z.object({
+    schemaVersion: schemaVersionSchema,
+    targetRef: stableUriSchema,
+    decision: z.enum(['PASS', 'REWORK', 'REJECT']),
+    reviewedAt: isoDateTimeSchema,
+    summary: z.string().trim().min(1).max(16000),
+    evidenceRefs: z.array(stableUriSchema).max(256).default([]),
+}).strict();

package/dist/internal/contracts/collection-control.d.ts

@@ -0,0 +1,160 @@
+import { z } from 'zod';
+export declare const knowledgeControlScopeSchema: z.ZodEnum<{
+    "knowledge.read": "knowledge.read";
+    "knowledge.collect": "knowledge.collect";
+    "knowledge.source.manage": "knowledge.source.manage";
+    "knowledge.review": "knowledge.review";
+    "knowledge.publish": "knowledge.publish";
+}>;
+export declare const collectionControlRequestIdSchema: z.ZodString;
+export declare const collectionControlCreateRequestSchema: z.ZodPipe<z.ZodObject<{
+    projectKey: z.ZodString;
+    requestId: z.ZodString;
+    sourceIds: z.ZodArray<z.ZodString>;
+}, z.core.$strict>, z.ZodTransform<{
+    sourceIds: string[];
+    projectKey: string;
+    requestId: string;
+}, {
+    projectKey: string;
+    requestId: string;
+    sourceIds: string[];
+}>>;
+export declare const collectionControlAuditSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    projectKey: z.ZodString;
+    requestId: z.ZodString;
+    batchId: z.ZodString;
+    batchRef: z.ZodString;
+    tenantId: z.ZodString;
+    clientId: z.ZodString;
+    requestedAt: z.ZodISODateTime;
+    sourceIds: z.ZodArray<z.ZodString>;
+    sourceRevisionRefs: z.ZodArray<z.ZodString>;
+    admission: z.ZodLiteral<"ACCEPTED">;
+}, z.core.$strict>;
+export declare const collectionControlStatusSchema: z.ZodEnum<{
+    PENDING: "PENDING";
+    SUCCEEDED: "SUCCEEDED";
+    PARTIAL: "PARTIAL";
+    FAILED: "FAILED";
+}>;
+export declare const collectionControlRunSummarySchema: z.ZodObject<{
+    runId: z.ZodString;
+    runtimeNodeId: z.ZodString;
+    startedAt: z.ZodISODateTime;
+    finishedAt: z.ZodISODateTime;
+    status: z.ZodEnum<{
+        SUCCEEDED: "SUCCEEDED";
+        PARTIAL: "PARTIAL";
+        FAILED: "FAILED";
+    }>;
+}, z.core.$strict>;
+export declare const collectionControlRequestProjectionSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    projectKey: z.ZodString;
+    requestId: z.ZodString;
+    batchId: z.ZodString;
+    batchRef: z.ZodString;
+    trigger: z.ZodLiteral<"MANUAL">;
+    status: z.ZodEnum<{
+        PENDING: "PENDING";
+        SUCCEEDED: "SUCCEEDED";
+        PARTIAL: "PARTIAL";
+        FAILED: "FAILED";
+    }>;
+    requestedAt: z.ZodISODateTime;
+    requestedBy: z.ZodObject<{
+        tenantId: z.ZodString;
+        clientId: z.ZodString;
+    }, z.core.$strict>;
+    sourceIds: z.ZodArray<z.ZodString>;
+    sourceRevisionRefs: z.ZodArray<z.ZodString>;
+    run: z.ZodNullable<z.ZodObject<{
+        runId: z.ZodString;
+        runtimeNodeId: z.ZodString;
+        startedAt: z.ZodISODateTime;
+        finishedAt: z.ZodISODateTime;
+        status: z.ZodEnum<{
+            SUCCEEDED: "SUCCEEDED";
+            PARTIAL: "PARTIAL";
+            FAILED: "FAILED";
+        }>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const collectionControlCreateResponseSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    inserted: z.ZodBoolean;
+    request: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<1>;
+        projectKey: z.ZodString;
+        requestId: z.ZodString;
+        batchId: z.ZodString;
+        batchRef: z.ZodString;
+        trigger: z.ZodLiteral<"MANUAL">;
+        status: z.ZodEnum<{
+            PENDING: "PENDING";
+            SUCCEEDED: "SUCCEEDED";
+            PARTIAL: "PARTIAL";
+            FAILED: "FAILED";
+        }>;
+        requestedAt: z.ZodISODateTime;
+        requestedBy: z.ZodObject<{
+            tenantId: z.ZodString;
+            clientId: z.ZodString;
+        }, z.core.$strict>;
+        sourceIds: z.ZodArray<z.ZodString>;
+        sourceRevisionRefs: z.ZodArray<z.ZodString>;
+        run: z.ZodNullable<z.ZodObject<{
+            runId: z.ZodString;
+            runtimeNodeId: z.ZodString;
+            startedAt: z.ZodISODateTime;
+            finishedAt: z.ZodISODateTime;
+            status: z.ZodEnum<{
+                SUCCEEDED: "SUCCEEDED";
+                PARTIAL: "PARTIAL";
+                FAILED: "FAILED";
+            }>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const collectionControlGetResponseSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    request: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<1>;
+        projectKey: z.ZodString;
+        requestId: z.ZodString;
+        batchId: z.ZodString;
+        batchRef: z.ZodString;
+        trigger: z.ZodLiteral<"MANUAL">;
+        status: z.ZodEnum<{
+            PENDING: "PENDING";
+            SUCCEEDED: "SUCCEEDED";
+            PARTIAL: "PARTIAL";
+            FAILED: "FAILED";
+        }>;
+        requestedAt: z.ZodISODateTime;
+        requestedBy: z.ZodObject<{
+            tenantId: z.ZodString;
+            clientId: z.ZodString;
+        }, z.core.$strict>;
+        sourceIds: z.ZodArray<z.ZodString>;
+        sourceRevisionRefs: z.ZodArray<z.ZodString>;
+        run: z.ZodNullable<z.ZodObject<{
+            runId: z.ZodString;
+            runtimeNodeId: z.ZodString;
+            startedAt: z.ZodISODateTime;
+            finishedAt: z.ZodISODateTime;
+            status: z.ZodEnum<{
+                SUCCEEDED: "SUCCEEDED";
+                PARTIAL: "PARTIAL";
+                FAILED: "FAILED";
+            }>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type KnowledgeControlScope = z.infer<typeof knowledgeControlScopeSchema>;
+export type CollectionControlCreateRequest = z.infer<typeof collectionControlCreateRequestSchema>;
+export type CollectionControlAudit = z.infer<typeof collectionControlAuditSchema>;
+export type CollectionControlStatus = z.infer<typeof collectionControlStatusSchema>;
+export type CollectionControlRequestProjection = z.infer<typeof collectionControlRequestProjectionSchema>;

package/dist/internal/contracts/collection-control.js

@@ -0,0 +1,69 @@
+import { z } from 'zod';
+import { idSchema, isoDateTimeSchema, projectKeySchema, schemaVersionSchema, stableUriSchema } from './common.js';
+export const knowledgeControlScopeSchema = z.enum([
+    'knowledge.read',
+    'knowledge.collect',
+    'knowledge.source.manage',
+    'knowledge.review',
+    'knowledge.publish',
+]);
+export const collectionControlRequestIdSchema = idSchema.regex(/^[A-Za-z0-9][A-Za-z0-9._-]{0,255}$/);
+export const collectionControlCreateRequestSchema = z.object({
+    projectKey: projectKeySchema,
+    requestId: collectionControlRequestIdSchema,
+    sourceIds: z.array(idSchema).min(1).max(1_000),
+}).strict().transform((value) => ({
+    ...value,
+    sourceIds: [...new Set(value.sourceIds)].sort(),
+}));
+export const collectionControlAuditSchema = z.object({
+    schemaVersion: schemaVersionSchema,
+    projectKey: projectKeySchema,
+    requestId: collectionControlRequestIdSchema,
+    batchId: idSchema,
+    batchRef: stableUriSchema,
+    tenantId: idSchema,
+    clientId: idSchema,
+    requestedAt: isoDateTimeSchema,
+    sourceIds: z.array(idSchema).min(1).max(1_000),
+    sourceRevisionRefs: z.array(stableUriSchema).min(1).max(1_000),
+    admission: z.literal('ACCEPTED'),
+}).strict().superRefine((value, ctx) => {
+    if (value.sourceIds.length !== value.sourceRevisionRefs.length)
+        ctx.addIssue({
+            code: 'custom',
+            path: ['sourceRevisionRefs'],
+            message: 'sourceRevisionRefs must align with sourceIds',
+        });
+});
+export const collectionControlStatusSchema = z.enum(['PENDING', 'SUCCEEDED', 'PARTIAL', 'FAILED']);
+export const collectionControlRunSummarySchema = z.object({
+    runId: idSchema,
+    runtimeNodeId: idSchema,
+    startedAt: isoDateTimeSchema,
+    finishedAt: isoDateTimeSchema,
+    status: z.enum(['SUCCEEDED', 'PARTIAL', 'FAILED']),
+}).strict();
+export const collectionControlRequestProjectionSchema = z.object({
+    schemaVersion: schemaVersionSchema,
+    projectKey: projectKeySchema,
+    requestId: collectionControlRequestIdSchema,
+    batchId: idSchema,
+    batchRef: stableUriSchema,
+    trigger: z.literal('MANUAL'),
+    status: collectionControlStatusSchema,
+    requestedAt: isoDateTimeSchema,
+    requestedBy: z.object({ tenantId: idSchema, clientId: idSchema }).strict(),
+    sourceIds: z.array(idSchema).min(1).max(1_000),
+    sourceRevisionRefs: z.array(stableUriSchema).min(1).max(1_000),
+    run: collectionControlRunSummarySchema.nullable(),
+}).strict();
+export const collectionControlCreateResponseSchema = z.object({
+    schemaVersion: schemaVersionSchema,
+    inserted: z.boolean(),
+    request: collectionControlRequestProjectionSchema,
+}).strict();
+export const collectionControlGetResponseSchema = z.object({
+    schemaVersion: schemaVersionSchema,
+    request: collectionControlRequestProjectionSchema,
+}).strict();

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

@@ -0,0 +1,263 @@
+import { z } from 'zod';
+export declare const collectionBatchSourceBindingSchema: z.ZodObject<{
+    sourceId: z.ZodString;
+    sourceRef: z.ZodString;
+    sourceRevisionRef: z.ZodString;
+    targetId: z.ZodString;
+}, z.core.$strict>;
+/** The collector-facing task deliberately contains no project/source-family semantics. */
+export declare const collectionTaskSchema: z.ZodObject<{
+    taskId: z.ZodString;
+    targetId: z.ZodString;
+    target: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"URL">;
+        locator: z.ZodURL;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"FILE">;
+        rootBinding: z.ZodString;
+        relativePath: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"EXECUTOR">;
+        executorId: z.ZodString;
+        bindingRef: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        parameters: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>]>>>;
+    }, z.core.$strict>], "kind">;
+}, z.core.$strict>;
+export declare const collectionBatchTriggerSchema: z.ZodEnum<{
+    MANUAL: "MANUAL";
+    DUE: "DUE";
+}>;
+export declare const collectionBatchSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    projectKey: z.ZodString;
+    projectRef: z.ZodString;
+    projectIntentRef: z.ZodString;
+    requestId: z.ZodString;
+    batchId: z.ZodString;
+    batchRef: z.ZodString;
+    trigger: z.ZodDefault<z.ZodEnum<{
+        MANUAL: "MANUAL";
+        DUE: "DUE";
+    }>>;
+    createdAt: z.ZodISODateTime;
+    sourceBindings: z.ZodArray<z.ZodObject<{
+        sourceId: z.ZodString;
+        sourceRef: z.ZodString;
+        sourceRevisionRef: z.ZodString;
+        targetId: z.ZodString;
+    }, z.core.$strict>>;
+    tasks: z.ZodArray<z.ZodObject<{
+        taskId: z.ZodString;
+        targetId: z.ZodString;
+        target: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"URL">;
+            locator: z.ZodURL;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"FILE">;
+            rootBinding: z.ZodString;
+            relativePath: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"EXECUTOR">;
+            executorId: z.ZodString;
+            bindingRef: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            parameters: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>]>>>;
+        }, z.core.$strict>], "kind">;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const collectorBatchViewSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    batchId: z.ZodString;
+    tasks: z.ZodArray<z.ZodObject<{
+        taskId: z.ZodString;
+        targetId: z.ZodString;
+        target: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"URL">;
+            locator: z.ZodURL;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"FILE">;
+            rootBinding: z.ZodString;
+            relativePath: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"EXECUTOR">;
+            executorId: z.ZodString;
+            bindingRef: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            parameters: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>]>>>;
+        }, z.core.$strict>], "kind">;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const sourceCollectionDueReasonSchema: z.ZodEnum<{
+    MANUAL: "MANUAL";
+    DISABLED: "DISABLED";
+    PENDING_BATCH: "PENDING_BATCH";
+    SPECIALIZED_EXECUTOR: "SPECIALIZED_EXECUTOR";
+    SPECIALIZED_COLLECTOR: "SPECIALIZED_COLLECTOR";
+    NEVER_ATTEMPTED: "NEVER_ATTEMPTED";
+    INTERVAL_WAIT: "INTERVAL_WAIT";
+    INTERVAL_ELAPSED: "INTERVAL_ELAPSED";
+}>;
+export declare const sourceCollectionDueEntrySchema: z.ZodObject<{
+    sourceId: z.ZodString;
+    sourceRef: z.ZodString;
+    sourceRevisionRef: z.ZodString;
+    enabled: z.ZodBoolean;
+    refresh: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        mode: z.ZodLiteral<"MANUAL">;
+    }, z.core.$strict>, z.ZodObject<{
+        mode: z.ZodLiteral<"INTERVAL">;
+        intervalSeconds: z.ZodNumber;
+    }, z.core.$strict>], "mode">;
+    lastAttemptAt: z.ZodNullable<z.ZodISODateTime>;
+    lastState: z.ZodNullable<z.ZodEnum<{
+        ACCESS_CONTROLLED: "ACCESS_CONTROLLED";
+        FAILED: "FAILED";
+        ACQUIRED: "ACQUIRED";
+        HTTP_TERMINAL: "HTTP_TERMINAL";
+    }>>;
+    lastBatchRef: z.ZodNullable<z.ZodString>;
+    lastRunId: z.ZodNullable<z.ZodString>;
+    pendingBatchRef: z.ZodNullable<z.ZodString>;
+    nextDueAt: z.ZodNullable<z.ZodISODateTime>;
+    due: z.ZodBoolean;
+    reason: z.ZodEnum<{
+        MANUAL: "MANUAL";
+        DISABLED: "DISABLED";
+        PENDING_BATCH: "PENDING_BATCH";
+        SPECIALIZED_EXECUTOR: "SPECIALIZED_EXECUTOR";
+        SPECIALIZED_COLLECTOR: "SPECIALIZED_COLLECTOR";
+        NEVER_ATTEMPTED: "NEVER_ATTEMPTED";
+        INTERVAL_WAIT: "INTERVAL_WAIT";
+        INTERVAL_ELAPSED: "INTERVAL_ELAPSED";
+    }>;
+}, z.core.$strict>;
+export declare const projectCollectionDuePlanSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    projectKey: z.ZodString;
+    projectRef: z.ZodString;
+    projectIntentRef: z.ZodString;
+    assessedAt: z.ZodISODateTime;
+    sourceCount: z.ZodNumber;
+    dueSourceCount: z.ZodNumber;
+    dueSourceIds: z.ZodArray<z.ZodString>;
+    sources: z.ZodArray<z.ZodObject<{
+        sourceId: z.ZodString;
+        sourceRef: z.ZodString;
+        sourceRevisionRef: z.ZodString;
+        enabled: z.ZodBoolean;
+        refresh: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            mode: z.ZodLiteral<"MANUAL">;
+        }, z.core.$strict>, z.ZodObject<{
+            mode: z.ZodLiteral<"INTERVAL">;
+            intervalSeconds: z.ZodNumber;
+        }, z.core.$strict>], "mode">;
+        lastAttemptAt: z.ZodNullable<z.ZodISODateTime>;
+        lastState: z.ZodNullable<z.ZodEnum<{
+            ACCESS_CONTROLLED: "ACCESS_CONTROLLED";
+            FAILED: "FAILED";
+            ACQUIRED: "ACQUIRED";
+            HTTP_TERMINAL: "HTTP_TERMINAL";
+        }>>;
+        lastBatchRef: z.ZodNullable<z.ZodString>;
+        lastRunId: z.ZodNullable<z.ZodString>;
+        pendingBatchRef: z.ZodNullable<z.ZodString>;
+        nextDueAt: z.ZodNullable<z.ZodISODateTime>;
+        due: z.ZodBoolean;
+        reason: z.ZodEnum<{
+            MANUAL: "MANUAL";
+            DISABLED: "DISABLED";
+            PENDING_BATCH: "PENDING_BATCH";
+            SPECIALIZED_EXECUTOR: "SPECIALIZED_EXECUTOR";
+            SPECIALIZED_COLLECTOR: "SPECIALIZED_COLLECTOR";
+            NEVER_ATTEMPTED: "NEVER_ATTEMPTED";
+            INTERVAL_WAIT: "INTERVAL_WAIT";
+            INTERVAL_ELAPSED: "INTERVAL_ELAPSED";
+        }>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const collectionTaskRunResultSchema: z.ZodObject<{
+    taskId: z.ZodString;
+    targetId: z.ZodString;
+    sourceId: z.ZodString;
+    sourceRevisionRef: z.ZodString;
+    observedAt: z.ZodISODateTime;
+    state: z.ZodEnum<{
+        ACCESS_CONTROLLED: "ACCESS_CONTROLLED";
+        FAILED: "FAILED";
+        ACQUIRED: "ACQUIRED";
+        HTTP_TERMINAL: "HTTP_TERMINAL";
+    }>;
+    finalLocator: z.ZodNullable<z.ZodString>;
+    httpStatus: z.ZodNullable<z.ZodNumber>;
+    evidenceRef: z.ZodNullable<z.ZodString>;
+    contentHash: z.ZodNullable<z.ZodString>;
+    byteLength: z.ZodNullable<z.ZodNumber>;
+    mediaType: z.ZodNullable<z.ZodString>;
+    reusedEvidence: z.ZodBoolean;
+    relatedEvidenceRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    richDocumentRef: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    projectionJobId: z.ZodOptional<z.ZodString>;
+    projectionState: z.ZodOptional<z.ZodEnum<{
+        PENDING: "PENDING";
+        SUCCEEDED: "SUCCEEDED";
+        PARTIAL: "PARTIAL";
+        FAILED: "FAILED";
+        NOT_REQUIRED: "NOT_REQUIRED";
+    }>>;
+    errorCode: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export declare const collectionRunReceiptSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    projectKey: z.ZodString;
+    projectRef: z.ZodString;
+    batchId: z.ZodString;
+    batchRef: z.ZodString;
+    runId: z.ZodString;
+    runtimeNodeId: z.ZodString;
+    startedAt: z.ZodISODateTime;
+    finishedAt: z.ZodISODateTime;
+    status: z.ZodEnum<{
+        SUCCEEDED: "SUCCEEDED";
+        PARTIAL: "PARTIAL";
+        FAILED: "FAILED";
+    }>;
+    results: z.ZodArray<z.ZodObject<{
+        taskId: z.ZodString;
+        targetId: z.ZodString;
+        sourceId: z.ZodString;
+        sourceRevisionRef: z.ZodString;
+        observedAt: z.ZodISODateTime;
+        state: z.ZodEnum<{
+            ACCESS_CONTROLLED: "ACCESS_CONTROLLED";
+            FAILED: "FAILED";
+            ACQUIRED: "ACQUIRED";
+            HTTP_TERMINAL: "HTTP_TERMINAL";
+        }>;
+        finalLocator: z.ZodNullable<z.ZodString>;
+        httpStatus: z.ZodNullable<z.ZodNumber>;
+        evidenceRef: z.ZodNullable<z.ZodString>;
+        contentHash: z.ZodNullable<z.ZodString>;
+        byteLength: z.ZodNullable<z.ZodNumber>;
+        mediaType: z.ZodNullable<z.ZodString>;
+        reusedEvidence: z.ZodBoolean;
+        relatedEvidenceRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        richDocumentRef: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        projectionJobId: z.ZodOptional<z.ZodString>;
+        projectionState: z.ZodOptional<z.ZodEnum<{
+            PENDING: "PENDING";
+            SUCCEEDED: "SUCCEEDED";
+            PARTIAL: "PARTIAL";
+            FAILED: "FAILED";
+            NOT_REQUIRED: "NOT_REQUIRED";
+        }>>;
+        errorCode: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type SourceCollectionDueReason = z.infer<typeof sourceCollectionDueReasonSchema>;
+export type SourceCollectionDueEntry = z.infer<typeof sourceCollectionDueEntrySchema>;
+export type ProjectCollectionDuePlan = z.infer<typeof projectCollectionDuePlanSchema>;
+export type CollectionBatchTrigger = z.infer<typeof collectionBatchTriggerSchema>;
+export type CollectionBatchSourceBinding = z.infer<typeof collectionBatchSourceBindingSchema>;
+export type CollectionTask = z.infer<typeof collectionTaskSchema>;
+export type CollectionBatch = z.infer<typeof collectionBatchSchema>;
+export type CollectorBatchView = z.infer<typeof collectorBatchViewSchema>;
+export type CollectionTaskRunResult = z.infer<typeof collectionTaskRunResultSchema>;
+export type CollectionRunReceipt = z.infer<typeof collectionRunReceiptSchema>;