@disclosureos/schema 1.1.0 → 2.0.0-beta.0

package/dist/experimental/v2/index.d.ts

@@ -0,0 +1,1602 @@
+import { ClaimHistoryIssueCode, parseExperimentalClaimHistory, ClaimSubject } from '@disclosureos/records/experimental/v2';
+import { z } from 'zod';
+import { parseAcquisitionContext, AcquisitionContextIssueCode } from '@disclosureos/instruments/experimental/v2';
+
+declare const ASSESSMENT_DOCUMENTATION_PROFILE: Readonly<{
+    readonly id: "urn:disclosureos:experimental:profile:assessment-documentation";
+    readonly version: "0.1.0";
+    readonly scope: "documentary_only";
+}>;
+type Status$b = 'passed' | 'failed' | 'not_checked';
+type DocumentationIssueCode = ClaimHistoryIssueCode | 'PROFILE.NO_ASSESSMENTS' | 'PROFILE.UNASSESSED' | 'PROFILE.INPUTS_REQUIRED' | 'PROFILE.METHOD_CONTEXT' | 'PROFILE.LOCATOR_REQUIRED' | 'PROFILE.DIGEST_REQUIRED' | 'PROFILE.MEASUREMENT_REQUIRED' | 'PROFILE.MEASUREMENT_UNCERTAINTY' | 'PROFILE.INSTRUMENT_PRODUCT_REQUIRED' | 'PROFILE.EVENT_TIME' | 'PROFILE.FRAME_CONTEXT' | 'EXTERNAL.ASSET_UNAVAILABLE' | 'EXTERNAL.DIGEST_MISMATCH' | 'EXTERNAL.HASH_UNAVAILABLE' | 'EXTERNAL.EMPTY_ASSET';
+interface DocumentationIssue {
+    code: DocumentationIssueCode;
+    stage: 'structural' | 'semantic' | 'profile' | 'external';
+    severity: 'error' | 'warning';
+    pointer: string;
+    message: string;
+}
+interface AssetCheck {
+    ref: string;
+    status: Status$b;
+    expectedSha256?: string;
+    actualSha256?: string;
+}
+interface AssessmentDocumentation {
+    claimRef: string;
+    status: Status$b;
+    inputRefs: string[];
+    sourceRefs: string[];
+    productRefs: string[];
+    measurementRefs: string[];
+    assets: AssetCheck[];
+    issues: DocumentationIssue[];
+}
+interface DocumentationOptions {
+    /** Exact complete bytes keyed by source:/product: reference. No URLs are fetched. */
+    assets?: ReadonlyMap<string, Uint8Array>;
+}
+interface DocumentationResult {
+    success: boolean;
+    profile: typeof ASSESSMENT_DOCUMENTATION_PROFILE;
+    contract: ReturnType<typeof parseExperimentalClaimHistory>['contract'];
+    checks: {
+        structural: Status$b;
+        semantic: Status$b;
+        profile: Status$b;
+        external: Status$b;
+    };
+    scientific: 'not_checked';
+    locatorContents: 'not_checked';
+    methodExecution: 'not_checked';
+    assessments: AssessmentDocumentation[];
+    issues: DocumentationIssue[];
+}
+/** Documentary preflight plus local byte integrity, not scientific or locator-content verification. */
+declare function evaluateAssessmentDocumentation(input: unknown, options?: DocumentationOptions): Promise<DocumentationResult>;
+
+declare const ACQUISITION_BINDINGS_SCHEMA_ID = "urn:disclosureos:experimental:acquisition-bindings:0.1.0";
+declare const AcquisitionBindingsSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"acquisition_bindings">;
+    schemaVersion: z.ZodLiteral<"0.1.0">;
+    id: z.ZodString;
+    historyId: z.ZodString;
+    observationId: z.ZodString;
+    contextId: z.ZodString;
+    sources: z.ZodArray<z.ZodObject<{
+        sourceRef: z.ZodString;
+        instrumentRef: z.ZodString;
+    }, z.core.$strict>>;
+    products: z.ZodArray<z.ZodObject<{
+        observationProductRef: z.ZodString;
+        contextProductRef: z.ZodString;
+    }, z.core.$strict>>;
+    extensions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+}, z.core.$strict>;
+type AcquisitionBindings = z.infer<typeof AcquisitionBindingsSchema>;
+declare function acquisitionBindingsJsonSchema(): Record<string, unknown>;
+
+declare const ACQUISITION_BINDINGS_PROFILE: Readonly<{
+    readonly id: "urn:disclosureos:experimental:profile:acquisition-bindings";
+    readonly version: "0.1.0";
+    readonly scope: "product_identity_and_declared_context";
+}>;
+type Status$a = 'passed' | 'failed' | 'not_checked';
+type BindingIssueCode = ClaimHistoryIssueCode | AcquisitionContextIssueCode | 'BINDING.DOCUMENT_ID' | 'BINDING.SOURCE_KIND' | 'BINDING.RAW_REQUIRED' | 'BINDING.DIGEST_MISMATCH' | 'BINDING.FORMAT_MISMATCH' | 'BINDING.SOURCE_IDENTITY' | 'BINDING.PRODUCT_REQUIRED' | 'BINDING.SOURCE_REQUIRED' | 'BINDING.DIGEST_REQUIRED' | 'BINDING.CONTEXT_INCOMPLETE' | 'BINDING.NO_INSTRUMENT_PRODUCTS' | 'EXTERNAL.ASSET_UNAVAILABLE' | 'EXTERNAL.DIGEST_MISMATCH' | 'EXTERNAL.SIZE_MISMATCH' | 'EXTERNAL.HASH_UNAVAILABLE' | 'EXTERNAL.EMPTY_ASSET';
+interface BindingIssue {
+    code: BindingIssueCode;
+    stage: 'structural' | 'semantic' | 'profile' | 'external';
+    severity: 'error' | 'warning';
+    pointer: string;
+    message: string;
+}
+interface BindingAssetCheck {
+    ref: string;
+    status: Status$a;
+    pointer: string;
+    expectedSha256: string;
+    expectedByteLength: number;
+    actualSha256?: string;
+    actualByteLength?: number;
+}
+interface ProductBindingCheck {
+    observationProductRef: string;
+    contextProductRef: string;
+    acquisitionRef: string;
+    instrumentRef: string;
+    assetRefs: string[];
+    status: Status$a;
+    issues: BindingIssue[];
+}
+interface AcquisitionBindingOptions {
+    /** Context-scoped keys: product:ID, manifest:ID, calibration:ID/report, calibration:ID/review. */
+    assets?: ReadonlyMap<string, Uint8Array>;
+}
+interface AcquisitionBindingResult {
+    success: boolean;
+    profile: typeof ACQUISITION_BINDINGS_PROFILE;
+    contracts: {
+        history: ReturnType<typeof parseExperimentalClaimHistory>['contract'];
+        context: ReturnType<typeof parseAcquisitionContext>['contract'];
+        bindings: {
+            schemaId: typeof ACQUISITION_BINDINGS_SCHEMA_ID;
+            rulesetVersion: '0.1.0';
+        };
+    };
+    checks: {
+        structural: Status$a;
+        semantic: Status$a;
+        profile: Status$a;
+        external: Status$a;
+    };
+    scientific: 'not_checked';
+    identityAuthenticity: 'not_checked';
+    artifactContents: 'not_checked';
+    bindings: ProductBindingCheck[];
+    assets: BindingAssetCheck[];
+    issues: BindingIssue[];
+}
+/** Explicit cross-document links and local byte identity. Does not authenticate an instrument or calibrate a measurement. */
+declare function evaluateAcquisitionBindings(historyInput: unknown, contextInput: unknown, bindingsInput: unknown, options?: AcquisitionBindingOptions): Promise<AcquisitionBindingResult>;
+
+declare const MEASUREMENT_BINDINGS_SCHEMA_ID = "urn:disclosureos:experimental:measurement-bindings:0.1.0";
+declare const MEASUREMENT_BINDINGS_PROFILE: Readonly<{
+    readonly id: "urn:disclosureos:experimental:profile:measurement-bindings";
+    readonly version: "0.1.0";
+    readonly scope: "single_channel_declared_capture";
+}>;
+declare const MeasurementBindingsSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"measurement_bindings">;
+    schemaVersion: z.ZodLiteral<"0.1.0">;
+    id: z.ZodString;
+    historyId: z.ZodString;
+    observationId: z.ZodString;
+    contextId: z.ZodString;
+    acquisitionBindingsId: z.ZodString;
+    measurements: z.ZodArray<z.ZodObject<{
+        measurementRef: z.ZodString;
+        observationProductRef: z.ZodString;
+        channelId: z.ZodString;
+        time: z.ZodUnion<readonly [z.ZodObject<{
+            state: z.ZodLiteral<"unknown">;
+            reason: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            state: z.ZodLiteral<"known">;
+            kind: z.ZodLiteral<"instant">;
+            value: z.ZodString;
+            timeScale: z.ZodLiteral<"UTC">;
+        }, z.core.$strict>, z.ZodObject<{
+            state: z.ZodLiteral<"known">;
+            kind: z.ZodLiteral<"interval">;
+            start: z.ZodString;
+            end: z.ZodString;
+            timeScale: z.ZodLiteral<"UTC">;
+        }, z.core.$strict>]>;
+    }, z.core.$strict>>;
+    extensions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+}, z.core.$strict>;
+type MeasurementBindings = z.infer<typeof MeasurementBindingsSchema>;
+declare function measurementBindingsJsonSchema(): Record<string, unknown>;
+type Status$9 = "passed" | "failed" | "not_checked";
+interface MeasurementBindingIssue {
+    code: string;
+    stage: "structural" | "semantic" | "profile" | "external";
+    severity: "error" | "warning";
+    pointer: string;
+    message: string;
+}
+interface MeasurementBindingResult {
+    success: boolean;
+    profile: typeof MEASUREMENT_BINDINGS_PROFILE;
+    contract: {
+        schemaId: typeof MEASUREMENT_BINDINGS_SCHEMA_ID;
+        rulesetVersion: "0.1.0";
+    };
+    checks: {
+        structural: Status$9;
+        semantic: Status$9;
+        profile: Status$9;
+        external: Status$9;
+    };
+    issues: MeasurementBindingIssue[];
+    acquisition: AcquisitionBindingResult | null;
+    scientific: "not_checked";
+    clockUncertainty: "not_checked";
+    artifactContents: "not_checked";
+}
+/** Checks declared single-channel support and nominal capture containment, then verifies local acquisition bytes. */
+declare function evaluateMeasurementBindings(historyInput: unknown, contextInput: unknown, acquisitionBindingsInput: unknown, measurementBindingsInput: unknown, options?: AcquisitionBindingOptions): Promise<MeasurementBindingResult>;
+
+declare const INSTRUMENT_RESEARCH_REVIEW_SCHEMA_ID = "urn:disclosureos:experimental:instrument-research-review:0.1.0";
+declare const INSTRUMENT_RESEARCH_PREREQUISITES_PROFILE: Readonly<{
+    readonly id: "urn:disclosureos:experimental:profile:instrument-research-prerequisites";
+    readonly version: "0.1.0";
+    readonly scope: "reviewed_declared_inputs";
+}>;
+declare const InstrumentResearchReviewSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"instrument_research_review">;
+    schemaVersion: z.ZodLiteral<"0.1.0">;
+    id: z.ZodString;
+    historyId: z.ZodString;
+    observationId: z.ZodString;
+    contextId: z.ZodString;
+    acquisitionBindingsId: z.ZodString;
+    measurementBindingsId: z.ZodString;
+    purpose: z.ZodObject<{
+        id: z.ZodString;
+        version: z.ZodString;
+        description: z.ZodString;
+    }, z.core.$strict>;
+    measurements: z.ZodArray<z.ZodObject<{
+        measurementRef: z.ZodString;
+        calibrationRef: z.ZodString;
+        calibrationUse: z.ZodUnion<readonly [z.ZodObject<{
+            state: z.ZodLiteral<"unreviewed">;
+        }, z.core.$strict>, z.ZodObject<{
+            state: z.ZodLiteral<"reviewed">;
+            reviewedBy: z.ZodString;
+            reviewedAt: z.ZodString;
+            outcome: z.ZodEnum<{
+                inconclusive: "inconclusive";
+                accepted: "accepted";
+                rejected: "rejected";
+            }>;
+            rationale: z.ZodString;
+            method: z.ZodObject<{
+                id: z.ZodString;
+                version: z.ZodString;
+                description: z.ZodString;
+            }, z.core.$strict>;
+            report: z.ZodObject<{
+                digest: z.ZodObject<{
+                    algorithm: z.ZodLiteral<"sha256">;
+                    value: z.ZodString;
+                }, z.core.$strict>;
+                mediaType: z.ZodString;
+                byteLength: z.ZodNumber;
+            }, z.core.$strict>;
+        }, z.core.$strict>]>;
+        timing: z.ZodUnion<readonly [z.ZodObject<{
+            kind: z.ZodLiteral<"unknown">;
+            reason: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            lower: z.ZodString;
+            upper: z.ZodString;
+            timeScale: z.ZodLiteral<"UTC">;
+            assumptions: z.ZodArray<z.ZodString>;
+            review: z.ZodUnion<readonly [z.ZodObject<{
+                state: z.ZodLiteral<"unreviewed">;
+            }, z.core.$strict>, z.ZodObject<{
+                state: z.ZodLiteral<"reviewed">;
+                reviewedBy: z.ZodString;
+                reviewedAt: z.ZodString;
+                outcome: z.ZodEnum<{
+                    inconclusive: "inconclusive";
+                    accepted: "accepted";
+                    rejected: "rejected";
+                }>;
+                rationale: z.ZodString;
+                method: z.ZodObject<{
+                    id: z.ZodString;
+                    version: z.ZodString;
+                    description: z.ZodString;
+                }, z.core.$strict>;
+                report: z.ZodObject<{
+                    digest: z.ZodObject<{
+                        algorithm: z.ZodLiteral<"sha256">;
+                        value: z.ZodString;
+                    }, z.core.$strict>;
+                    mediaType: z.ZodString;
+                    byteLength: z.ZodNumber;
+                }, z.core.$strict>;
+            }, z.core.$strict>]>;
+            kind: z.ZodLiteral<"bound">;
+        }, z.core.$strict>, z.ZodObject<{
+            coverageProbability: z.ZodNumber;
+            lower: z.ZodString;
+            upper: z.ZodString;
+            timeScale: z.ZodLiteral<"UTC">;
+            assumptions: z.ZodArray<z.ZodString>;
+            review: z.ZodUnion<readonly [z.ZodObject<{
+                state: z.ZodLiteral<"unreviewed">;
+            }, z.core.$strict>, z.ZodObject<{
+                state: z.ZodLiteral<"reviewed">;
+                reviewedBy: z.ZodString;
+                reviewedAt: z.ZodString;
+                outcome: z.ZodEnum<{
+                    inconclusive: "inconclusive";
+                    accepted: "accepted";
+                    rejected: "rejected";
+                }>;
+                rationale: z.ZodString;
+                method: z.ZodObject<{
+                    id: z.ZodString;
+                    version: z.ZodString;
+                    description: z.ZodString;
+                }, z.core.$strict>;
+                report: z.ZodObject<{
+                    digest: z.ZodObject<{
+                        algorithm: z.ZodLiteral<"sha256">;
+                        value: z.ZodString;
+                    }, z.core.$strict>;
+                    mediaType: z.ZodString;
+                    byteLength: z.ZodNumber;
+                }, z.core.$strict>;
+            }, z.core.$strict>]>;
+            kind: z.ZodLiteral<"coverage_interval">;
+        }, z.core.$strict>]>;
+    }, z.core.$strict>>;
+    extensions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+}, z.core.$strict>;
+type InstrumentResearchReview = z.infer<typeof InstrumentResearchReviewSchema>;
+declare function instrumentResearchReviewJsonSchema(): Record<string, unknown>;
+type Status$8 = "passed" | "failed" | "not_checked";
+interface InstrumentResearchOptions {
+    observationAssets?: ReadonlyMap<string, Uint8Array>;
+    contextAssets?: ReadonlyMap<string, Uint8Array>;
+    /** Separate namespace: measurement:ID/calibration-use and measurement:ID/timing. */
+    reviewAssets?: ReadonlyMap<string, Uint8Array>;
+}
+interface ResearchReviewAssetCheck {
+    ref: string;
+    status: Status$8;
+    expectedSha256: string;
+    expectedByteLength: number;
+    actualSha256?: string;
+    actualByteLength?: number;
+}
+interface InstrumentResearchResult {
+    success: boolean;
+    profile: typeof INSTRUMENT_RESEARCH_PREREQUISITES_PROFILE;
+    contract: {
+        schemaId: typeof INSTRUMENT_RESEARCH_REVIEW_SCHEMA_ID;
+        rulesetVersion: "0.1.0";
+    };
+    checks: {
+        structural: Status$8;
+        semantic: Status$8;
+        profile: Status$8;
+        external: Status$8;
+    };
+    review: {
+        id: string;
+        purpose: InstrumentResearchReview["purpose"];
+    } | null;
+    issues: MeasurementBindingIssue[];
+    documentation: DocumentationResult | null;
+    measurements: MeasurementBindingResult | null;
+    reviewAssets: ResearchReviewAssetCheck[];
+    scientificEligibility: "not_checked";
+    calibrationAdequacy: "not_checked";
+    timingModel: "not_checked";
+    reviewerAuthenticity: "not_checked";
+}
+/** Assesses documented prerequisites, not scientific validity or reviewer competence. */
+declare function evaluateInstrumentResearchPrerequisites(historyInput: unknown, contextInput: unknown, acquisitionBindingsInput: unknown, measurementBindingsInput: unknown, reviewInput: unknown, options?: InstrumentResearchOptions): Promise<InstrumentResearchResult>;
+
+declare const REPRODUCTION_PACKET_SCHEMA_ID = "urn:disclosureos:experimental:reproduction-packet:0.1.0";
+declare const REPRODUCTION_PACKET_PROFILE: Readonly<{
+    readonly id: "urn:disclosureos:experimental:profile:reproduction-packet";
+    readonly version: "0.1.0";
+    readonly scope: "exact_bytes_and_research_prerequisites";
+}>;
+declare const ReproductionPacketSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"reproduction_packet">;
+    schemaVersion: z.ZodLiteral<"0.1.0">;
+    id: z.ZodString;
+    researchProfile: z.ZodLiteral<"urn:disclosureos:experimental:profile:instrument-research-prerequisites:0.1.0">;
+    files: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        sha256: z.ZodString;
+        byteLength: z.ZodNumber;
+    }, z.core.$strict>>;
+    documents: z.ZodObject<{
+        history: z.ZodString;
+        context: z.ZodString;
+        acquisitionBindings: z.ZodString;
+        measurementBindings: z.ZodString;
+        review: z.ZodString;
+    }, z.core.$strict>;
+    assets: z.ZodObject<{
+        observation: z.ZodArray<z.ZodObject<{
+            ref: z.ZodString;
+            fileRef: z.ZodString;
+        }, z.core.$strict>>;
+        context: z.ZodArray<z.ZodObject<{
+            ref: z.ZodString;
+            fileRef: z.ZodString;
+        }, z.core.$strict>>;
+        review: z.ZodArray<z.ZodObject<{
+            ref: z.ZodString;
+            fileRef: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    method: z.ZodObject<{
+        id: z.ZodString;
+        version: z.ZodString;
+        description: z.ZodString;
+        inputRef: z.ZodString;
+        expectedOutputRef: z.ZodString;
+        measurementRef: z.ZodString;
+        unit: z.ZodString;
+        absoluteTolerance: z.ZodNumber;
+        implementations: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            artifactRef: z.ZodString;
+            environmentRef: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+type ReproductionPacket = z.infer<typeof ReproductionPacketSchema>;
+declare function reproductionPacketJsonSchema(): Record<string, unknown>;
+type Status$7 = "passed" | "failed" | "not_checked";
+interface ReproductionFileCheck {
+    id: string;
+    status: Status$7;
+    expectedSha256: string;
+    expectedByteLength: number;
+    actualSha256?: string;
+    actualByteLength?: number;
+}
+interface ReproductionPacketResult {
+    success: boolean;
+    profile: typeof REPRODUCTION_PACKET_PROFILE;
+    contract: {
+        schemaId: typeof REPRODUCTION_PACKET_SCHEMA_ID;
+        rulesetVersion: "0.1.0";
+    };
+    checks: {
+        structural: Status$7;
+        semantic: Status$7;
+        profile: Status$7;
+        external: Status$7;
+    };
+    packetId?: string;
+    method?: ReproductionPacket["method"];
+    files: ReproductionFileCheck[];
+    issues: {
+        code: string;
+        pointer: string;
+        message: string;
+    }[];
+    research: InstrumentResearchResult | null;
+    methodExecution: "not_checked";
+    environmentExecution: "not_checked";
+    scientificEligibility: "not_checked";
+}
+/** Pins exact supplied bytes and composes research prerequisites. Never fetches files or executes bundled code. */
+declare function evaluateReproductionPacket(input: unknown, options?: {
+    files?: ReadonlyMap<string, Uint8Array>;
+}): Promise<ReproductionPacketResult>;
+
+declare const DATASET_RELEASE_SCHEMA_ID = "urn:disclosureos:experimental:dataset-release:0.1.0";
+declare const DATASET_RELEASE_PROFILE: Readonly<{
+    readonly id: "urn:disclosureos:experimental:profile:dataset-release";
+    readonly version: "0.1.0";
+    readonly scope: "pinned_packets_and_nominal_session_membership";
+}>;
+declare const DatasetReleaseSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"dataset_release">;
+    schemaVersion: z.ZodLiteral<"0.1.0">;
+    id: z.ZodString;
+    version: z.ZodString;
+    title: z.ZodString;
+    description: z.ZodString;
+    createdAt: z.ZodString;
+    access: z.ZodEnum<{
+        unknown: "unknown";
+        public: "public";
+        restricted: "restricted";
+    }>;
+    license: z.ZodUnion<readonly [z.ZodObject<{
+        state: z.ZodLiteral<"unknown">;
+        reason: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        state: z.ZodLiteral<"declared">;
+        identifier: z.ZodString;
+    }, z.core.$strict>]>;
+    packets: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        packetId: z.ZodString;
+        sha256: z.ZodString;
+        byteLength: z.ZodNumber;
+    }, z.core.$strict>>;
+    sessions: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        time: z.ZodUnion<readonly [z.ZodObject<{
+            state: z.ZodLiteral<"unknown">;
+            reason: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            state: z.ZodLiteral<"known">;
+            start: z.ZodString;
+            end: z.ZodString;
+            timeScale: z.ZodLiteral<"UTC">;
+        }, z.core.$strict>]>;
+        members: z.ZodArray<z.ZodObject<{
+            packetRef: z.ZodString;
+            acquisitionRef: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    extensions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+}, z.core.$strict>;
+type DatasetRelease = z.infer<typeof DatasetReleaseSchema>;
+declare function datasetReleaseJsonSchema(): Record<string, unknown>;
+interface DatasetPacketInput {
+    manifest: Uint8Array;
+    files: ReadonlyMap<string, Uint8Array>;
+}
+type Status$6 = "passed" | "failed" | "not_checked";
+interface DatasetIssue {
+    code: string;
+    pointer: string;
+    message: string;
+    stage: "structural" | "semantic" | "profile" | "external";
+}
+interface DatasetReleaseResult {
+    success: boolean;
+    profile: typeof DATASET_RELEASE_PROFILE;
+    contract: {
+        schemaId: typeof DATASET_RELEASE_SCHEMA_ID;
+        rulesetVersion: "0.1.0";
+    };
+    checks: {
+        structural: Status$6;
+        semantic: Status$6;
+        profile: Status$6;
+        external: Status$6;
+    };
+    release?: {
+        id: string;
+        version: string;
+    };
+    issues: DatasetIssue[];
+    packets: {
+        packetRef: string;
+        manifestStatus: Status$6;
+        expectedSha256: string;
+        expectedByteLength: number;
+        actualSha256?: string;
+        actualByteLength?: number;
+        validation: ReproductionPacketResult | null;
+    }[];
+    sessions: {
+        sessionRef: string;
+        status: Status$6;
+        members: {
+            packetRef: string;
+            acquisitionRef: string;
+            classification?: string;
+            status: Status$6;
+        }[];
+    }[];
+    scientificEligibility: "not_checked";
+    authorization: "not_checked";
+    crossInstrumentIdentity: "not_checked";
+}
+/** Verifies exact packet manifests and explicit nominal session membership. Does not infer simultaneity or physical identity. */
+declare function evaluateDatasetRelease(input: unknown, options?: {
+    packets?: ReadonlyMap<string, DatasetPacketInput>;
+}): Promise<DatasetReleaseResult>;
+
+declare const SOURCE_INTAKE_SCHEMA_ID = "urn:disclosureos:experimental:source-intake:0.1.0";
+declare const SOURCE_INTAKE_PROFILE: Readonly<{
+    readonly id: "urn:disclosureos:experimental:profile:source-intake";
+    readonly version: "0.1.0";
+    readonly scope: "local_file_receipt_identity";
+}>;
+declare const SourceIntakeSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"source_intake">;
+    schemaVersion: z.ZodLiteral<"0.1.0">;
+    id: z.ZodString;
+    receivedAt: z.ZodString;
+    source: z.ZodObject<{
+        publisher: z.ZodUnion<readonly [z.ZodObject<{
+            state: z.ZodLiteral<"unknown">;
+            reason: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            state: z.ZodLiteral<"declared">;
+            value: z.ZodString;
+        }, z.core.$strict>]>;
+        uri: z.ZodOptional<z.ZodURL>;
+    }, z.core.$strict>;
+    access: z.ZodEnum<{
+        unknown: "unknown";
+        public: "public";
+        restricted: "restricted";
+    }>;
+    license: z.ZodUnion<readonly [z.ZodObject<{
+        state: z.ZodLiteral<"unknown">;
+        reason: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        state: z.ZodLiteral<"declared">;
+        value: z.ZodString;
+    }, z.core.$strict>]>;
+    artifacts: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        originalName: z.ZodString;
+        role: z.ZodEnum<{
+            unknown: "unknown";
+            derived: "derived";
+            documentation: "documentation";
+            native_raw: "native_raw";
+            source_export: "source_export";
+        }>;
+        format: z.ZodUnion<readonly [z.ZodObject<{
+            state: z.ZodLiteral<"unknown">;
+            reason: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            state: z.ZodLiteral<"declared">;
+            value: z.ZodString;
+        }, z.core.$strict>]>;
+        sha256: z.ZodString;
+        byteLength: z.ZodNumber;
+        context: z.ZodObject<{
+            instrument: z.ZodUnion<readonly [z.ZodObject<{
+                state: z.ZodLiteral<"unknown">;
+                reason: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                state: z.ZodLiteral<"declared">;
+                value: z.ZodString;
+            }, z.core.$strict>]>;
+            calibration: z.ZodUnion<readonly [z.ZodObject<{
+                state: z.ZodLiteral<"unknown">;
+                reason: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                state: z.ZodLiteral<"declared">;
+                value: z.ZodString;
+            }, z.core.$strict>]>;
+            clock: z.ZodUnion<readonly [z.ZodObject<{
+                state: z.ZodLiteral<"unknown">;
+                reason: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                state: z.ZodLiteral<"declared">;
+                value: z.ZodString;
+            }, z.core.$strict>]>;
+            acquisitionTime: z.ZodUnion<readonly [z.ZodObject<{
+                state: z.ZodLiteral<"unknown">;
+                reason: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                state: z.ZodLiteral<"declared">;
+                kind: z.ZodLiteral<"instant">;
+                value: z.ZodString;
+                timeScale: z.ZodLiteral<"UTC">;
+            }, z.core.$strict>, z.ZodObject<{
+                state: z.ZodLiteral<"declared">;
+                kind: z.ZodLiteral<"interval">;
+                start: z.ZodString;
+                end: z.ZodString;
+                timeScale: z.ZodLiteral<"UTC">;
+            }, z.core.$strict>]>;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    extensions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+}, z.core.$strict>;
+type SourceIntake = z.infer<typeof SourceIntakeSchema>;
+declare function sourceIntakeJsonSchema(): Record<string, unknown>;
+type Status$5 = "passed" | "failed" | "not_checked";
+interface SourceIntakeResult {
+    success: boolean;
+    profile: typeof SOURCE_INTAKE_PROFILE;
+    contract: {
+        schemaId: typeof SOURCE_INTAKE_SCHEMA_ID;
+        rulesetVersion: "0.1.0";
+    };
+    checks: {
+        structural: Status$5;
+        semantic: Status$5;
+        profile: Status$5;
+        external: Status$5;
+    };
+    issues: {
+        code: string;
+        stage: "structural" | "semantic" | "external";
+        pointer: string;
+        message: string;
+    }[];
+    gaps: {
+        pointer: string;
+        reason: string;
+        nextAction: string;
+    }[];
+    files: {
+        id: string;
+        status: Status$5;
+        expectedSha256: string;
+        expectedByteLength: number;
+        actualSha256?: string;
+        actualByteLength?: number;
+    }[];
+    researchEligibility: "not_checked";
+    artifactContents: "not_checked";
+    authorization: "not_checked";
+}
+/** Receipt integrity only: missing context never requires fabricated observations or reviews. */
+declare function evaluateSourceIntake(input: unknown, options?: {
+    files?: ReadonlyMap<string, Uint8Array>;
+}): Promise<SourceIntakeResult>;
+
+declare const DOCUMENTATION_COMPLETION_POLICY: Readonly<{
+    readonly id: "urn:disclosureos:experimental:policy:documentation-completion";
+    readonly version: "0.1.0";
+    readonly scope: "assessment_documentation_requirements";
+}>;
+declare const DOCUMENTATION_REQUIREMENTS: readonly Readonly<{
+    readonly id: "assessment";
+    readonly label: "Attributed evaluator assessment";
+} | {
+    readonly id: "documentary_support";
+    readonly label: "Traceable support, method descriptions and passage locators";
+} | {
+    readonly id: "content_digests";
+    readonly label: "Supporting content digests";
+} | {
+    readonly id: "content_integrity";
+    readonly label: "Local supporting content verification";
+} | {
+    readonly id: "measurement";
+    readonly label: "Measurement matching the confirmed subject";
+} | {
+    readonly id: "event_time";
+    readonly label: "Supplied event time";
+} | {
+    readonly id: "measurement_uncertainty";
+    readonly label: "Characterized measurement uncertainty";
+} | {
+    readonly id: "raw_product_lineage";
+    readonly label: "Primary instrument product lineage";
+} | {
+    readonly id: "reference_frames";
+    readonly label: "Declared measurement frame context";
+}>[];
+type DocumentationRequirementId = (typeof DOCUMENTATION_REQUIREMENTS)[number]["id"];
+type CompletionStatus = "satisfied" | "missing" | "failed" | "not_checked" | "not_applicable";
+interface DocumentationAction extends DocumentationIssue {
+    nextAction: string;
+}
+interface DocumentationRequirement {
+    id: DocumentationRequirementId;
+    label: string;
+    importance: "required";
+    applicability: "applicable" | "not_applicable" | "not_checked";
+    status: CompletionStatus;
+    reason: string;
+    actions: DocumentationAction[];
+    blockedBy: DocumentationRequirementId[];
+}
+interface AssessmentDocumentationCompletion {
+    claimRef: string;
+    topic: string;
+    subject: ClaimSubject;
+    /** The existing documentary profile remains authoritative. */
+    documentationStatus: "passed" | "failed" | "not_checked";
+    requirements: DocumentationRequirement[];
+    /** Counts of checklist groups, not evidence volume, percentages, weights or scores. */
+    counts: Record<CompletionStatus, number>;
+}
+interface DocumentationCompletionResult {
+    policy: typeof DOCUMENTATION_COMPLETION_POLICY;
+    applicability: {
+        state: "applicable" | "not_applicable" | "not_checked";
+        reason: string;
+    };
+    validation: DocumentationResult;
+    assessments: AssessmentDocumentationCompletion[];
+    actions: DocumentationAction[];
+    scientificEligibility: "not_checked";
+    artifactContents: "not_checked";
+    methodExecution: "not_checked";
+}
+/** Explain the existing documentary profile; never accept caller-asserted completion flags. */
+declare function evaluateDocumentationCompletion(input: unknown, options?: DocumentationOptions): Promise<DocumentationCompletionResult>;
+
+declare const INSTRUMENT_RESEARCH_COMPLETION_POLICY: Readonly<{
+    readonly id: "urn:disclosureos:experimental:policy:instrument-research-completion";
+    readonly version: "0.1.0";
+    readonly scope: "selected_instrument_research_prerequisites";
+}>;
+declare const INSTRUMENT_RESEARCH_REQUIREMENTS: readonly Readonly<{
+    readonly id: "input_consistency";
+    readonly label: "Reported structural and semantic consistency";
+} | {
+    readonly id: "review_scope";
+    readonly label: "Nonempty mapped measurement review scope";
+} | {
+    readonly id: "reviewed_context";
+    readonly label: "Calibration, uncertainty and interpreted timing prerequisites";
+} | {
+    readonly id: "assessment_documentation";
+    readonly label: "Assessment documentation and supporting bytes";
+} | {
+    readonly id: "measurement_acquisition";
+    readonly label: "Measurement and acquisition bindings with supporting bytes";
+} | {
+    readonly id: "report_integrity";
+    readonly label: "Calibration-use and timing review report integrity";
+}>[];
+type ResearchRequirementId = (typeof INSTRUMENT_RESEARCH_REQUIREMENTS)[number]["id"];
+type ResearchCompletionStatus = "satisfied" | "missing" | "failed" | "not_checked";
+interface ResearchCompletionAction extends MeasurementBindingIssue {
+    nextAction: string;
+    measurementRef?: string;
+}
+interface ResearchCompletionRequirement {
+    id: ResearchRequirementId;
+    label: string;
+    importance: "required";
+    status: ResearchCompletionStatus;
+    reason: string;
+    blockedBy: ResearchRequirementId[];
+    actions: ResearchCompletionAction[];
+}
+interface InstrumentResearchCompletionResult {
+    policy: typeof INSTRUMENT_RESEARCH_COMPLETION_POLICY;
+    applicability: {
+        state: "selected";
+        reason: string;
+    };
+    validation: InstrumentResearchResult;
+    requirements: ResearchCompletionRequirement[];
+    counts: Record<ResearchCompletionStatus, number>;
+    actions: ResearchCompletionAction[];
+    scientificEligibility: "not_checked";
+    calibrationAdequacy: "not_checked";
+    timingModel: "not_checked";
+    reviewerAuthenticity: "not_checked";
+}
+/** Guidance for the explicitly selected profile. All validation is delegated, including early exits. */
+declare function evaluateInstrumentResearchCompletion(historyInput: unknown, contextInput: unknown, acquisitionBindingsInput: unknown, measurementBindingsInput: unknown, reviewInput: unknown, options?: InstrumentResearchOptions): Promise<InstrumentResearchCompletionResult>;
+
+declare const RESEARCH_EVALUATION_SCHEMA_ID = "urn:disclosureos:experimental:research-evaluation:0.1.0";
+declare const RESEARCH_EVALUATION_POLICY: Readonly<{
+    readonly id: "urn:disclosureos:experimental:policy:research-evaluation";
+    readonly version: "0.1.0";
+    readonly scope: "local_byte_identity_and_computed_prerequisites";
+}>;
+declare const ResearchEvaluationSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"research_evaluation">;
+    schemaVersion: z.ZodLiteral<"0.1.0">;
+    id: z.ZodString;
+    workflow: z.ZodLiteral<"research-completion:0.1.0">;
+    packet: z.ZodObject<{
+        sha256: z.ZodString;
+        byteLength: z.ZodNumber;
+    }, z.core.$strict>;
+    dependencies: z.ZodObject<{
+        vocabularies: z.ZodArray<z.ZodObject<{
+            sha256: z.ZodString;
+            byteLength: z.ZodNumber;
+            ref: z.ZodString;
+            id: z.ZodString;
+            version: z.ZodString;
+        }, z.core.$strict>>;
+        implementation: z.ZodObject<{
+            sha256: z.ZodString;
+            byteLength: z.ZodNumber;
+            ref: z.ZodString;
+            id: z.ZodString;
+            version: z.ZodString;
+        }, z.core.$strict>;
+        environment: z.ZodObject<{
+            sha256: z.ZodString;
+            byteLength: z.ZodNumber;
+            ref: z.ZodString;
+            id: z.ZodString;
+            version: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+type ResearchEvaluation = z.infer<typeof ResearchEvaluationSchema>;
+declare function researchEvaluationJsonSchema(): Record<string, unknown>;
+type Status$4 = "passed" | "failed" | "not_checked";
+interface ResearchEvaluationOptions {
+    packetBytes?: Uint8Array;
+    files?: ReadonlyMap<string, Uint8Array>;
+    dependencyFiles?: ReadonlyMap<string, Uint8Array>;
+}
+interface ResearchEvaluationOutput {
+    packet: ReproductionPacketResult;
+    completion: InstrumentResearchCompletionResult;
+}
+interface ResearchEvaluationReceipt {
+    format: "disclosureos-research-evaluation-receipt:0.1.0";
+    serialization: "sorted-json-utf8:0.1.0";
+    request: {
+        sha256: string;
+        byteLength: number;
+    };
+    output: {
+        sha256: string;
+        byteLength: number;
+    };
+    /** These exact strings are hashed as UTF-8; no trailing newline is added. */
+    requestJson: string;
+    outputJson: string;
+}
+interface ResearchEvaluationResult {
+    success: boolean;
+    policy: typeof RESEARCH_EVALUATION_POLICY;
+    checks: {
+        structural: Status$4;
+        semantic: Status$4;
+        external: Status$4;
+        evaluation: Status$4;
+        receipt: Status$4;
+    };
+    issues: {
+        code: string;
+        pointer: string;
+        message: string;
+    }[];
+    files: ReproductionFileCheck[];
+    packetValidation: ReproductionPacketResult | null;
+    output: ResearchEvaluationOutput | null;
+    receipt: ResearchEvaluationReceipt | null;
+    implementationExecution: "not_attested";
+    environmentExecution: "not_attested";
+    vocabularyMembership: "not_checked";
+    scientificEligibility: "not_checked";
+}
+/** Executes only the fixed built-in workflow. Supplied artifacts are pinned, never fetched or executed. */
+declare function evaluateResearchEvaluation(input: unknown, options?: ResearchEvaluationOptions): Promise<ResearchEvaluationResult>;
+
+declare const RELEASED_DOCUMENT_SELECTION_SCHEMA_ID = "urn:disclosureos:experimental:released-document-selection:0.1.0";
+declare const RELEASED_DOCUMENT_PROFILE: Readonly<{
+    readonly id: "urn:disclosureos:experimental:profile:released-document-provenance";
+    readonly version: "0.1.0";
+    readonly scope: "selected_document_sources_and_direct_extractions";
+    readonly maturity: "experimental";
+}>;
+declare const ReleasedDocumentSelectionSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"released_document_selection">;
+    schemaVersion: z.ZodLiteral<"0.1.0">;
+    id: z.ZodString;
+    historyId: z.ZodString;
+    observationId: z.ZodString;
+    documents: z.ZodArray<z.ZodObject<{
+        sourceRef: z.ZodString;
+        release: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            state: z.ZodLiteral<"known">;
+            releasedBy: z.ZodString;
+            reference: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            state: z.ZodLiteral<"unknown">;
+            reason: z.ZodString;
+        }, z.core.$strict>], "state">;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+type ReleasedDocumentSelection = z.infer<typeof ReleasedDocumentSelectionSchema>;
+declare function releasedDocumentSelectionJsonSchema(): Record<string, unknown>;
+declare const RELEASED_DOCUMENT_REQUIREMENTS: readonly Readonly<{
+    readonly id: "document_source";
+    readonly importance: "required";
+    readonly label: "Declared public document source";
+} | {
+    readonly id: "release_citation";
+    readonly importance: "required";
+    readonly label: "Attributed release citation";
+} | {
+    readonly id: "content_digest";
+    readonly importance: "required";
+    readonly label: "Declared document SHA-256";
+} | {
+    readonly id: "content_integrity";
+    readonly importance: "required";
+    readonly label: "Exact local document bytes";
+} | {
+    readonly id: "extraction_traceability";
+    readonly importance: "required";
+    readonly label: "Locators and extractor identities for supplied direct extractions";
+} | {
+    readonly id: "source_title";
+    readonly importance: "recommended";
+    readonly label: "Human-readable source title";
+} | {
+    readonly id: "source_uri";
+    readonly importance: "recommended";
+    readonly label: "Source retrieval reference";
+} | {
+    readonly id: "source_attribution";
+    readonly importance: "recommended";
+    readonly label: "Source-side attribution for supplied direct extractions";
+}>[];
+type ReleasedDocumentRequirementId = (typeof RELEASED_DOCUMENT_REQUIREMENTS)[number]["id"];
+type Status$3 = "passed" | "failed" | "not_checked";
+type ReleasedDocumentCompletionStatus = "satisfied" | "missing" | "failed" | "not_checked" | "not_applicable";
+interface ReleasedDocumentIssue {
+    code: string;
+    stage: "structural" | "semantic" | "profile" | "external" | "recommendation";
+    severity: "error" | "warning";
+    pointer: string;
+    message: string;
+    nextAction: string;
+}
+interface ReleasedDocumentRequirement {
+    id: ReleasedDocumentRequirementId;
+    label: string;
+    importance: "required" | "recommended";
+    status: ReleasedDocumentCompletionStatus;
+    reason: string;
+    blockedBy: ReleasedDocumentRequirementId[];
+    issues: ReleasedDocumentIssue[];
+}
+interface ReleasedDocumentReport {
+    sourceRef: string;
+    status: Status$3;
+    requirements: ReleasedDocumentRequirement[];
+    extractionRefs: string[];
+    asset: {
+        status: Status$3;
+        expectedSha256?: string;
+        actualSha256?: string;
+        byteLength?: number;
+    };
+}
+interface ReleasedDocumentResult {
+    success: boolean;
+    profile: typeof RELEASED_DOCUMENT_PROFILE;
+    selection: ReleasedDocumentSelection | null;
+    validation: ReturnType<typeof parseExperimentalClaimHistory>;
+    checks: {
+        structural: Status$3;
+        semantic: Status$3;
+        profile: Status$3;
+        external: Status$3;
+    };
+    documents: ReleasedDocumentReport[];
+    issues: ReleasedDocumentIssue[];
+    releaseAuthenticity: "not_checked";
+    redistributionRights: "not_checked";
+    locatorContents: "not_checked";
+    extractionAccuracy: "not_checked";
+    assessmentSupport: "not_checked";
+    scientificEligibility: "not_checked";
+}
+/** Selected documentary provenance only. Assessments and scientific sufficiency are not evaluated. */
+declare function evaluateReleasedDocuments(historyInput: unknown, selectionInput: unknown, options?: {
+    assets?: ReadonlyMap<string, Uint8Array>;
+}): Promise<ReleasedDocumentResult>;
+
+declare const HISTORICAL_TESTIMONY_SELECTION_SCHEMA_ID = "urn:disclosureos:experimental:historical-testimony-selection:0.1.0";
+declare const HISTORICAL_TESTIMONY_PROFILE: Readonly<{
+    readonly id: "urn:disclosureos:experimental:profile:historical-testimony-provenance";
+    readonly version: "0.1.0";
+    readonly scope: "selected_testimony_sources_and_direct_extractions";
+    readonly maturity: "experimental";
+}>;
+declare const HistoricalTestimonySelectionSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"historical_testimony_selection">;
+    schemaVersion: z.ZodLiteral<"0.1.0">;
+    id: z.ZodString;
+    historyId: z.ZodString;
+    observationId: z.ZodString;
+    accounts: z.ZodArray<z.ZodObject<{
+        sourceRef: z.ZodString;
+        recording: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            state: z.ZodLiteral<"known">;
+            recordedBy: z.ZodString;
+            reference: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            state: z.ZodLiteral<"unknown">;
+            reason: z.ZodString;
+        }, z.core.$strict>], "state">;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+type HistoricalTestimonySelection = z.infer<typeof HistoricalTestimonySelectionSchema>;
+declare function historicalTestimonySelectionJsonSchema(): Record<string, unknown>;
+declare const HISTORICAL_TESTIMONY_REQUIREMENTS: readonly Readonly<{
+    readonly id: "testimony_source";
+    readonly importance: "required";
+    readonly label: "Declared testimony source";
+} | {
+    readonly id: "recording_citation";
+    readonly importance: "required";
+    readonly label: "Attributed recording citation";
+} | {
+    readonly id: "content_digest";
+    readonly importance: "required";
+    readonly label: "Declared account SHA-256";
+} | {
+    readonly id: "content_integrity";
+    readonly importance: "required";
+    readonly label: "Exact local account bytes";
+} | {
+    readonly id: "extraction_traceability";
+    readonly importance: "required";
+    readonly label: "Locators, speaker attribution and extractor identities for supplied direct extractions";
+} | {
+    readonly id: "source_title";
+    readonly importance: "recommended";
+    readonly label: "Human-readable source title";
+} | {
+    readonly id: "source_uri";
+    readonly importance: "recommended";
+    readonly label: "Source retrieval reference";
+}>[];
+type HistoricalTestimonyRequirementId = (typeof HISTORICAL_TESTIMONY_REQUIREMENTS)[number]["id"];
+type Status$2 = "passed" | "failed" | "not_checked";
+type HistoricalTestimonyCompletionStatus = "satisfied" | "missing" | "failed" | "not_checked" | "not_applicable";
+interface HistoricalTestimonyIssue {
+    code: string;
+    stage: "structural" | "semantic" | "profile" | "external" | "recommendation";
+    severity: "error" | "warning";
+    pointer: string;
+    message: string;
+    nextAction: string;
+}
+interface HistoricalTestimonyRequirement {
+    id: HistoricalTestimonyRequirementId;
+    label: string;
+    importance: "required" | "recommended";
+    status: HistoricalTestimonyCompletionStatus;
+    reason: string;
+    blockedBy: HistoricalTestimonyRequirementId[];
+    issues: HistoricalTestimonyIssue[];
+}
+interface HistoricalTestimonyReport {
+    sourceRef: string;
+    status: Status$2;
+    requirements: HistoricalTestimonyRequirement[];
+    extractionRefs: string[];
+    asset: {
+        status: Status$2;
+        expectedSha256?: string;
+        actualSha256?: string;
+        byteLength?: number;
+    };
+}
+interface HistoricalTestimonyResult {
+    success: boolean;
+    profile: typeof HISTORICAL_TESTIMONY_PROFILE;
+    selection: HistoricalTestimonySelection | null;
+    validation: ReturnType<typeof parseExperimentalClaimHistory>;
+    checks: {
+        structural: Status$2;
+        semantic: Status$2;
+        profile: Status$2;
+        external: Status$2;
+    };
+    accounts: HistoricalTestimonyReport[];
+    issues: HistoricalTestimonyIssue[];
+    recordingAuthenticity: "not_checked";
+    speakerIdentity: "not_checked";
+    accountAccuracy: "not_checked";
+    firsthandKnowledge: "not_checked";
+    witnessIndependence: "not_checked";
+    redistributionRights: "not_checked";
+    locatorContents: "not_checked";
+    extractionAccuracy: "not_checked";
+    assessmentSupport: "not_checked";
+    scientificEligibility: "not_checked";
+}
+/** Selected testimony provenance only. Assessments and scientific sufficiency are not evaluated. */
+declare function evaluateHistoricalTestimony(historyInput: unknown, selectionInput: unknown, options?: {
+    assets?: ReadonlyMap<string, Uint8Array>;
+}): Promise<HistoricalTestimonyResult>;
+
+declare const PHYSICAL_SAMPLE_SELECTION_SCHEMA_ID = "urn:disclosureos:experimental:physical-sample-selection:0.1.0";
+declare const PHYSICAL_SAMPLE_PROFILE: Readonly<{
+    readonly id: "urn:disclosureos:experimental:profile:physical-sample-provenance";
+    readonly version: "0.1.0";
+    readonly scope: "selected_collected_specimen_custody_declarations";
+    readonly maturity: "experimental";
+}>;
+declare const PhysicalSampleSelectionSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"physical_sample_selection">;
+    schemaVersion: z.ZodLiteral<"0.1.0">;
+    id: z.ZodString;
+    historyId: z.ZodString;
+    observationId: z.ZodString;
+    samples: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        lineage: z.ZodEnum<{
+            unknown: "unknown";
+            collected_specimen: "collected_specimen";
+            derived_sample: "derived_sample";
+            mixture: "mixture";
+        }>;
+        label: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            state: z.ZodLiteral<"known">;
+            value: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            state: z.ZodLiteral<"unknown">;
+            reason: z.ZodString;
+        }, z.core.$strict>], "state">;
+        collection: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            state: z.ZodLiteral<"known">;
+            collectedBy: z.ZodString;
+            recordRef: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            state: z.ZodLiteral<"unknown">;
+            reason: z.ZodString;
+        }, z.core.$strict>], "state">;
+        custody: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            state: z.ZodLiteral<"documented">;
+            transfers: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                from: z.ZodString;
+                to: z.ZodString;
+                recordRef: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>, z.ZodObject<{
+            state: z.ZodLiteral<"unknown">;
+            reason: z.ZodString;
+        }, z.core.$strict>], "state">;
+        currentCustodian: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            state: z.ZodLiteral<"known">;
+            holder: z.ZodString;
+            recordRef: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            state: z.ZodLiteral<"unknown">;
+            reason: z.ZodString;
+        }, z.core.$strict>], "state">;
+        catalogIdentifier: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+type PhysicalSampleSelection = z.infer<typeof PhysicalSampleSelectionSchema>;
+declare function physicalSampleSelectionJsonSchema(): Record<string, unknown>;
+declare const PHYSICAL_SAMPLE_REQUIREMENTS: readonly Readonly<{
+    readonly id: "sample_scope";
+    readonly importance: "required";
+    readonly label: "Declared collected specimen";
+} | {
+    readonly id: "sample_identity";
+    readonly importance: "required";
+    readonly label: "Recorded specimen label";
+} | {
+    readonly id: "collection_record";
+    readonly importance: "required";
+    readonly label: "Attributed collection record";
+} | {
+    readonly id: "custody_record";
+    readonly importance: "required";
+    readonly label: "Declared handoff continuity";
+} | {
+    readonly id: "current_custodian";
+    readonly importance: "required";
+    readonly label: "Cited current custodian";
+} | {
+    readonly id: "record_integrity";
+    readonly importance: "required";
+    readonly label: "Exact cited record bytes";
+} | {
+    readonly id: "catalog_identifier";
+    readonly importance: "recommended";
+    readonly label: "External catalog identifier";
+}>[];
+type PhysicalSampleRequirementId = (typeof PHYSICAL_SAMPLE_REQUIREMENTS)[number]["id"];
+type Status$1 = "passed" | "failed" | "not_checked";
+interface PhysicalSampleIssue {
+    code: string;
+    stage: "structural" | "semantic" | "profile" | "external" | "recommendation";
+    severity: "error" | "warning";
+    pointer: string;
+    message: string;
+    nextAction: string;
+}
+interface PhysicalSampleRequirement {
+    id: PhysicalSampleRequirementId;
+    importance: "required" | "recommended";
+    label: string;
+    status: "satisfied" | "missing" | "failed" | "not_checked";
+    reason: string;
+    blockedBy: PhysicalSampleRequirementId[];
+    issues: PhysicalSampleIssue[];
+}
+interface PhysicalSampleRecordCheck {
+    sourceRef: string;
+    status: Status$1;
+    expectedSha256?: string;
+    actualSha256?: string;
+    byteLength?: number;
+}
+interface PhysicalSampleReport {
+    sampleId: string;
+    status: Status$1;
+    requirements: PhysicalSampleRequirement[];
+    records: PhysicalSampleRecordCheck[];
+}
+interface PhysicalSampleResult {
+    success: boolean;
+    profile: typeof PHYSICAL_SAMPLE_PROFILE;
+    selection: PhysicalSampleSelection | null;
+    validation: ReturnType<typeof parseExperimentalClaimHistory>;
+    checks: {
+        structural: Status$1;
+        semantic: Status$1;
+        profile: Status$1;
+        external: Status$1;
+    };
+    samples: PhysicalSampleReport[];
+    issues: PhysicalSampleIssue[];
+    specimenIdentity: "not_checked";
+    collectionAuthenticity: "not_checked";
+    custodyAuthenticity: "not_checked";
+    custodyCompleteness: "not_checked";
+    custodyChronology: "not_checked";
+    recordContents: "not_checked";
+    contaminationControl: "not_checked";
+    composition: "not_checked";
+    origin: "not_checked";
+    redistributionRights: "not_checked";
+    assessmentSupport: "not_checked";
+    scientificEligibility: "not_checked";
+}
+/** Documentary declarations only; never establishes physical identity, custody truth or origin. */
+declare function evaluatePhysicalSamples(historyInput: unknown, selectionInput: unknown, options?: {
+    assets?: ReadonlyMap<string, Uint8Array>;
+}): Promise<PhysicalSampleResult>;
+
+declare const PROFILE_EVALUATION_SCHEMA_ID = "urn:disclosureos:experimental:profile-evaluation:0.1.0";
+declare const PROFILE_EVALUATION_POLICY: Readonly<{
+    readonly id: "urn:disclosureos:experimental:policy:profile-evaluation";
+    readonly version: "0.1.0";
+    readonly scope: "pinned_inputs_and_computed_provenance_profile";
+}>;
+declare const ProfileEvaluationSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"profile_evaluation">;
+    schemaVersion: z.ZodLiteral<"0.1.0">;
+    id: z.ZodString;
+    workflow: z.ZodEnum<{
+        "released-documents:0.1.0": "released-documents:0.1.0";
+        "historical-testimony:0.1.0": "historical-testimony:0.1.0";
+        "physical-samples:0.1.0": "physical-samples:0.1.0";
+    }>;
+    history: z.ZodObject<{
+        sha256: z.ZodString;
+        byteLength: z.ZodNumber;
+    }, z.core.$strict>;
+    selection: z.ZodObject<{
+        sha256: z.ZodString;
+        byteLength: z.ZodNumber;
+    }, z.core.$strict>;
+    assets: z.ZodArray<z.ZodObject<{
+        sha256: z.ZodString;
+        byteLength: z.ZodNumber;
+        ref: z.ZodString;
+        fileRef: z.ZodString;
+    }, z.core.$strict>>;
+    dependencies: z.ZodObject<{
+        vocabularies: z.ZodArray<z.ZodObject<{
+            sha256: z.ZodString;
+            byteLength: z.ZodNumber;
+            ref: z.ZodString;
+            id: z.ZodString;
+            version: z.ZodString;
+        }, z.core.$strict>>;
+        implementation: z.ZodObject<{
+            sha256: z.ZodString;
+            byteLength: z.ZodNumber;
+            ref: z.ZodString;
+            id: z.ZodString;
+            version: z.ZodString;
+        }, z.core.$strict>;
+        environment: z.ZodObject<{
+            sha256: z.ZodString;
+            byteLength: z.ZodNumber;
+            ref: z.ZodString;
+            id: z.ZodString;
+            version: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+type ProfileEvaluation = z.infer<typeof ProfileEvaluationSchema>;
+declare function profileEvaluationJsonSchema(): Record<string, unknown>;
+interface ProfileEvaluationOptions {
+    historyBytes?: Uint8Array;
+    selectionBytes?: Uint8Array;
+    assetFiles?: ReadonlyMap<string, Uint8Array>;
+    dependencyFiles?: ReadonlyMap<string, Uint8Array>;
+}
+type Status = "passed" | "failed" | "not_checked";
+interface ProfileEvaluationReceipt {
+    format: "disclosureos-profile-evaluation-receipt:0.1.0";
+    serialization: "sorted-json-utf8:0.1.0";
+    request: {
+        sha256: string;
+        byteLength: number;
+    };
+    output: {
+        sha256: string;
+        byteLength: number;
+    };
+    requestJson: string;
+    outputJson: string;
+}
+interface ProfileEvaluationResult {
+    success: boolean;
+    policy: typeof PROFILE_EVALUATION_POLICY;
+    checks: {
+        structural: Status;
+        semantic: Status;
+        external: Status;
+        profile: Status;
+        receipt: Status;
+    };
+    issues: {
+        code: string;
+        pointer: string;
+        message: string;
+    }[];
+    files: {
+        ref: string;
+        status: Status;
+        expectedSha256: string;
+        expectedByteLength: number;
+        actualSha256?: string;
+        actualByteLength?: number;
+    }[];
+    profile: ReleasedDocumentResult | HistoricalTestimonyResult | PhysicalSampleResult | null;
+    receipt: ProfileEvaluationReceipt | null;
+    unselectedArtifactIntegrity: "not_checked";
+    vocabularyMembership: "not_checked";
+    scientificEligibility: "not_checked";
+    statisticalIndependence: "not_checked";
+    implementationExecution: "not_attested";
+    environmentExecution: "not_attested";
+}
+/** Runs only a fixed built-in provenance profile over pinned local inputs. Supplied dependencies are never executed. */
+declare function evaluateProfileEvaluation(input: unknown, options?: ProfileEvaluationOptions): Promise<ProfileEvaluationResult>;
+
+declare const PROFILE_PREPARATION_SCHEMA_ID = "urn:disclosureos:experimental:profile-preparation:0.1.0";
+declare const ProfilePreparationSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"profile_preparation">;
+    schemaVersion: z.ZodLiteral<"0.1.0">;
+    id: z.ZodString;
+    workflow: z.ZodEnum<{
+        "released-documents:0.1.0": "released-documents:0.1.0";
+        "historical-testimony:0.1.0": "historical-testimony:0.1.0";
+        "physical-samples:0.1.0": "physical-samples:0.1.0";
+    }>;
+    history: z.ZodString;
+    selection: z.ZodString;
+    assets: z.ZodArray<z.ZodObject<{
+        ref: z.ZodString;
+        fileRef: z.ZodString;
+        path: z.ZodString;
+    }, z.core.$strict>>;
+    dependencies: z.ZodObject<{
+        vocabularies: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            version: z.ZodString;
+            ref: z.ZodString;
+            path: z.ZodString;
+        }, z.core.$strict>>;
+        implementation: z.ZodObject<{
+            id: z.ZodString;
+            version: z.ZodString;
+            ref: z.ZodString;
+            path: z.ZodString;
+        }, z.core.$strict>;
+        environment: z.ZodObject<{
+            id: z.ZodString;
+            version: z.ZodString;
+            ref: z.ZodString;
+            path: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+type ProfilePreparation = z.infer<typeof ProfilePreparationSchema>;
+declare function profilePreparationJsonSchema(): Record<string, unknown>;
+
+declare const MIGRATION_REVIEW_SCHEMA_ID = "urn:disclosureos:experimental:migration-review:0.1.0";
+/** Plan structure only. Target values and references require the v2 semantic parser. */
+declare const MigrationReviewSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"legacy_migration_review">;
+    schemaVersion: z.ZodLiteral<"0.1.0">;
+    namespace: z.ZodString;
+    source: z.ZodObject<{
+        sha256: z.ZodString;
+        byteLength: z.ZodNumber;
+    }, z.core.$strict>;
+    reviewedBy: z.ZodString;
+    reviewedAt: z.ZodISODateTime;
+    decisions: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        field: z.ZodLiteral<"eventTime">;
+        sourceId: z.ZodString;
+        sourcePointers: z.ZodArray<z.ZodString>;
+        rationale: z.ZodString;
+        value: z.ZodJSONSchema;
+    }, z.core.$strict>, z.ZodObject<{
+        field: z.ZodLiteral<"position">;
+        frames: z.ZodArray<z.ZodJSONSchema>;
+        sourceId: z.ZodString;
+        sourcePointers: z.ZodArray<z.ZodString>;
+        rationale: z.ZodString;
+        value: z.ZodJSONSchema;
+    }, z.core.$strict>], "field">>;
+}, z.core.$strict>;
+type MigrationReview = z.infer<typeof MigrationReviewSchema>;
+declare function migrationReviewJsonSchema(): Record<string, unknown>;
+
+declare const MIGRATION_RESOLUTION_SCHEMA_ID = "urn:disclosureos:experimental:migration-resolution:0.1.0";
+/** Structure only: membership, exact pins and duplicate decisions require the resolver. */
+declare const MigrationResolutionSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"legacy_migration_resolution">;
+    schemaVersion: z.ZodLiteral<"0.1.0">;
+    ledger: z.ZodObject<{
+        sha256: z.ZodString;
+        byteLength: z.ZodNumber;
+    }, z.core.$strict>;
+    decidedBy: z.ZodString;
+    decidedAt: z.ZodISODateTime;
+    decisions: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        action: z.ZodLiteral<"select">;
+        revision: z.ZodString;
+        identity: z.ZodString;
+        rationale: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        action: z.ZodLiteral<"defer">;
+        identity: z.ZodString;
+        rationale: z.ZodString;
+    }, z.core.$strict>], "action">>;
+}, z.core.$strict>;
+type MigrationResolution = z.infer<typeof MigrationResolutionSchema>;
+declare function migrationResolutionJsonSchema(): Record<string, unknown>;
+
+declare const MIGRATION_LEGACY_SCORES_SCHEMA_ID = "urn:disclosureos:experimental:migration-legacy-scores:0.1.0";
+/** Declared association and output contract only; neither identity nor methodology is authenticated. */
+declare const MigrationLegacyScoresSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"legacy_score_preservation_plan">;
+    schemaVersion: z.ZodLiteral<"0.1.0">;
+    namespace: z.ZodString;
+    source: z.ZodObject<{
+        sha256: z.ZodString;
+        byteLength: z.ZodNumber;
+    }, z.core.$strict>;
+    reviewedBy: z.ZodString;
+    reviewedAt: z.ZodISODateTime;
+    decisions: z.ZodArray<z.ZodObject<{
+        sourcePointer: z.ZodString;
+        sourceId: z.ZodString;
+        resultKind: z.ZodEnum<{
+            completeness: "completeness";
+            compellingness: "compellingness";
+        }>;
+        outputContractVersion: z.ZodString;
+        methodologyVersion: z.ZodString;
+        rationale: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+type MigrationLegacyScores = z.infer<typeof MigrationLegacyScoresSchema>;
+declare function migrationLegacyScoresJsonSchema(): Record<string, unknown>;
+
+declare const MIGRATION_COMPATIBILITY_SCHEMA_ID = "urn:disclosureos:experimental:migration-compatibility:0.1.0";
+declare const MigrationCompatibilitySchema: z.ZodObject<{
+    kind: z.ZodLiteral<"legacy_sensor_revision_review">;
+    schemaVersion: z.ZodLiteral<"0.1.0">;
+    source: z.ZodObject<{
+        sha256: z.ZodString;
+        byteLength: z.ZodNumber;
+    }, z.core.$strict>;
+    namespace: z.ZodString;
+    reviewedBy: z.ZodString;
+    reviewedAt: z.ZodISODateTime;
+    context: z.ZodObject<{
+        bytes: z.ZodString;
+        sha256: z.ZodString;
+        byteLength: z.ZodNumber;
+    }, z.core.$strict>;
+    decisions: z.ZodArray<z.ZodObject<{
+        sourceId: z.ZodString;
+        sensorPointer: z.ZodString;
+        legacyRef: z.ZodString;
+        acquisitionRef: z.ZodString;
+        manifest: z.ZodObject<{
+            bytes: z.ZodString;
+            sha256: z.ZodString;
+            byteLength: z.ZodNumber;
+        }, z.core.$strict>;
+        provenance: z.ZodObject<{
+            bytes: z.ZodString;
+            sha256: z.ZodString;
+            byteLength: z.ZodNumber;
+        }, z.core.$strict>;
+        provenanceLocator: z.ZodString;
+        rationale: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+type MigrationCompatibility = z.infer<typeof MigrationCompatibilitySchema>;
+declare function migrationCompatibilityJsonSchema(): Record<string, unknown>;
+
+export { ACQUISITION_BINDINGS_PROFILE, ACQUISITION_BINDINGS_SCHEMA_ID, ASSESSMENT_DOCUMENTATION_PROFILE, type AcquisitionBindingOptions, type AcquisitionBindingResult, type AcquisitionBindings, AcquisitionBindingsSchema, type AssessmentDocumentation, type AssessmentDocumentationCompletion, type AssetCheck, type BindingAssetCheck, type BindingIssue, type BindingIssueCode, type CompletionStatus, DATASET_RELEASE_PROFILE, DATASET_RELEASE_SCHEMA_ID, DOCUMENTATION_COMPLETION_POLICY, DOCUMENTATION_REQUIREMENTS, type DatasetIssue, type DatasetPacketInput, type DatasetRelease, type DatasetReleaseResult, DatasetReleaseSchema, type DocumentationAction, type DocumentationCompletionResult, type DocumentationIssue, type DocumentationIssueCode, type DocumentationOptions, type DocumentationRequirement, type DocumentationRequirementId, type DocumentationResult, HISTORICAL_TESTIMONY_PROFILE, HISTORICAL_TESTIMONY_REQUIREMENTS, HISTORICAL_TESTIMONY_SELECTION_SCHEMA_ID, type HistoricalTestimonyCompletionStatus, type HistoricalTestimonyIssue, type HistoricalTestimonyReport, type HistoricalTestimonyRequirement, type HistoricalTestimonyRequirementId, type HistoricalTestimonyResult, type HistoricalTestimonySelection, HistoricalTestimonySelectionSchema, INSTRUMENT_RESEARCH_COMPLETION_POLICY, INSTRUMENT_RESEARCH_PREREQUISITES_PROFILE, INSTRUMENT_RESEARCH_REQUIREMENTS, INSTRUMENT_RESEARCH_REVIEW_SCHEMA_ID, type InstrumentResearchCompletionResult, type InstrumentResearchOptions, type InstrumentResearchResult, type InstrumentResearchReview, InstrumentResearchReviewSchema, MEASUREMENT_BINDINGS_PROFILE, MEASUREMENT_BINDINGS_SCHEMA_ID, MIGRATION_COMPATIBILITY_SCHEMA_ID, MIGRATION_LEGACY_SCORES_SCHEMA_ID, MIGRATION_RESOLUTION_SCHEMA_ID, MIGRATION_REVIEW_SCHEMA_ID, type MeasurementBindingIssue, type MeasurementBindingResult, type MeasurementBindings, MeasurementBindingsSchema, type MigrationCompatibility, MigrationCompatibilitySchema, type MigrationLegacyScores, MigrationLegacyScoresSchema, type MigrationResolution, MigrationResolutionSchema, type MigrationReview, MigrationReviewSchema, PHYSICAL_SAMPLE_PROFILE, PHYSICAL_SAMPLE_REQUIREMENTS, PHYSICAL_SAMPLE_SELECTION_SCHEMA_ID, PROFILE_EVALUATION_POLICY, PROFILE_EVALUATION_SCHEMA_ID, PROFILE_PREPARATION_SCHEMA_ID, type PhysicalSampleIssue, type PhysicalSampleRecordCheck, type PhysicalSampleReport, type PhysicalSampleRequirement, type PhysicalSampleRequirementId, type PhysicalSampleResult, type PhysicalSampleSelection, PhysicalSampleSelectionSchema, type ProductBindingCheck, type ProfileEvaluation, type ProfileEvaluationOptions, type ProfileEvaluationReceipt, type ProfileEvaluationResult, ProfileEvaluationSchema, type ProfilePreparation, ProfilePreparationSchema, RELEASED_DOCUMENT_PROFILE, RELEASED_DOCUMENT_REQUIREMENTS, RELEASED_DOCUMENT_SELECTION_SCHEMA_ID, REPRODUCTION_PACKET_PROFILE, REPRODUCTION_PACKET_SCHEMA_ID, RESEARCH_EVALUATION_POLICY, RESEARCH_EVALUATION_SCHEMA_ID, type ReleasedDocumentCompletionStatus, type ReleasedDocumentIssue, type ReleasedDocumentReport, type ReleasedDocumentRequirement, type ReleasedDocumentRequirementId, type ReleasedDocumentResult, type ReleasedDocumentSelection, ReleasedDocumentSelectionSchema, type ReproductionFileCheck, type ReproductionPacket, type ReproductionPacketResult, ReproductionPacketSchema, type ResearchCompletionAction, type ResearchCompletionRequirement, type ResearchCompletionStatus, type ResearchEvaluation, type ResearchEvaluationOptions, type ResearchEvaluationOutput, type ResearchEvaluationReceipt, type ResearchEvaluationResult, ResearchEvaluationSchema, type ResearchRequirementId, type ResearchReviewAssetCheck, SOURCE_INTAKE_PROFILE, SOURCE_INTAKE_SCHEMA_ID, type SourceIntake, type SourceIntakeResult, SourceIntakeSchema, acquisitionBindingsJsonSchema, datasetReleaseJsonSchema, evaluateAcquisitionBindings, evaluateAssessmentDocumentation, evaluateDatasetRelease, evaluateDocumentationCompletion, evaluateHistoricalTestimony, evaluateInstrumentResearchCompletion, evaluateInstrumentResearchPrerequisites, evaluateMeasurementBindings, evaluatePhysicalSamples, evaluateProfileEvaluation, evaluateReleasedDocuments, evaluateReproductionPacket, evaluateResearchEvaluation, evaluateSourceIntake, historicalTestimonySelectionJsonSchema, instrumentResearchReviewJsonSchema, measurementBindingsJsonSchema, migrationCompatibilityJsonSchema, migrationLegacyScoresJsonSchema, migrationResolutionJsonSchema, migrationReviewJsonSchema, physicalSampleSelectionJsonSchema, profileEvaluationJsonSchema, profilePreparationJsonSchema, releasedDocumentSelectionJsonSchema, reproductionPacketJsonSchema, researchEvaluationJsonSchema, sourceIntakeJsonSchema };