@actuarial-ts/data 0.7.0 → 0.8.0

package/dist/customizationContracts.d.ts

@@ -0,0 +1,2473 @@
+import { type AnalysisDefinition, type AnalysisClassificationDefinition, type AnalysisPredicate, type AnalysisRecipe, type AnalysisResult, type AnalysisScenario, type AnalysisScenarioGrid, type CustomizationExposureObservation, type CustomizationResourceLimits, type ExposureAllocationTarget, type ExposureLevelSchedule, type ExposureRevisionSelection, type HistoricalDatasetInput, type JsonValue } from "@actuarial-ts/core";
+import { z } from "zod";
+/** Complete, closed resource policy for every customization streaming boundary. */
+export declare const customizationResourceLimitsSchema: z.ZodType<CustomizationResourceLimits>;
+export declare const customizationExposureObservationSchema: z.ZodType<CustomizationExposureObservation>;
+export declare const exposureAllocationTargetSchema: z.ZodType<ExposureAllocationTarget>;
+export declare const exposureRevisionSelectionSchema: z.ZodType<ExposureRevisionSelection>;
+export declare const exposureLevelScheduleSchema: z.ZodType<ExposureLevelSchedule>;
+export declare const historicalRecordSchema: z.ZodEffects<z.ZodObject<{
+    recordId: z.ZodEffects<z.ZodString, string, string>;
+    sourceNamespace: z.ZodEffects<z.ZodString, string, string>;
+    claimId: z.ZodEffects<z.ZodString, string, string>;
+    grain: z.ZodEnum<["claim-snapshot", "claim-component-snapshot", "transaction"]>;
+    componentId: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+    accidentDate: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+    reportDate: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+    evaluationDate: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+    effectiveDate: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+    measures: z.ZodRecord<z.ZodEffects<z.ZodString, string, string>, z.ZodUnion<[z.ZodNumber, z.ZodNull]>>;
+    status: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+    dimensions: z.ZodOptional<z.ZodRecord<z.ZodEffects<z.ZodString, string, string>, z.ZodUnion<[z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>, z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>, "many">]>>>;
+    relationships: z.ZodOptional<z.ZodObject<{
+        claimantIds: z.ZodOptional<z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">>;
+        occurrenceId: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+        policyIds: z.ZodOptional<z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">>;
+        coverageIds: z.ZodOptional<z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">>;
+    }, "strict", z.ZodTypeAny, {
+        claimantIds?: string[] | undefined;
+        occurrenceId?: string | undefined;
+        policyIds?: string[] | undefined;
+        coverageIds?: string[] | undefined;
+    }, {
+        claimantIds?: string[] | undefined;
+        occurrenceId?: string | undefined;
+        policyIds?: string[] | undefined;
+        coverageIds?: string[] | undefined;
+    }>>;
+    completeness: z.ZodEnum<["complete-snapshot", "partial-snapshot", "change-only"]>;
+    revision: z.ZodObject<{
+        id: z.ZodEffects<z.ZodString, string, string>;
+        action: z.ZodEnum<["upsert", "delete"]>;
+        sequence: z.ZodOptional<z.ZodNumber>;
+        correctedAt: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        id: string;
+        action: "upsert" | "delete";
+        sequence?: number | undefined;
+        correctedAt?: string | undefined;
+    }, {
+        id: string;
+        action: "upsert" | "delete";
+        sequence?: number | undefined;
+        correctedAt?: string | undefined;
+    }>;
+    source: z.ZodObject<{
+        artifactId: z.ZodEffects<z.ZodString, string, string>;
+        sourceFile: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+        sourceSheet: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+        sourceRow: z.ZodOptional<z.ZodNumber>;
+    }, "strict", z.ZodTypeAny, {
+        artifactId: string;
+        sourceFile?: string | undefined;
+        sourceSheet?: string | undefined;
+        sourceRow?: number | undefined;
+    }, {
+        artifactId: string;
+        sourceFile?: string | undefined;
+        sourceSheet?: string | undefined;
+        sourceRow?: number | undefined;
+    }>;
+}, "strict", z.ZodTypeAny, {
+    claimId: string;
+    revision: {
+        id: string;
+        action: "upsert" | "delete";
+        sequence?: number | undefined;
+        correctedAt?: string | undefined;
+    };
+    source: {
+        artifactId: string;
+        sourceFile?: string | undefined;
+        sourceSheet?: string | undefined;
+        sourceRow?: number | undefined;
+    };
+    recordId: string;
+    sourceNamespace: string;
+    grain: "claim-snapshot" | "claim-component-snapshot" | "transaction";
+    measures: Record<string, number | null>;
+    completeness: "complete-snapshot" | "partial-snapshot" | "change-only";
+    status?: string | undefined;
+    evaluationDate?: string | undefined;
+    dimensions?: Record<string, string | number | boolean | (string | number | boolean | null)[] | null> | undefined;
+    effectiveDate?: string | undefined;
+    componentId?: string | undefined;
+    accidentDate?: string | undefined;
+    reportDate?: string | undefined;
+    relationships?: {
+        claimantIds?: string[] | undefined;
+        occurrenceId?: string | undefined;
+        policyIds?: string[] | undefined;
+        coverageIds?: string[] | undefined;
+    } | undefined;
+}, {
+    claimId: string;
+    revision: {
+        id: string;
+        action: "upsert" | "delete";
+        sequence?: number | undefined;
+        correctedAt?: string | undefined;
+    };
+    source: {
+        artifactId: string;
+        sourceFile?: string | undefined;
+        sourceSheet?: string | undefined;
+        sourceRow?: number | undefined;
+    };
+    recordId: string;
+    sourceNamespace: string;
+    grain: "claim-snapshot" | "claim-component-snapshot" | "transaction";
+    measures: Record<string, number | null>;
+    completeness: "complete-snapshot" | "partial-snapshot" | "change-only";
+    status?: string | undefined;
+    evaluationDate?: string | undefined;
+    dimensions?: Record<string, string | number | boolean | (string | number | boolean | null)[] | null> | undefined;
+    effectiveDate?: string | undefined;
+    componentId?: string | undefined;
+    accidentDate?: string | undefined;
+    reportDate?: string | undefined;
+    relationships?: {
+        claimantIds?: string[] | undefined;
+        occurrenceId?: string | undefined;
+        policyIds?: string[] | undefined;
+        coverageIds?: string[] | undefined;
+    } | undefined;
+}>, {
+    claimId: string;
+    revision: {
+        id: string;
+        action: "upsert" | "delete";
+        sequence?: number | undefined;
+        correctedAt?: string | undefined;
+    };
+    source: {
+        artifactId: string;
+        sourceFile?: string | undefined;
+        sourceSheet?: string | undefined;
+        sourceRow?: number | undefined;
+    };
+    recordId: string;
+    sourceNamespace: string;
+    grain: "claim-snapshot" | "claim-component-snapshot" | "transaction";
+    measures: Record<string, number | null>;
+    completeness: "complete-snapshot" | "partial-snapshot" | "change-only";
+    status?: string | undefined;
+    evaluationDate?: string | undefined;
+    dimensions?: Record<string, string | number | boolean | (string | number | boolean | null)[] | null> | undefined;
+    effectiveDate?: string | undefined;
+    componentId?: string | undefined;
+    accidentDate?: string | undefined;
+    reportDate?: string | undefined;
+    relationships?: {
+        claimantIds?: string[] | undefined;
+        occurrenceId?: string | undefined;
+        policyIds?: string[] | undefined;
+        coverageIds?: string[] | undefined;
+    } | undefined;
+}, {
+    claimId: string;
+    revision: {
+        id: string;
+        action: "upsert" | "delete";
+        sequence?: number | undefined;
+        correctedAt?: string | undefined;
+    };
+    source: {
+        artifactId: string;
+        sourceFile?: string | undefined;
+        sourceSheet?: string | undefined;
+        sourceRow?: number | undefined;
+    };
+    recordId: string;
+    sourceNamespace: string;
+    grain: "claim-snapshot" | "claim-component-snapshot" | "transaction";
+    measures: Record<string, number | null>;
+    completeness: "complete-snapshot" | "partial-snapshot" | "change-only";
+    status?: string | undefined;
+    evaluationDate?: string | undefined;
+    dimensions?: Record<string, string | number | boolean | (string | number | boolean | null)[] | null> | undefined;
+    effectiveDate?: string | undefined;
+    componentId?: string | undefined;
+    accidentDate?: string | undefined;
+    reportDate?: string | undefined;
+    relationships?: {
+        claimantIds?: string[] | undefined;
+        occurrenceId?: string | undefined;
+        policyIds?: string[] | undefined;
+        coverageIds?: string[] | undefined;
+    } | undefined;
+}>;
+export declare const historicalDatasetInputSchema: z.ZodEffects<z.ZodObject<{
+    historyContractVersion: z.ZodLiteral<"actuarial-history/1">;
+    datasetId: z.ZodEffects<z.ZodString, string, string>;
+    historyMode: z.ZodEnum<["full-snapshots", "changes", "mixed"]>;
+    revisionView: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+        kind: z.ZodLiteral<"as-known">;
+        knowledgeCutoff: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        kind: "as-known";
+        knowledgeCutoff: string;
+    }, {
+        kind: "as-known";
+        knowledgeCutoff: string;
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"restated">;
+    }, "strict", z.ZodTypeAny, {
+        kind: "restated";
+    }, {
+        kind: "restated";
+    }>]>;
+    revisionPrecedence: z.ZodEnum<["sequence", "corrected-at"]>;
+    missingSnapshotRecord: z.ZodEnum<["unknown", "carried-forward"]>;
+    sources: z.ZodArray<z.ZodObject<{
+        namespace: z.ZodEffects<z.ZodString, string, string>;
+        artifactId: z.ZodEffects<z.ZodString, string, string>;
+        mappingVersion: z.ZodEffects<z.ZodString, string, string>;
+    }, "strict", z.ZodTypeAny, {
+        artifactId: string;
+        namespace: string;
+        mappingVersion: string;
+    }, {
+        artifactId: string;
+        namespace: string;
+        mappingVersion: string;
+    }>, "many">;
+    evaluationDates: z.ZodOptional<z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">>;
+    openingBalances: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        sourceNamespace: z.ZodEffects<z.ZodString, string, string>;
+        claimId: z.ZodEffects<z.ZodString, string, string>;
+        asOfDate: z.ZodEffects<z.ZodString, string, string>;
+        measures: z.ZodRecord<z.ZodEffects<z.ZodString, string, string>, z.ZodNumber>;
+        source: z.ZodObject<{
+            artifactId: z.ZodEffects<z.ZodString, string, string>;
+            sourceFile: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+            sourceSheet: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+            sourceRow: z.ZodOptional<z.ZodNumber>;
+        }, "strict", z.ZodTypeAny, {
+            artifactId: string;
+            sourceFile?: string | undefined;
+            sourceSheet?: string | undefined;
+            sourceRow?: number | undefined;
+        }, {
+            artifactId: string;
+            sourceFile?: string | undefined;
+            sourceSheet?: string | undefined;
+            sourceRow?: number | undefined;
+        }>;
+    }, "strict", z.ZodTypeAny, {
+        claimId: string;
+        source: {
+            artifactId: string;
+            sourceFile?: string | undefined;
+            sourceSheet?: string | undefined;
+            sourceRow?: number | undefined;
+        };
+        sourceNamespace: string;
+        measures: Record<string, number>;
+        asOfDate: string;
+    }, {
+        claimId: string;
+        source: {
+            artifactId: string;
+            sourceFile?: string | undefined;
+            sourceSheet?: string | undefined;
+            sourceRow?: number | undefined;
+        };
+        sourceNamespace: string;
+        measures: Record<string, number>;
+        asOfDate: string;
+    }>, "many">>;
+    records: z.ZodArray<z.ZodEffects<z.ZodObject<{
+        recordId: z.ZodEffects<z.ZodString, string, string>;
+        sourceNamespace: z.ZodEffects<z.ZodString, string, string>;
+        claimId: z.ZodEffects<z.ZodString, string, string>;
+        grain: z.ZodEnum<["claim-snapshot", "claim-component-snapshot", "transaction"]>;
+        componentId: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+        accidentDate: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+        reportDate: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+        evaluationDate: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+        effectiveDate: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+        measures: z.ZodRecord<z.ZodEffects<z.ZodString, string, string>, z.ZodUnion<[z.ZodNumber, z.ZodNull]>>;
+        status: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+        dimensions: z.ZodOptional<z.ZodRecord<z.ZodEffects<z.ZodString, string, string>, z.ZodUnion<[z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>, z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>, "many">]>>>;
+        relationships: z.ZodOptional<z.ZodObject<{
+            claimantIds: z.ZodOptional<z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">>;
+            occurrenceId: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+            policyIds: z.ZodOptional<z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">>;
+            coverageIds: z.ZodOptional<z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">>;
+        }, "strict", z.ZodTypeAny, {
+            claimantIds?: string[] | undefined;
+            occurrenceId?: string | undefined;
+            policyIds?: string[] | undefined;
+            coverageIds?: string[] | undefined;
+        }, {
+            claimantIds?: string[] | undefined;
+            occurrenceId?: string | undefined;
+            policyIds?: string[] | undefined;
+            coverageIds?: string[] | undefined;
+        }>>;
+        completeness: z.ZodEnum<["complete-snapshot", "partial-snapshot", "change-only"]>;
+        revision: z.ZodObject<{
+            id: z.ZodEffects<z.ZodString, string, string>;
+            action: z.ZodEnum<["upsert", "delete"]>;
+            sequence: z.ZodOptional<z.ZodNumber>;
+            correctedAt: z.ZodOptional<z.ZodString>;
+        }, "strict", z.ZodTypeAny, {
+            id: string;
+            action: "upsert" | "delete";
+            sequence?: number | undefined;
+            correctedAt?: string | undefined;
+        }, {
+            id: string;
+            action: "upsert" | "delete";
+            sequence?: number | undefined;
+            correctedAt?: string | undefined;
+        }>;
+        source: z.ZodObject<{
+            artifactId: z.ZodEffects<z.ZodString, string, string>;
+            sourceFile: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+            sourceSheet: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+            sourceRow: z.ZodOptional<z.ZodNumber>;
+        }, "strict", z.ZodTypeAny, {
+            artifactId: string;
+            sourceFile?: string | undefined;
+            sourceSheet?: string | undefined;
+            sourceRow?: number | undefined;
+        }, {
+            artifactId: string;
+            sourceFile?: string | undefined;
+            sourceSheet?: string | undefined;
+            sourceRow?: number | undefined;
+        }>;
+    }, "strict", z.ZodTypeAny, {
+        claimId: string;
+        revision: {
+            id: string;
+            action: "upsert" | "delete";
+            sequence?: number | undefined;
+            correctedAt?: string | undefined;
+        };
+        source: {
+            artifactId: string;
+            sourceFile?: string | undefined;
+            sourceSheet?: string | undefined;
+            sourceRow?: number | undefined;
+        };
+        recordId: string;
+        sourceNamespace: string;
+        grain: "claim-snapshot" | "claim-component-snapshot" | "transaction";
+        measures: Record<string, number | null>;
+        completeness: "complete-snapshot" | "partial-snapshot" | "change-only";
+        status?: string | undefined;
+        evaluationDate?: string | undefined;
+        dimensions?: Record<string, string | number | boolean | (string | number | boolean | null)[] | null> | undefined;
+        effectiveDate?: string | undefined;
+        componentId?: string | undefined;
+        accidentDate?: string | undefined;
+        reportDate?: string | undefined;
+        relationships?: {
+            claimantIds?: string[] | undefined;
+            occurrenceId?: string | undefined;
+            policyIds?: string[] | undefined;
+            coverageIds?: string[] | undefined;
+        } | undefined;
+    }, {
+        claimId: string;
+        revision: {
+            id: string;
+            action: "upsert" | "delete";
+            sequence?: number | undefined;
+            correctedAt?: string | undefined;
+        };
+        source: {
+            artifactId: string;
+            sourceFile?: string | undefined;
+            sourceSheet?: string | undefined;
+            sourceRow?: number | undefined;
+        };
+        recordId: string;
+        sourceNamespace: string;
+        grain: "claim-snapshot" | "claim-component-snapshot" | "transaction";
+        measures: Record<string, number | null>;
+        completeness: "complete-snapshot" | "partial-snapshot" | "change-only";
+        status?: string | undefined;
+        evaluationDate?: string | undefined;
+        dimensions?: Record<string, string | number | boolean | (string | number | boolean | null)[] | null> | undefined;
+        effectiveDate?: string | undefined;
+        componentId?: string | undefined;
+        accidentDate?: string | undefined;
+        reportDate?: string | undefined;
+        relationships?: {
+            claimantIds?: string[] | undefined;
+            occurrenceId?: string | undefined;
+            policyIds?: string[] | undefined;
+            coverageIds?: string[] | undefined;
+        } | undefined;
+    }>, {
+        claimId: string;
+        revision: {
+            id: string;
+            action: "upsert" | "delete";
+            sequence?: number | undefined;
+            correctedAt?: string | undefined;
+        };
+        source: {
+            artifactId: string;
+            sourceFile?: string | undefined;
+            sourceSheet?: string | undefined;
+            sourceRow?: number | undefined;
+        };
+        recordId: string;
+        sourceNamespace: string;
+        grain: "claim-snapshot" | "claim-component-snapshot" | "transaction";
+        measures: Record<string, number | null>;
+        completeness: "complete-snapshot" | "partial-snapshot" | "change-only";
+        status?: string | undefined;
+        evaluationDate?: string | undefined;
+        dimensions?: Record<string, string | number | boolean | (string | number | boolean | null)[] | null> | undefined;
+        effectiveDate?: string | undefined;
+        componentId?: string | undefined;
+        accidentDate?: string | undefined;
+        reportDate?: string | undefined;
+        relationships?: {
+            claimantIds?: string[] | undefined;
+            occurrenceId?: string | undefined;
+            policyIds?: string[] | undefined;
+            coverageIds?: string[] | undefined;
+        } | undefined;
+    }, {
+        claimId: string;
+        revision: {
+            id: string;
+            action: "upsert" | "delete";
+            sequence?: number | undefined;
+            correctedAt?: string | undefined;
+        };
+        source: {
+            artifactId: string;
+            sourceFile?: string | undefined;
+            sourceSheet?: string | undefined;
+            sourceRow?: number | undefined;
+        };
+        recordId: string;
+        sourceNamespace: string;
+        grain: "claim-snapshot" | "claim-component-snapshot" | "transaction";
+        measures: Record<string, number | null>;
+        completeness: "complete-snapshot" | "partial-snapshot" | "change-only";
+        status?: string | undefined;
+        evaluationDate?: string | undefined;
+        dimensions?: Record<string, string | number | boolean | (string | number | boolean | null)[] | null> | undefined;
+        effectiveDate?: string | undefined;
+        componentId?: string | undefined;
+        accidentDate?: string | undefined;
+        reportDate?: string | undefined;
+        relationships?: {
+            claimantIds?: string[] | undefined;
+            occurrenceId?: string | undefined;
+            policyIds?: string[] | undefined;
+            coverageIds?: string[] | undefined;
+        } | undefined;
+    }>, "many">;
+}, "strict", z.ZodTypeAny, {
+    sources: {
+        artifactId: string;
+        namespace: string;
+        mappingVersion: string;
+    }[];
+    revisionView: {
+        kind: "as-known";
+        knowledgeCutoff: string;
+    } | {
+        kind: "restated";
+    };
+    revisionPrecedence: "sequence" | "corrected-at";
+    historyContractVersion: "actuarial-history/1";
+    datasetId: string;
+    historyMode: "full-snapshots" | "changes" | "mixed";
+    missingSnapshotRecord: "unknown" | "carried-forward";
+    records: {
+        claimId: string;
+        revision: {
+            id: string;
+            action: "upsert" | "delete";
+            sequence?: number | undefined;
+            correctedAt?: string | undefined;
+        };
+        source: {
+            artifactId: string;
+            sourceFile?: string | undefined;
+            sourceSheet?: string | undefined;
+            sourceRow?: number | undefined;
+        };
+        recordId: string;
+        sourceNamespace: string;
+        grain: "claim-snapshot" | "claim-component-snapshot" | "transaction";
+        measures: Record<string, number | null>;
+        completeness: "complete-snapshot" | "partial-snapshot" | "change-only";
+        status?: string | undefined;
+        evaluationDate?: string | undefined;
+        dimensions?: Record<string, string | number | boolean | (string | number | boolean | null)[] | null> | undefined;
+        effectiveDate?: string | undefined;
+        componentId?: string | undefined;
+        accidentDate?: string | undefined;
+        reportDate?: string | undefined;
+        relationships?: {
+            claimantIds?: string[] | undefined;
+            occurrenceId?: string | undefined;
+            policyIds?: string[] | undefined;
+            coverageIds?: string[] | undefined;
+        } | undefined;
+    }[];
+    evaluationDates?: string[] | undefined;
+    openingBalances?: {
+        claimId: string;
+        source: {
+            artifactId: string;
+            sourceFile?: string | undefined;
+            sourceSheet?: string | undefined;
+            sourceRow?: number | undefined;
+        };
+        sourceNamespace: string;
+        measures: Record<string, number>;
+        asOfDate: string;
+    }[] | undefined;
+}, {
+    sources: {
+        artifactId: string;
+        namespace: string;
+        mappingVersion: string;
+    }[];
+    revisionView: {
+        kind: "as-known";
+        knowledgeCutoff: string;
+    } | {
+        kind: "restated";
+    };
+    revisionPrecedence: "sequence" | "corrected-at";
+    historyContractVersion: "actuarial-history/1";
+    datasetId: string;
+    historyMode: "full-snapshots" | "changes" | "mixed";
+    missingSnapshotRecord: "unknown" | "carried-forward";
+    records: {
+        claimId: string;
+        revision: {
+            id: string;
+            action: "upsert" | "delete";
+            sequence?: number | undefined;
+            correctedAt?: string | undefined;
+        };
+        source: {
+            artifactId: string;
+            sourceFile?: string | undefined;
+            sourceSheet?: string | undefined;
+            sourceRow?: number | undefined;
+        };
+        recordId: string;
+        sourceNamespace: string;
+        grain: "claim-snapshot" | "claim-component-snapshot" | "transaction";
+        measures: Record<string, number | null>;
+        completeness: "complete-snapshot" | "partial-snapshot" | "change-only";
+        status?: string | undefined;
+        evaluationDate?: string | undefined;
+        dimensions?: Record<string, string | number | boolean | (string | number | boolean | null)[] | null> | undefined;
+        effectiveDate?: string | undefined;
+        componentId?: string | undefined;
+        accidentDate?: string | undefined;
+        reportDate?: string | undefined;
+        relationships?: {
+            claimantIds?: string[] | undefined;
+            occurrenceId?: string | undefined;
+            policyIds?: string[] | undefined;
+            coverageIds?: string[] | undefined;
+        } | undefined;
+    }[];
+    evaluationDates?: string[] | undefined;
+    openingBalances?: {
+        claimId: string;
+        source: {
+            artifactId: string;
+            sourceFile?: string | undefined;
+            sourceSheet?: string | undefined;
+            sourceRow?: number | undefined;
+        };
+        sourceNamespace: string;
+        measures: Record<string, number>;
+        asOfDate: string;
+    }[] | undefined;
+}>, {
+    sources: {
+        artifactId: string;
+        namespace: string;
+        mappingVersion: string;
+    }[];
+    revisionView: {
+        kind: "as-known";
+        knowledgeCutoff: string;
+    } | {
+        kind: "restated";
+    };
+    revisionPrecedence: "sequence" | "corrected-at";
+    historyContractVersion: "actuarial-history/1";
+    datasetId: string;
+    historyMode: "full-snapshots" | "changes" | "mixed";
+    missingSnapshotRecord: "unknown" | "carried-forward";
+    records: {
+        claimId: string;
+        revision: {
+            id: string;
+            action: "upsert" | "delete";
+            sequence?: number | undefined;
+            correctedAt?: string | undefined;
+        };
+        source: {
+            artifactId: string;
+            sourceFile?: string | undefined;
+            sourceSheet?: string | undefined;
+            sourceRow?: number | undefined;
+        };
+        recordId: string;
+        sourceNamespace: string;
+        grain: "claim-snapshot" | "claim-component-snapshot" | "transaction";
+        measures: Record<string, number | null>;
+        completeness: "complete-snapshot" | "partial-snapshot" | "change-only";
+        status?: string | undefined;
+        evaluationDate?: string | undefined;
+        dimensions?: Record<string, string | number | boolean | (string | number | boolean | null)[] | null> | undefined;
+        effectiveDate?: string | undefined;
+        componentId?: string | undefined;
+        accidentDate?: string | undefined;
+        reportDate?: string | undefined;
+        relationships?: {
+            claimantIds?: string[] | undefined;
+            occurrenceId?: string | undefined;
+            policyIds?: string[] | undefined;
+            coverageIds?: string[] | undefined;
+        } | undefined;
+    }[];
+    evaluationDates?: string[] | undefined;
+    openingBalances?: {
+        claimId: string;
+        source: {
+            artifactId: string;
+            sourceFile?: string | undefined;
+            sourceSheet?: string | undefined;
+            sourceRow?: number | undefined;
+        };
+        sourceNamespace: string;
+        measures: Record<string, number>;
+        asOfDate: string;
+    }[] | undefined;
+}, {
+    sources: {
+        artifactId: string;
+        namespace: string;
+        mappingVersion: string;
+    }[];
+    revisionView: {
+        kind: "as-known";
+        knowledgeCutoff: string;
+    } | {
+        kind: "restated";
+    };
+    revisionPrecedence: "sequence" | "corrected-at";
+    historyContractVersion: "actuarial-history/1";
+    datasetId: string;
+    historyMode: "full-snapshots" | "changes" | "mixed";
+    missingSnapshotRecord: "unknown" | "carried-forward";
+    records: {
+        claimId: string;
+        revision: {
+            id: string;
+            action: "upsert" | "delete";
+            sequence?: number | undefined;
+            correctedAt?: string | undefined;
+        };
+        source: {
+            artifactId: string;
+            sourceFile?: string | undefined;
+            sourceSheet?: string | undefined;
+            sourceRow?: number | undefined;
+        };
+        recordId: string;
+        sourceNamespace: string;
+        grain: "claim-snapshot" | "claim-component-snapshot" | "transaction";
+        measures: Record<string, number | null>;
+        completeness: "complete-snapshot" | "partial-snapshot" | "change-only";
+        status?: string | undefined;
+        evaluationDate?: string | undefined;
+        dimensions?: Record<string, string | number | boolean | (string | number | boolean | null)[] | null> | undefined;
+        effectiveDate?: string | undefined;
+        componentId?: string | undefined;
+        accidentDate?: string | undefined;
+        reportDate?: string | undefined;
+        relationships?: {
+            claimantIds?: string[] | undefined;
+            occurrenceId?: string | undefined;
+            policyIds?: string[] | undefined;
+            coverageIds?: string[] | undefined;
+        } | undefined;
+    }[];
+    evaluationDates?: string[] | undefined;
+    openingBalances?: {
+        claimId: string;
+        source: {
+            artifactId: string;
+            sourceFile?: string | undefined;
+            sourceSheet?: string | undefined;
+            sourceRow?: number | undefined;
+        };
+        sourceNamespace: string;
+        measures: Record<string, number>;
+        asOfDate: string;
+    }[] | undefined;
+}>;
+export declare const analysisDefinitionSchema: z.ZodEffects<z.ZodObject<{
+    analysisContractVersion: z.ZodLiteral<"actuarial-analysis/1">;
+    id: z.ZodEffects<z.ZodString, string, string>;
+    version: z.ZodEffects<z.ZodString, string, string>;
+    dimensions: z.ZodArray<z.ZodObject<{
+        id: z.ZodEffects<z.ZodString, string, string>;
+        type: z.ZodEnum<["string", "number", "boolean", "date", "entity-reference"]>;
+        multiple: z.ZodBoolean;
+    }, "strict", z.ZodTypeAny, {
+        type: "string" | "number" | "boolean" | "date" | "entity-reference";
+        id: string;
+        multiple: boolean;
+    }, {
+        type: "string" | "number" | "boolean" | "date" | "entity-reference";
+        id: string;
+        multiple: boolean;
+    }>, "many">;
+    scopes: z.ZodObject<{
+        financial: z.ZodObject<{
+            id: z.ZodEffects<z.ZodString, string, string>;
+            subject: z.ZodEnum<["claim", "claimant", "occurrence", "policy", "coverage"]>;
+            predicate: z.ZodType<AnalysisPredicate, z.ZodTypeDef, AnalysisPredicate>;
+            classification: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+                kind: z.ZodLiteral<"as-observed">;
+            }, "strict", z.ZodTypeAny, {
+                kind: "as-observed";
+            }, {
+                kind: "as-observed";
+            }>, z.ZodObject<{
+                kind: z.ZodLiteral<"latest-as-of-analysis">;
+                asOfDate: z.ZodEffects<z.ZodString, string, string>;
+            }, "strict", z.ZodTypeAny, {
+                kind: "latest-as-of-analysis";
+                asOfDate: string;
+            }, {
+                kind: "latest-as-of-analysis";
+                asOfDate: string;
+            }>, z.ZodObject<{
+                kind: z.ZodLiteral<"frozen-cohort">;
+                asOfDate: z.ZodEffects<z.ZodString, string, string>;
+            }, "strict", z.ZodTypeAny, {
+                kind: "frozen-cohort";
+                asOfDate: string;
+            }, {
+                kind: "frozen-cohort";
+                asOfDate: string;
+            }>]>;
+        }, "strict", z.ZodTypeAny, {
+            id: string;
+            subject: "claim" | "claimant" | "occurrence" | "policy" | "coverage";
+            predicate: AnalysisPredicate;
+            classification: {
+                kind: "as-observed";
+            } | {
+                kind: "latest-as-of-analysis";
+                asOfDate: string;
+            } | {
+                kind: "frozen-cohort";
+                asOfDate: string;
+            };
+        }, {
+            id: string;
+            subject: "claim" | "claimant" | "occurrence" | "policy" | "coverage";
+            predicate: AnalysisPredicate;
+            classification: {
+                kind: "as-observed";
+            } | {
+                kind: "latest-as-of-analysis";
+                asOfDate: string;
+            } | {
+                kind: "frozen-cohort";
+                asOfDate: string;
+            };
+        }>;
+        reporting: z.ZodObject<{
+            id: z.ZodEffects<z.ZodString, string, string>;
+            subject: z.ZodEnum<["claim", "claimant", "occurrence", "policy", "coverage"]>;
+            predicate: z.ZodType<AnalysisPredicate, z.ZodTypeDef, AnalysisPredicate>;
+            classification: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+                kind: z.ZodLiteral<"as-observed">;
+            }, "strict", z.ZodTypeAny, {
+                kind: "as-observed";
+            }, {
+                kind: "as-observed";
+            }>, z.ZodObject<{
+                kind: z.ZodLiteral<"latest-as-of-analysis">;
+                asOfDate: z.ZodEffects<z.ZodString, string, string>;
+            }, "strict", z.ZodTypeAny, {
+                kind: "latest-as-of-analysis";
+                asOfDate: string;
+            }, {
+                kind: "latest-as-of-analysis";
+                asOfDate: string;
+            }>, z.ZodObject<{
+                kind: z.ZodLiteral<"frozen-cohort">;
+                asOfDate: z.ZodEffects<z.ZodString, string, string>;
+            }, "strict", z.ZodTypeAny, {
+                kind: "frozen-cohort";
+                asOfDate: string;
+            }, {
+                kind: "frozen-cohort";
+                asOfDate: string;
+            }>]>;
+        }, "strict", z.ZodTypeAny, {
+            id: string;
+            subject: "claim" | "claimant" | "occurrence" | "policy" | "coverage";
+            predicate: AnalysisPredicate;
+            classification: {
+                kind: "as-observed";
+            } | {
+                kind: "latest-as-of-analysis";
+                asOfDate: string;
+            } | {
+                kind: "frozen-cohort";
+                asOfDate: string;
+            };
+        }, {
+            id: string;
+            subject: "claim" | "claimant" | "occurrence" | "policy" | "coverage";
+            predicate: AnalysisPredicate;
+            classification: {
+                kind: "as-observed";
+            } | {
+                kind: "latest-as-of-analysis";
+                asOfDate: string;
+            } | {
+                kind: "frozen-cohort";
+                asOfDate: string;
+            };
+        }>;
+        exposure: z.ZodArray<z.ZodObject<{
+            id: z.ZodEffects<z.ZodString, string, string>;
+            populationKeys: z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">;
+            timeBasis: z.ZodEnum<["interval", "point-in-time", "already-earned"]>;
+            reportingFilterEffect: z.ZodEnum<["none", "matching-exposure-dimensions"]>;
+            valuationSelection: z.ZodOptional<z.ZodEnum<["origin-static", "exact", "latest-on-or-before"]>>;
+        }, "strict", z.ZodTypeAny, {
+            id: string;
+            populationKeys: string[];
+            timeBasis: "interval" | "point-in-time" | "already-earned";
+            reportingFilterEffect: "none" | "matching-exposure-dimensions";
+            valuationSelection?: "exact" | "origin-static" | "latest-on-or-before" | undefined;
+        }, {
+            id: string;
+            populationKeys: string[];
+            timeBasis: "interval" | "point-in-time" | "already-earned";
+            reportingFilterEffect: "none" | "matching-exposure-dimensions";
+            valuationSelection?: "exact" | "origin-static" | "latest-on-or-before" | undefined;
+        }>, "many">;
+    }, "strict", z.ZodTypeAny, {
+        financial: {
+            id: string;
+            subject: "claim" | "claimant" | "occurrence" | "policy" | "coverage";
+            predicate: AnalysisPredicate;
+            classification: {
+                kind: "as-observed";
+            } | {
+                kind: "latest-as-of-analysis";
+                asOfDate: string;
+            } | {
+                kind: "frozen-cohort";
+                asOfDate: string;
+            };
+        };
+        reporting: {
+            id: string;
+            subject: "claim" | "claimant" | "occurrence" | "policy" | "coverage";
+            predicate: AnalysisPredicate;
+            classification: {
+                kind: "as-observed";
+            } | {
+                kind: "latest-as-of-analysis";
+                asOfDate: string;
+            } | {
+                kind: "frozen-cohort";
+                asOfDate: string;
+            };
+        };
+        exposure: {
+            id: string;
+            populationKeys: string[];
+            timeBasis: "interval" | "point-in-time" | "already-earned";
+            reportingFilterEffect: "none" | "matching-exposure-dimensions";
+            valuationSelection?: "exact" | "origin-static" | "latest-on-or-before" | undefined;
+        }[];
+    }, {
+        financial: {
+            id: string;
+            subject: "claim" | "claimant" | "occurrence" | "policy" | "coverage";
+            predicate: AnalysisPredicate;
+            classification: {
+                kind: "as-observed";
+            } | {
+                kind: "latest-as-of-analysis";
+                asOfDate: string;
+            } | {
+                kind: "frozen-cohort";
+                asOfDate: string;
+            };
+        };
+        reporting: {
+            id: string;
+            subject: "claim" | "claimant" | "occurrence" | "policy" | "coverage";
+            predicate: AnalysisPredicate;
+            classification: {
+                kind: "as-observed";
+            } | {
+                kind: "latest-as-of-analysis";
+                asOfDate: string;
+            } | {
+                kind: "frozen-cohort";
+                asOfDate: string;
+            };
+        };
+        exposure: {
+            id: string;
+            populationKeys: string[];
+            timeBasis: "interval" | "point-in-time" | "already-earned";
+            reportingFilterEffect: "none" | "matching-exposure-dimensions";
+            valuationSelection?: "exact" | "origin-static" | "latest-on-or-before" | undefined;
+        }[];
+    }>;
+    policySchedule: z.ZodArray<z.ZodEffects<z.ZodObject<{
+        id: z.ZodEffects<z.ZodString, string, string>;
+        label: z.ZodEffects<z.ZodString, string, string>;
+        scope: z.ZodRecord<z.ZodEffects<z.ZodString, string, string>, z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>;
+        startDate: z.ZodEffects<z.ZodString, string, string>;
+        endDate: z.ZodEffects<z.ZodString, string, string>;
+        revisionId: z.ZodEffects<z.ZodString, string, string>;
+    }, "strict", z.ZodTypeAny, {
+        id: string;
+        startDate: string;
+        endDate: string;
+        revisionId: string;
+        label: string;
+        scope: Record<string, string | number | boolean | null>;
+    }, {
+        id: string;
+        startDate: string;
+        endDate: string;
+        revisionId: string;
+        label: string;
+        scope: Record<string, string | number | boolean | null>;
+    }>, {
+        id: string;
+        startDate: string;
+        endDate: string;
+        revisionId: string;
+        label: string;
+        scope: Record<string, string | number | boolean | null>;
+    }, {
+        id: string;
+        startDate: string;
+        endDate: string;
+        revisionId: string;
+        label: string;
+        scope: Record<string, string | number | boolean | null>;
+    }>, "many">;
+    period: z.ZodObject<{
+        originBasis: z.ZodEnum<["accident", "report", "policy"]>;
+        grouping: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+            kind: z.ZodLiteral<"calendar">;
+            cadence: z.ZodEnum<["month", "quarter", "year"]>;
+        }, "strict", z.ZodTypeAny, {
+            kind: "calendar";
+            cadence: "year" | "month" | "quarter";
+        }, {
+            kind: "calendar";
+            cadence: "year" | "month" | "quarter";
+        }>, z.ZodObject<{
+            kind: z.ZodLiteral<"fiscal">;
+            cadence: z.ZodEnum<["quarter", "year"]>;
+            startMonth: z.ZodNumber;
+        }, "strict", z.ZodTypeAny, {
+            kind: "fiscal";
+            cadence: "year" | "quarter";
+            startMonth: number;
+        }, {
+            kind: "fiscal";
+            cadence: "year" | "quarter";
+            startMonth: number;
+        }>, z.ZodObject<{
+            kind: z.ZodLiteral<"policy-schedule">;
+            periodIds: z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">;
+        }, "strict", z.ZodTypeAny, {
+            kind: "policy-schedule";
+            periodIds: string[];
+        }, {
+            kind: "policy-schedule";
+            periodIds: string[];
+        }>]>;
+        comparisonClock: z.ZodEnum<["common-evaluation-date", "since-period-start", "since-period-end", "matched-accident-cohorts"]>;
+        ageConvention: z.ZodEnum<["exact-days", "calendar-months"]>;
+        observationSelection: z.ZodEnum<["exact", "latest-on-or-before"]>;
+    }, "strict", z.ZodTypeAny, {
+        originBasis: "policy" | "accident" | "report";
+        grouping: {
+            kind: "calendar";
+            cadence: "year" | "month" | "quarter";
+        } | {
+            kind: "fiscal";
+            cadence: "year" | "quarter";
+            startMonth: number;
+        } | {
+            kind: "policy-schedule";
+            periodIds: string[];
+        };
+        comparisonClock: "common-evaluation-date" | "since-period-start" | "since-period-end" | "matched-accident-cohorts";
+        ageConvention: "exact-days" | "calendar-months";
+        observationSelection: "exact" | "latest-on-or-before";
+    }, {
+        originBasis: "policy" | "accident" | "report";
+        grouping: {
+            kind: "calendar";
+            cadence: "year" | "month" | "quarter";
+        } | {
+            kind: "fiscal";
+            cadence: "year" | "quarter";
+            startMonth: number;
+        } | {
+            kind: "policy-schedule";
+            periodIds: string[];
+        };
+        comparisonClock: "common-evaluation-date" | "since-period-start" | "since-period-end" | "matched-accident-cohorts";
+        ageConvention: "exact-days" | "calendar-months";
+        observationSelection: "exact" | "latest-on-or-before";
+    }>;
+    exposures: z.ZodArray<z.ZodObject<{
+        id: z.ZodEffects<z.ZodString, string, string>;
+        unit: z.ZodEffects<z.ZodString, string, string>;
+        sourceMeaning: z.ZodEnum<["already-earned", "written-over-interval", "flow-over-interval", "point-in-time"]>;
+        earning: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+            kind: z.ZodLiteral<"supplied">;
+        }, "strict", z.ZodTypeAny, {
+            kind: "supplied";
+        }, {
+            kind: "supplied";
+        }>, z.ZodObject<{
+            kind: z.ZodLiteral<"uniform-daily">;
+            dayCount: z.ZodLiteral<"actual-days">;
+        }, "strict", z.ZodTypeAny, {
+            kind: "uniform-daily";
+            dayCount: "actual-days";
+        }, {
+            kind: "uniform-daily";
+            dayCount: "actual-days";
+        }>, z.ZodObject<{
+            kind: z.ZodLiteral<"weighted">;
+            scheduleId: z.ZodEffects<z.ZodString, string, string>;
+        }, "strict", z.ZodTypeAny, {
+            kind: "weighted";
+            scheduleId: string;
+        }, {
+            kind: "weighted";
+            scheduleId: string;
+        }>]>;
+        allocation: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+            kind: z.ZodLiteral<"exact-match">;
+        }, "strict", z.ZodTypeAny, {
+            kind: "exact-match";
+        }, {
+            kind: "exact-match";
+        }>, z.ZodObject<{
+            kind: z.ZodLiteral<"time-overlap">;
+        }, "strict", z.ZodTypeAny, {
+            kind: "time-overlap";
+        }, {
+            kind: "time-overlap";
+        }>, z.ZodObject<{
+            kind: z.ZodLiteral<"supplied-weights">;
+            weightMeasureId: z.ZodEffects<z.ZodString, string, string>;
+        }, "strict", z.ZodTypeAny, {
+            kind: "supplied-weights";
+            weightMeasureId: string;
+        }, {
+            kind: "supplied-weights";
+            weightMeasureId: string;
+        }>]>;
+        scopeId: z.ZodEffects<z.ZodString, string, string>;
+    }, "strict", z.ZodTypeAny, {
+        id: string;
+        unit: string;
+        allocation: {
+            kind: "exact-match";
+        } | {
+            kind: "time-overlap";
+        } | {
+            kind: "supplied-weights";
+            weightMeasureId: string;
+        };
+        sourceMeaning: "point-in-time" | "already-earned" | "written-over-interval" | "flow-over-interval";
+        earning: {
+            kind: "supplied";
+        } | {
+            kind: "uniform-daily";
+            dayCount: "actual-days";
+        } | {
+            kind: "weighted";
+            scheduleId: string;
+        };
+        scopeId: string;
+    }, {
+        id: string;
+        unit: string;
+        allocation: {
+            kind: "exact-match";
+        } | {
+            kind: "time-overlap";
+        } | {
+            kind: "supplied-weights";
+            weightMeasureId: string;
+        };
+        sourceMeaning: "point-in-time" | "already-earned" | "written-over-interval" | "flow-over-interval";
+        earning: {
+            kind: "supplied";
+        } | {
+            kind: "uniform-daily";
+            dayCount: "actual-days";
+        } | {
+            kind: "weighted";
+            scheduleId: string;
+        };
+        scopeId: string;
+    }>, "many">;
+    measures: z.ZodArray<z.ZodObject<{
+        id: z.ZodEffects<z.ZodString, string, string>;
+        unit: z.ZodEffects<z.ZodString, string, string>;
+        developmentSemantics: z.ZodEnum<["cumulative", "incremental", "point-in-time"]>;
+        statistic: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+            kind: z.ZodLiteral<"sum">;
+            measureId: z.ZodEffects<z.ZodString, string, string>;
+        }, "strict", z.ZodTypeAny, {
+            measureId: string;
+            kind: "sum";
+        }, {
+            measureId: string;
+            kind: "sum";
+        }>, z.ZodObject<{
+            kind: z.ZodLiteral<"ratio">;
+            numeratorMeasureId: z.ZodEffects<z.ZodString, string, string>;
+            denominatorMeasureId: z.ZodEffects<z.ZodString, string, string>;
+            scale: z.ZodNumber;
+            denominatorRule: z.ZodEnum<["positive", "nonzero"]>;
+        }, "strict", z.ZodTypeAny, {
+            kind: "ratio";
+            numeratorMeasureId: string;
+            denominatorMeasureId: string;
+            scale: number;
+            denominatorRule: "positive" | "nonzero";
+        }, {
+            kind: "ratio";
+            numeratorMeasureId: string;
+            denominatorMeasureId: string;
+            scale: number;
+            denominatorRule: "positive" | "nonzero";
+        }>, z.ZodObject<{
+            kind: z.ZodLiteral<"distinct-count">;
+            entity: z.ZodEnum<["claim", "claimant", "occurrence", "policy", "coverage"]>;
+        }, "strict", z.ZodTypeAny, {
+            kind: "distinct-count";
+            entity: "claim" | "claimant" | "occurrence" | "policy" | "coverage";
+        }, {
+            kind: "distinct-count";
+            entity: "claim" | "claimant" | "occurrence" | "policy" | "coverage";
+        }>, z.ZodObject<{
+            kind: z.ZodLiteral<"weighted-mean">;
+            measureId: z.ZodEffects<z.ZodString, string, string>;
+            weightMeasureId: z.ZodEffects<z.ZodString, string, string>;
+        }, "strict", z.ZodTypeAny, {
+            measureId: string;
+            kind: "weighted-mean";
+            weightMeasureId: string;
+        }, {
+            measureId: string;
+            kind: "weighted-mean";
+            weightMeasureId: string;
+        }>, z.ZodObject<{
+            kind: z.ZodEnum<["minimum", "maximum"]>;
+            measureId: z.ZodEffects<z.ZodString, string, string>;
+        }, "strict", z.ZodTypeAny, {
+            measureId: string;
+            kind: "minimum" | "maximum";
+        }, {
+            measureId: string;
+            kind: "minimum" | "maximum";
+        }>, z.ZodObject<{
+            kind: z.ZodLiteral<"quantile">;
+            measureId: z.ZodEffects<z.ZodString, string, string>;
+            probability: z.ZodNumber;
+            method: z.ZodLiteral<"hf-type-7">;
+        }, "strict", z.ZodTypeAny, {
+            measureId: string;
+            kind: "quantile";
+            probability: number;
+            method: "hf-type-7";
+        }, {
+            measureId: string;
+            kind: "quantile";
+            probability: number;
+            method: "hf-type-7";
+        }>, z.ZodObject<{
+            kind: z.ZodLiteral<"duration">;
+            start: z.ZodEnum<["accident-date", "report-date"]>;
+            end: z.ZodEnum<["report-date", "closed-date", "evaluation-date"]>;
+            unit: z.ZodLiteral<"days">;
+            population: z.ZodEnum<["all-with-observed-endpoint", "closed-only"]>;
+        }, "strict", z.ZodTypeAny, {
+            kind: "duration";
+            start: "accident-date" | "report-date";
+            end: "report-date" | "closed-date" | "evaluation-date";
+            unit: "days";
+            population: "all-with-observed-endpoint" | "closed-only";
+        }, {
+            kind: "duration";
+            start: "accident-date" | "report-date";
+            end: "report-date" | "closed-date" | "evaluation-date";
+            unit: "days";
+            population: "all-with-observed-endpoint" | "closed-only";
+        }>, z.ZodObject<{
+            kind: z.ZodLiteral<"survival-quantile">;
+            start: z.ZodEnum<["accident-date", "report-date"]>;
+            event: z.ZodLiteral<"closed-date">;
+            censor: z.ZodLiteral<"evaluation-date">;
+            unit: z.ZodLiteral<"days">;
+            probability: z.ZodNumber;
+            method: z.ZodLiteral<"kaplan-meier-product-limit">;
+        }, "strict", z.ZodTypeAny, {
+            kind: "survival-quantile";
+            probability: number;
+            method: "kaplan-meier-product-limit";
+            start: "accident-date" | "report-date";
+            unit: "days";
+            event: "closed-date";
+            censor: "evaluation-date";
+        }, {
+            kind: "survival-quantile";
+            probability: number;
+            method: "kaplan-meier-product-limit";
+            start: "accident-date" | "report-date";
+            unit: "days";
+            event: "closed-date";
+            censor: "evaluation-date";
+        }>]>;
+        populationScopeId: z.ZodEffects<z.ZodString, string, string>;
+        condition: z.ZodOptional<z.ZodType<AnalysisPredicate, z.ZodTypeDef, AnalysisPredicate>>;
+    }, "strict", z.ZodTypeAny, {
+        id: string;
+        unit: string;
+        developmentSemantics: "point-in-time" | "cumulative" | "incremental";
+        statistic: {
+            measureId: string;
+            kind: "sum";
+        } | {
+            kind: "ratio";
+            numeratorMeasureId: string;
+            denominatorMeasureId: string;
+            scale: number;
+            denominatorRule: "positive" | "nonzero";
+        } | {
+            kind: "distinct-count";
+            entity: "claim" | "claimant" | "occurrence" | "policy" | "coverage";
+        } | {
+            measureId: string;
+            kind: "weighted-mean";
+            weightMeasureId: string;
+        } | {
+            measureId: string;
+            kind: "minimum" | "maximum";
+        } | {
+            measureId: string;
+            kind: "quantile";
+            probability: number;
+            method: "hf-type-7";
+        } | {
+            kind: "duration";
+            start: "accident-date" | "report-date";
+            end: "report-date" | "closed-date" | "evaluation-date";
+            unit: "days";
+            population: "all-with-observed-endpoint" | "closed-only";
+        } | {
+            kind: "survival-quantile";
+            probability: number;
+            method: "kaplan-meier-product-limit";
+            start: "accident-date" | "report-date";
+            unit: "days";
+            event: "closed-date";
+            censor: "evaluation-date";
+        };
+        populationScopeId: string;
+        condition?: AnalysisPredicate | undefined;
+    }, {
+        id: string;
+        unit: string;
+        developmentSemantics: "point-in-time" | "cumulative" | "incremental";
+        statistic: {
+            measureId: string;
+            kind: "sum";
+        } | {
+            kind: "ratio";
+            numeratorMeasureId: string;
+            denominatorMeasureId: string;
+            scale: number;
+            denominatorRule: "positive" | "nonzero";
+        } | {
+            kind: "distinct-count";
+            entity: "claim" | "claimant" | "occurrence" | "policy" | "coverage";
+        } | {
+            measureId: string;
+            kind: "weighted-mean";
+            weightMeasureId: string;
+        } | {
+            measureId: string;
+            kind: "minimum" | "maximum";
+        } | {
+            measureId: string;
+            kind: "quantile";
+            probability: number;
+            method: "hf-type-7";
+        } | {
+            kind: "duration";
+            start: "accident-date" | "report-date";
+            end: "report-date" | "closed-date" | "evaluation-date";
+            unit: "days";
+            population: "all-with-observed-endpoint" | "closed-only";
+        } | {
+            kind: "survival-quantile";
+            probability: number;
+            method: "kaplan-meier-product-limit";
+            start: "accident-date" | "report-date";
+            unit: "days";
+            event: "closed-date";
+            censor: "evaluation-date";
+        };
+        populationScopeId: string;
+        condition?: AnalysisPredicate | undefined;
+    }>, "many">;
+    financialTerms: z.ZodArray<z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+        kind: z.ZodEnum<["claim-layer", "occurrence-layer"]>;
+        id: z.ZodEffects<z.ZodString, string, string>;
+        measureId: z.ZodEffects<z.ZodString, string, string>;
+        attachment: z.ZodNumber;
+        limit: z.ZodNullable<z.ZodNumber>;
+        allocation: z.ZodLiteral<"proportional">;
+    }, "strict", z.ZodTypeAny, {
+        measureId: string;
+        kind: "claim-layer" | "occurrence-layer";
+        id: string;
+        attachment: number;
+        limit: number | null;
+        allocation: "proportional";
+    }, {
+        measureId: string;
+        kind: "claim-layer" | "occurrence-layer";
+        id: string;
+        attachment: number;
+        limit: number | null;
+        allocation: "proportional";
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"policy-aggregate">;
+        id: z.ZodEffects<z.ZodString, string, string>;
+        measureId: z.ZodEffects<z.ZodString, string, string>;
+        deductible: z.ZodNumber;
+        limit: z.ZodNullable<z.ZodNumber>;
+        allocation: z.ZodEnum<["proportional", "chronological"]>;
+    }, "strict", z.ZodTypeAny, {
+        measureId: string;
+        kind: "policy-aggregate";
+        id: string;
+        limit: number | null;
+        allocation: "proportional" | "chronological";
+        deductible: number;
+    }, {
+        measureId: string;
+        kind: "policy-aggregate";
+        id: string;
+        limit: number | null;
+        allocation: "proportional" | "chronological";
+        deductible: number;
+    }>]>, "many">;
+    financialAdjustments: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+        kind: z.ZodLiteral<"scale">;
+        id: z.ZodEffects<z.ZodString, string, string>;
+        purpose: z.ZodEnum<["trend", "index"]>;
+        factor: z.ZodNumber;
+    }, "strict", z.ZodTypeAny, {
+        kind: "scale";
+        id: string;
+        purpose: "trend" | "index";
+        factor: number;
+    }, {
+        kind: "scale";
+        id: string;
+        purpose: "trend" | "index";
+        factor: number;
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"currency">;
+        id: z.ZodEffects<z.ZodString, string, string>;
+        fromUnit: z.ZodEffects<z.ZodString, string, string>;
+        toUnit: z.ZodEffects<z.ZodString, string, string>;
+        rate: z.ZodNumber;
+        rateDate: z.ZodEffects<z.ZodString, string, string>;
+    }, "strict", z.ZodTypeAny, {
+        kind: "currency";
+        id: string;
+        fromUnit: string;
+        toUnit: string;
+        rate: number;
+        rateDate: string;
+    }, {
+        kind: "currency";
+        id: string;
+        fromUnit: string;
+        toUnit: string;
+        rate: number;
+        rateDate: string;
+    }>, z.ZodObject<{
+        kind: z.ZodEnum<["include-expense", "exclude-expense"]>;
+        id: z.ZodEffects<z.ZodString, string, string>;
+        expenseMeasureId: z.ZodEffects<z.ZodString, string, string>;
+    }, "strict", z.ZodTypeAny, {
+        kind: "include-expense" | "exclude-expense";
+        id: string;
+        expenseMeasureId: string;
+    }, {
+        kind: "include-expense" | "exclude-expense";
+        id: string;
+        expenseMeasureId: string;
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"net-recovery">;
+        id: z.ZodEffects<z.ZodString, string, string>;
+        recoveryMeasureId: z.ZodEffects<z.ZodString, string, string>;
+    }, "strict", z.ZodTypeAny, {
+        kind: "net-recovery";
+        id: string;
+        recoveryMeasureId: string;
+    }, {
+        kind: "net-recovery";
+        id: string;
+        recoveryMeasureId: string;
+    }>]>, "many">>;
+}, "strict", z.ZodTypeAny, {
+    id: string;
+    dimensions: {
+        type: "string" | "number" | "boolean" | "date" | "entity-reference";
+        id: string;
+        multiple: boolean;
+    }[];
+    measures: {
+        id: string;
+        unit: string;
+        developmentSemantics: "point-in-time" | "cumulative" | "incremental";
+        statistic: {
+            measureId: string;
+            kind: "sum";
+        } | {
+            kind: "ratio";
+            numeratorMeasureId: string;
+            denominatorMeasureId: string;
+            scale: number;
+            denominatorRule: "positive" | "nonzero";
+        } | {
+            kind: "distinct-count";
+            entity: "claim" | "claimant" | "occurrence" | "policy" | "coverage";
+        } | {
+            measureId: string;
+            kind: "weighted-mean";
+            weightMeasureId: string;
+        } | {
+            measureId: string;
+            kind: "minimum" | "maximum";
+        } | {
+            measureId: string;
+            kind: "quantile";
+            probability: number;
+            method: "hf-type-7";
+        } | {
+            kind: "duration";
+            start: "accident-date" | "report-date";
+            end: "report-date" | "closed-date" | "evaluation-date";
+            unit: "days";
+            population: "all-with-observed-endpoint" | "closed-only";
+        } | {
+            kind: "survival-quantile";
+            probability: number;
+            method: "kaplan-meier-product-limit";
+            start: "accident-date" | "report-date";
+            unit: "days";
+            event: "closed-date";
+            censor: "evaluation-date";
+        };
+        populationScopeId: string;
+        condition?: AnalysisPredicate | undefined;
+    }[];
+    analysisContractVersion: "actuarial-analysis/1";
+    version: string;
+    scopes: {
+        financial: {
+            id: string;
+            subject: "claim" | "claimant" | "occurrence" | "policy" | "coverage";
+            predicate: AnalysisPredicate;
+            classification: {
+                kind: "as-observed";
+            } | {
+                kind: "latest-as-of-analysis";
+                asOfDate: string;
+            } | {
+                kind: "frozen-cohort";
+                asOfDate: string;
+            };
+        };
+        reporting: {
+            id: string;
+            subject: "claim" | "claimant" | "occurrence" | "policy" | "coverage";
+            predicate: AnalysisPredicate;
+            classification: {
+                kind: "as-observed";
+            } | {
+                kind: "latest-as-of-analysis";
+                asOfDate: string;
+            } | {
+                kind: "frozen-cohort";
+                asOfDate: string;
+            };
+        };
+        exposure: {
+            id: string;
+            populationKeys: string[];
+            timeBasis: "interval" | "point-in-time" | "already-earned";
+            reportingFilterEffect: "none" | "matching-exposure-dimensions";
+            valuationSelection?: "exact" | "origin-static" | "latest-on-or-before" | undefined;
+        }[];
+    };
+    policySchedule: {
+        id: string;
+        startDate: string;
+        endDate: string;
+        revisionId: string;
+        label: string;
+        scope: Record<string, string | number | boolean | null>;
+    }[];
+    period: {
+        originBasis: "policy" | "accident" | "report";
+        grouping: {
+            kind: "calendar";
+            cadence: "year" | "month" | "quarter";
+        } | {
+            kind: "fiscal";
+            cadence: "year" | "quarter";
+            startMonth: number;
+        } | {
+            kind: "policy-schedule";
+            periodIds: string[];
+        };
+        comparisonClock: "common-evaluation-date" | "since-period-start" | "since-period-end" | "matched-accident-cohorts";
+        ageConvention: "exact-days" | "calendar-months";
+        observationSelection: "exact" | "latest-on-or-before";
+    };
+    exposures: {
+        id: string;
+        unit: string;
+        allocation: {
+            kind: "exact-match";
+        } | {
+            kind: "time-overlap";
+        } | {
+            kind: "supplied-weights";
+            weightMeasureId: string;
+        };
+        sourceMeaning: "point-in-time" | "already-earned" | "written-over-interval" | "flow-over-interval";
+        earning: {
+            kind: "supplied";
+        } | {
+            kind: "uniform-daily";
+            dayCount: "actual-days";
+        } | {
+            kind: "weighted";
+            scheduleId: string;
+        };
+        scopeId: string;
+    }[];
+    financialTerms: ({
+        measureId: string;
+        kind: "claim-layer" | "occurrence-layer";
+        id: string;
+        attachment: number;
+        limit: number | null;
+        allocation: "proportional";
+    } | {
+        measureId: string;
+        kind: "policy-aggregate";
+        id: string;
+        limit: number | null;
+        allocation: "proportional" | "chronological";
+        deductible: number;
+    })[];
+    financialAdjustments?: ({
+        kind: "scale";
+        id: string;
+        purpose: "trend" | "index";
+        factor: number;
+    } | {
+        kind: "currency";
+        id: string;
+        fromUnit: string;
+        toUnit: string;
+        rate: number;
+        rateDate: string;
+    } | {
+        kind: "include-expense" | "exclude-expense";
+        id: string;
+        expenseMeasureId: string;
+    } | {
+        kind: "net-recovery";
+        id: string;
+        recoveryMeasureId: string;
+    })[] | undefined;
+}, {
+    id: string;
+    dimensions: {
+        type: "string" | "number" | "boolean" | "date" | "entity-reference";
+        id: string;
+        multiple: boolean;
+    }[];
+    measures: {
+        id: string;
+        unit: string;
+        developmentSemantics: "point-in-time" | "cumulative" | "incremental";
+        statistic: {
+            measureId: string;
+            kind: "sum";
+        } | {
+            kind: "ratio";
+            numeratorMeasureId: string;
+            denominatorMeasureId: string;
+            scale: number;
+            denominatorRule: "positive" | "nonzero";
+        } | {
+            kind: "distinct-count";
+            entity: "claim" | "claimant" | "occurrence" | "policy" | "coverage";
+        } | {
+            measureId: string;
+            kind: "weighted-mean";
+            weightMeasureId: string;
+        } | {
+            measureId: string;
+            kind: "minimum" | "maximum";
+        } | {
+            measureId: string;
+            kind: "quantile";
+            probability: number;
+            method: "hf-type-7";
+        } | {
+            kind: "duration";
+            start: "accident-date" | "report-date";
+            end: "report-date" | "closed-date" | "evaluation-date";
+            unit: "days";
+            population: "all-with-observed-endpoint" | "closed-only";
+        } | {
+            kind: "survival-quantile";
+            probability: number;
+            method: "kaplan-meier-product-limit";
+            start: "accident-date" | "report-date";
+            unit: "days";
+            event: "closed-date";
+            censor: "evaluation-date";
+        };
+        populationScopeId: string;
+        condition?: AnalysisPredicate | undefined;
+    }[];
+    analysisContractVersion: "actuarial-analysis/1";
+    version: string;
+    scopes: {
+        financial: {
+            id: string;
+            subject: "claim" | "claimant" | "occurrence" | "policy" | "coverage";
+            predicate: AnalysisPredicate;
+            classification: {
+                kind: "as-observed";
+            } | {
+                kind: "latest-as-of-analysis";
+                asOfDate: string;
+            } | {
+                kind: "frozen-cohort";
+                asOfDate: string;
+            };
+        };
+        reporting: {
+            id: string;
+            subject: "claim" | "claimant" | "occurrence" | "policy" | "coverage";
+            predicate: AnalysisPredicate;
+            classification: {
+                kind: "as-observed";
+            } | {
+                kind: "latest-as-of-analysis";
+                asOfDate: string;
+            } | {
+                kind: "frozen-cohort";
+                asOfDate: string;
+            };
+        };
+        exposure: {
+            id: string;
+            populationKeys: string[];
+            timeBasis: "interval" | "point-in-time" | "already-earned";
+            reportingFilterEffect: "none" | "matching-exposure-dimensions";
+            valuationSelection?: "exact" | "origin-static" | "latest-on-or-before" | undefined;
+        }[];
+    };
+    policySchedule: {
+        id: string;
+        startDate: string;
+        endDate: string;
+        revisionId: string;
+        label: string;
+        scope: Record<string, string | number | boolean | null>;
+    }[];
+    period: {
+        originBasis: "policy" | "accident" | "report";
+        grouping: {
+            kind: "calendar";
+            cadence: "year" | "month" | "quarter";
+        } | {
+            kind: "fiscal";
+            cadence: "year" | "quarter";
+            startMonth: number;
+        } | {
+            kind: "policy-schedule";
+            periodIds: string[];
+        };
+        comparisonClock: "common-evaluation-date" | "since-period-start" | "since-period-end" | "matched-accident-cohorts";
+        ageConvention: "exact-days" | "calendar-months";
+        observationSelection: "exact" | "latest-on-or-before";
+    };
+    exposures: {
+        id: string;
+        unit: string;
+        allocation: {
+            kind: "exact-match";
+        } | {
+            kind: "time-overlap";
+        } | {
+            kind: "supplied-weights";
+            weightMeasureId: string;
+        };
+        sourceMeaning: "point-in-time" | "already-earned" | "written-over-interval" | "flow-over-interval";
+        earning: {
+            kind: "supplied";
+        } | {
+            kind: "uniform-daily";
+            dayCount: "actual-days";
+        } | {
+            kind: "weighted";
+            scheduleId: string;
+        };
+        scopeId: string;
+    }[];
+    financialTerms: ({
+        measureId: string;
+        kind: "claim-layer" | "occurrence-layer";
+        id: string;
+        attachment: number;
+        limit: number | null;
+        allocation: "proportional";
+    } | {
+        measureId: string;
+        kind: "policy-aggregate";
+        id: string;
+        limit: number | null;
+        allocation: "proportional" | "chronological";
+        deductible: number;
+    })[];
+    financialAdjustments?: ({
+        kind: "scale";
+        id: string;
+        purpose: "trend" | "index";
+        factor: number;
+    } | {
+        kind: "currency";
+        id: string;
+        fromUnit: string;
+        toUnit: string;
+        rate: number;
+        rateDate: string;
+    } | {
+        kind: "include-expense" | "exclude-expense";
+        id: string;
+        expenseMeasureId: string;
+    } | {
+        kind: "net-recovery";
+        id: string;
+        recoveryMeasureId: string;
+    })[] | undefined;
+}>, {
+    id: string;
+    dimensions: {
+        type: "string" | "number" | "boolean" | "date" | "entity-reference";
+        id: string;
+        multiple: boolean;
+    }[];
+    measures: {
+        id: string;
+        unit: string;
+        developmentSemantics: "point-in-time" | "cumulative" | "incremental";
+        statistic: {
+            measureId: string;
+            kind: "sum";
+        } | {
+            kind: "ratio";
+            numeratorMeasureId: string;
+            denominatorMeasureId: string;
+            scale: number;
+            denominatorRule: "positive" | "nonzero";
+        } | {
+            kind: "distinct-count";
+            entity: "claim" | "claimant" | "occurrence" | "policy" | "coverage";
+        } | {
+            measureId: string;
+            kind: "weighted-mean";
+            weightMeasureId: string;
+        } | {
+            measureId: string;
+            kind: "minimum" | "maximum";
+        } | {
+            measureId: string;
+            kind: "quantile";
+            probability: number;
+            method: "hf-type-7";
+        } | {
+            kind: "duration";
+            start: "accident-date" | "report-date";
+            end: "report-date" | "closed-date" | "evaluation-date";
+            unit: "days";
+            population: "all-with-observed-endpoint" | "closed-only";
+        } | {
+            kind: "survival-quantile";
+            probability: number;
+            method: "kaplan-meier-product-limit";
+            start: "accident-date" | "report-date";
+            unit: "days";
+            event: "closed-date";
+            censor: "evaluation-date";
+        };
+        populationScopeId: string;
+        condition?: AnalysisPredicate | undefined;
+    }[];
+    analysisContractVersion: "actuarial-analysis/1";
+    version: string;
+    scopes: {
+        financial: {
+            id: string;
+            subject: "claim" | "claimant" | "occurrence" | "policy" | "coverage";
+            predicate: AnalysisPredicate;
+            classification: {
+                kind: "as-observed";
+            } | {
+                kind: "latest-as-of-analysis";
+                asOfDate: string;
+            } | {
+                kind: "frozen-cohort";
+                asOfDate: string;
+            };
+        };
+        reporting: {
+            id: string;
+            subject: "claim" | "claimant" | "occurrence" | "policy" | "coverage";
+            predicate: AnalysisPredicate;
+            classification: {
+                kind: "as-observed";
+            } | {
+                kind: "latest-as-of-analysis";
+                asOfDate: string;
+            } | {
+                kind: "frozen-cohort";
+                asOfDate: string;
+            };
+        };
+        exposure: {
+            id: string;
+            populationKeys: string[];
+            timeBasis: "interval" | "point-in-time" | "already-earned";
+            reportingFilterEffect: "none" | "matching-exposure-dimensions";
+            valuationSelection?: "exact" | "origin-static" | "latest-on-or-before" | undefined;
+        }[];
+    };
+    policySchedule: {
+        id: string;
+        startDate: string;
+        endDate: string;
+        revisionId: string;
+        label: string;
+        scope: Record<string, string | number | boolean | null>;
+    }[];
+    period: {
+        originBasis: "policy" | "accident" | "report";
+        grouping: {
+            kind: "calendar";
+            cadence: "year" | "month" | "quarter";
+        } | {
+            kind: "fiscal";
+            cadence: "year" | "quarter";
+            startMonth: number;
+        } | {
+            kind: "policy-schedule";
+            periodIds: string[];
+        };
+        comparisonClock: "common-evaluation-date" | "since-period-start" | "since-period-end" | "matched-accident-cohorts";
+        ageConvention: "exact-days" | "calendar-months";
+        observationSelection: "exact" | "latest-on-or-before";
+    };
+    exposures: {
+        id: string;
+        unit: string;
+        allocation: {
+            kind: "exact-match";
+        } | {
+            kind: "time-overlap";
+        } | {
+            kind: "supplied-weights";
+            weightMeasureId: string;
+        };
+        sourceMeaning: "point-in-time" | "already-earned" | "written-over-interval" | "flow-over-interval";
+        earning: {
+            kind: "supplied";
+        } | {
+            kind: "uniform-daily";
+            dayCount: "actual-days";
+        } | {
+            kind: "weighted";
+            scheduleId: string;
+        };
+        scopeId: string;
+    }[];
+    financialTerms: ({
+        measureId: string;
+        kind: "claim-layer" | "occurrence-layer";
+        id: string;
+        attachment: number;
+        limit: number | null;
+        allocation: "proportional";
+    } | {
+        measureId: string;
+        kind: "policy-aggregate";
+        id: string;
+        limit: number | null;
+        allocation: "proportional" | "chronological";
+        deductible: number;
+    })[];
+    financialAdjustments?: ({
+        kind: "scale";
+        id: string;
+        purpose: "trend" | "index";
+        factor: number;
+    } | {
+        kind: "currency";
+        id: string;
+        fromUnit: string;
+        toUnit: string;
+        rate: number;
+        rateDate: string;
+    } | {
+        kind: "include-expense" | "exclude-expense";
+        id: string;
+        expenseMeasureId: string;
+    } | {
+        kind: "net-recovery";
+        id: string;
+        recoveryMeasureId: string;
+    })[] | undefined;
+}, {
+    id: string;
+    dimensions: {
+        type: "string" | "number" | "boolean" | "date" | "entity-reference";
+        id: string;
+        multiple: boolean;
+    }[];
+    measures: {
+        id: string;
+        unit: string;
+        developmentSemantics: "point-in-time" | "cumulative" | "incremental";
+        statistic: {
+            measureId: string;
+            kind: "sum";
+        } | {
+            kind: "ratio";
+            numeratorMeasureId: string;
+            denominatorMeasureId: string;
+            scale: number;
+            denominatorRule: "positive" | "nonzero";
+        } | {
+            kind: "distinct-count";
+            entity: "claim" | "claimant" | "occurrence" | "policy" | "coverage";
+        } | {
+            measureId: string;
+            kind: "weighted-mean";
+            weightMeasureId: string;
+        } | {
+            measureId: string;
+            kind: "minimum" | "maximum";
+        } | {
+            measureId: string;
+            kind: "quantile";
+            probability: number;
+            method: "hf-type-7";
+        } | {
+            kind: "duration";
+            start: "accident-date" | "report-date";
+            end: "report-date" | "closed-date" | "evaluation-date";
+            unit: "days";
+            population: "all-with-observed-endpoint" | "closed-only";
+        } | {
+            kind: "survival-quantile";
+            probability: number;
+            method: "kaplan-meier-product-limit";
+            start: "accident-date" | "report-date";
+            unit: "days";
+            event: "closed-date";
+            censor: "evaluation-date";
+        };
+        populationScopeId: string;
+        condition?: AnalysisPredicate | undefined;
+    }[];
+    analysisContractVersion: "actuarial-analysis/1";
+    version: string;
+    scopes: {
+        financial: {
+            id: string;
+            subject: "claim" | "claimant" | "occurrence" | "policy" | "coverage";
+            predicate: AnalysisPredicate;
+            classification: {
+                kind: "as-observed";
+            } | {
+                kind: "latest-as-of-analysis";
+                asOfDate: string;
+            } | {
+                kind: "frozen-cohort";
+                asOfDate: string;
+            };
+        };
+        reporting: {
+            id: string;
+            subject: "claim" | "claimant" | "occurrence" | "policy" | "coverage";
+            predicate: AnalysisPredicate;
+            classification: {
+                kind: "as-observed";
+            } | {
+                kind: "latest-as-of-analysis";
+                asOfDate: string;
+            } | {
+                kind: "frozen-cohort";
+                asOfDate: string;
+            };
+        };
+        exposure: {
+            id: string;
+            populationKeys: string[];
+            timeBasis: "interval" | "point-in-time" | "already-earned";
+            reportingFilterEffect: "none" | "matching-exposure-dimensions";
+            valuationSelection?: "exact" | "origin-static" | "latest-on-or-before" | undefined;
+        }[];
+    };
+    policySchedule: {
+        id: string;
+        startDate: string;
+        endDate: string;
+        revisionId: string;
+        label: string;
+        scope: Record<string, string | number | boolean | null>;
+    }[];
+    period: {
+        originBasis: "policy" | "accident" | "report";
+        grouping: {
+            kind: "calendar";
+            cadence: "year" | "month" | "quarter";
+        } | {
+            kind: "fiscal";
+            cadence: "year" | "quarter";
+            startMonth: number;
+        } | {
+            kind: "policy-schedule";
+            periodIds: string[];
+        };
+        comparisonClock: "common-evaluation-date" | "since-period-start" | "since-period-end" | "matched-accident-cohorts";
+        ageConvention: "exact-days" | "calendar-months";
+        observationSelection: "exact" | "latest-on-or-before";
+    };
+    exposures: {
+        id: string;
+        unit: string;
+        allocation: {
+            kind: "exact-match";
+        } | {
+            kind: "time-overlap";
+        } | {
+            kind: "supplied-weights";
+            weightMeasureId: string;
+        };
+        sourceMeaning: "point-in-time" | "already-earned" | "written-over-interval" | "flow-over-interval";
+        earning: {
+            kind: "supplied";
+        } | {
+            kind: "uniform-daily";
+            dayCount: "actual-days";
+        } | {
+            kind: "weighted";
+            scheduleId: string;
+        };
+        scopeId: string;
+    }[];
+    financialTerms: ({
+        measureId: string;
+        kind: "claim-layer" | "occurrence-layer";
+        id: string;
+        attachment: number;
+        limit: number | null;
+        allocation: "proportional";
+    } | {
+        measureId: string;
+        kind: "policy-aggregate";
+        id: string;
+        limit: number | null;
+        allocation: "proportional" | "chronological";
+        deductible: number;
+    })[];
+    financialAdjustments?: ({
+        kind: "scale";
+        id: string;
+        purpose: "trend" | "index";
+        factor: number;
+    } | {
+        kind: "currency";
+        id: string;
+        fromUnit: string;
+        toUnit: string;
+        rate: number;
+        rateDate: string;
+    } | {
+        kind: "include-expense" | "exclude-expense";
+        id: string;
+        expenseMeasureId: string;
+    } | {
+        kind: "net-recovery";
+        id: string;
+        recoveryMeasureId: string;
+    })[] | undefined;
+}>;
+export declare const analysisRecipeSchema: z.ZodEffects<z.ZodObject<{
+    recipeContractVersion: z.ZodLiteral<"actuarial-recipe/1">;
+    id: z.ZodEffects<z.ZodString, string, string>;
+    version: z.ZodEffects<z.ZodString, string, string>;
+    analysisDefinitionId: z.ZodEffects<z.ZodString, string, string>;
+    steps: z.ZodArray<z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+        kind: z.ZodLiteral<"prepare-history">;
+        historyContractId: z.ZodEffects<z.ZodString, string, string>;
+    }, "strict", z.ZodTypeAny, {
+        kind: "prepare-history";
+        historyContractId: string;
+    }, {
+        kind: "prepare-history";
+        historyContractId: string;
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"assign-periods">;
+        analysisDefinitionId: z.ZodEffects<z.ZodString, string, string>;
+    }, "strict", z.ZodTypeAny, {
+        kind: "assign-periods";
+        analysisDefinitionId: string;
+    }, {
+        kind: "assign-periods";
+        analysisDefinitionId: string;
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"earn-exposure">;
+        exposureMeasureIds: z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">;
+    }, "strict", z.ZodTypeAny, {
+        kind: "earn-exposure";
+        exposureMeasureIds: string[];
+    }, {
+        kind: "earn-exposure";
+        exposureMeasureIds: string[];
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"apply-financial-terms">;
+        termIds: z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">;
+    }, "strict", z.ZodTypeAny, {
+        kind: "apply-financial-terms";
+        termIds: string[];
+    }, {
+        kind: "apply-financial-terms";
+        termIds: string[];
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"apply-financial-pipeline">;
+        amountMeasureId: z.ZodEffects<z.ZodString, string, string>;
+        stageIds: z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">;
+    }, "strict", z.ZodTypeAny, {
+        kind: "apply-financial-pipeline";
+        amountMeasureId: string;
+        stageIds: string[];
+    }, {
+        kind: "apply-financial-pipeline";
+        amountMeasureId: string;
+        stageIds: string[];
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"calculate">;
+        measureIds: z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">;
+    }, "strict", z.ZodTypeAny, {
+        kind: "calculate";
+        measureIds: string[];
+    }, {
+        kind: "calculate";
+        measureIds: string[];
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"adapt-diagnostics">;
+        diagnosticDefinitionId: z.ZodEffects<z.ZodString, string, string>;
+    }, "strict", z.ZodTypeAny, {
+        kind: "adapt-diagnostics";
+        diagnosticDefinitionId: string;
+    }, {
+        kind: "adapt-diagnostics";
+        diagnosticDefinitionId: string;
+    }>]>, "many">;
+    requiredCapabilities: z.ZodArray<z.ZodEnum<["history-snapshots", "history-changes", "irregular-periods", "exposure-earning", "typed-populations", "descriptive-statistics", "reserving-triangle-adapter", "bounded-execution", "shared-financial-terms", "recipes", "scenarios"]>, "many">;
+    parameters: z.ZodRecord<z.ZodEffects<z.ZodString, string, string>, z.ZodType<JsonValue, z.ZodTypeDef, JsonValue>>;
+}, "strict", z.ZodTypeAny, {
+    id: string;
+    version: string;
+    analysisDefinitionId: string;
+    recipeContractVersion: "actuarial-recipe/1";
+    steps: ({
+        kind: "prepare-history";
+        historyContractId: string;
+    } | {
+        kind: "assign-periods";
+        analysisDefinitionId: string;
+    } | {
+        kind: "earn-exposure";
+        exposureMeasureIds: string[];
+    } | {
+        kind: "apply-financial-terms";
+        termIds: string[];
+    } | {
+        kind: "apply-financial-pipeline";
+        amountMeasureId: string;
+        stageIds: string[];
+    } | {
+        kind: "calculate";
+        measureIds: string[];
+    } | {
+        kind: "adapt-diagnostics";
+        diagnosticDefinitionId: string;
+    })[];
+    requiredCapabilities: ("history-snapshots" | "history-changes" | "irregular-periods" | "exposure-earning" | "typed-populations" | "descriptive-statistics" | "reserving-triangle-adapter" | "bounded-execution" | "shared-financial-terms" | "recipes" | "scenarios")[];
+    parameters: Record<string, JsonValue>;
+}, {
+    id: string;
+    version: string;
+    analysisDefinitionId: string;
+    recipeContractVersion: "actuarial-recipe/1";
+    steps: ({
+        kind: "prepare-history";
+        historyContractId: string;
+    } | {
+        kind: "assign-periods";
+        analysisDefinitionId: string;
+    } | {
+        kind: "earn-exposure";
+        exposureMeasureIds: string[];
+    } | {
+        kind: "apply-financial-terms";
+        termIds: string[];
+    } | {
+        kind: "apply-financial-pipeline";
+        amountMeasureId: string;
+        stageIds: string[];
+    } | {
+        kind: "calculate";
+        measureIds: string[];
+    } | {
+        kind: "adapt-diagnostics";
+        diagnosticDefinitionId: string;
+    })[];
+    requiredCapabilities: ("history-snapshots" | "history-changes" | "irregular-periods" | "exposure-earning" | "typed-populations" | "descriptive-statistics" | "reserving-triangle-adapter" | "bounded-execution" | "shared-financial-terms" | "recipes" | "scenarios")[];
+    parameters: Record<string, JsonValue>;
+}>, {
+    id: string;
+    version: string;
+    analysisDefinitionId: string;
+    recipeContractVersion: "actuarial-recipe/1";
+    steps: ({
+        kind: "prepare-history";
+        historyContractId: string;
+    } | {
+        kind: "assign-periods";
+        analysisDefinitionId: string;
+    } | {
+        kind: "earn-exposure";
+        exposureMeasureIds: string[];
+    } | {
+        kind: "apply-financial-terms";
+        termIds: string[];
+    } | {
+        kind: "apply-financial-pipeline";
+        amountMeasureId: string;
+        stageIds: string[];
+    } | {
+        kind: "calculate";
+        measureIds: string[];
+    } | {
+        kind: "adapt-diagnostics";
+        diagnosticDefinitionId: string;
+    })[];
+    requiredCapabilities: ("history-snapshots" | "history-changes" | "irregular-periods" | "exposure-earning" | "typed-populations" | "descriptive-statistics" | "reserving-triangle-adapter" | "bounded-execution" | "shared-financial-terms" | "recipes" | "scenarios")[];
+    parameters: Record<string, JsonValue>;
+}, {
+    id: string;
+    version: string;
+    analysisDefinitionId: string;
+    recipeContractVersion: "actuarial-recipe/1";
+    steps: ({
+        kind: "prepare-history";
+        historyContractId: string;
+    } | {
+        kind: "assign-periods";
+        analysisDefinitionId: string;
+    } | {
+        kind: "earn-exposure";
+        exposureMeasureIds: string[];
+    } | {
+        kind: "apply-financial-terms";
+        termIds: string[];
+    } | {
+        kind: "apply-financial-pipeline";
+        amountMeasureId: string;
+        stageIds: string[];
+    } | {
+        kind: "calculate";
+        measureIds: string[];
+    } | {
+        kind: "adapt-diagnostics";
+        diagnosticDefinitionId: string;
+    })[];
+    requiredCapabilities: ("history-snapshots" | "history-changes" | "irregular-periods" | "exposure-earning" | "typed-populations" | "descriptive-statistics" | "reserving-triangle-adapter" | "bounded-execution" | "shared-financial-terms" | "recipes" | "scenarios")[];
+    parameters: Record<string, JsonValue>;
+}>;
+export declare const analysisResultSchema: z.ZodType<AnalysisResult>;
+export declare const analysisScenarioSchema: z.ZodEffects<z.ZodObject<{
+    id: z.ZodEffects<z.ZodString, string, string>;
+    changes: z.ZodArray<z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+        kind: z.ZodLiteral<"financial-term-limit">;
+        termId: z.ZodEffects<z.ZodString, string, string>;
+        limit: z.ZodNullable<z.ZodNumber>;
+    }, "strict", z.ZodTypeAny, {
+        kind: "financial-term-limit";
+        limit: number | null;
+        termId: string;
+    }, {
+        kind: "financial-term-limit";
+        limit: number | null;
+        termId: string;
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"financial-term-attachment">;
+        termId: z.ZodEffects<z.ZodString, string, string>;
+        amount: z.ZodNumber;
+    }, "strict", z.ZodTypeAny, {
+        kind: "financial-term-attachment";
+        termId: string;
+        amount: number;
+    }, {
+        kind: "financial-term-attachment";
+        termId: string;
+        amount: number;
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"reporting-predicate">;
+        predicate: z.ZodType<AnalysisPredicate, z.ZodTypeDef, AnalysisPredicate>;
+    }, "strict", z.ZodTypeAny, {
+        kind: "reporting-predicate";
+        predicate: AnalysisPredicate;
+    }, {
+        kind: "reporting-predicate";
+        predicate: AnalysisPredicate;
+    }>]>, "many">;
+}, "strict", z.ZodTypeAny, {
+    id: string;
+    changes: ({
+        kind: "financial-term-limit";
+        limit: number | null;
+        termId: string;
+    } | {
+        kind: "financial-term-attachment";
+        termId: string;
+        amount: number;
+    } | {
+        kind: "reporting-predicate";
+        predicate: AnalysisPredicate;
+    })[];
+}, {
+    id: string;
+    changes: ({
+        kind: "financial-term-limit";
+        limit: number | null;
+        termId: string;
+    } | {
+        kind: "financial-term-attachment";
+        termId: string;
+        amount: number;
+    } | {
+        kind: "reporting-predicate";
+        predicate: AnalysisPredicate;
+    })[];
+}>, {
+    id: string;
+    changes: ({
+        kind: "financial-term-limit";
+        limit: number | null;
+        termId: string;
+    } | {
+        kind: "financial-term-attachment";
+        termId: string;
+        amount: number;
+    } | {
+        kind: "reporting-predicate";
+        predicate: AnalysisPredicate;
+    })[];
+}, {
+    id: string;
+    changes: ({
+        kind: "financial-term-limit";
+        limit: number | null;
+        termId: string;
+    } | {
+        kind: "financial-term-attachment";
+        termId: string;
+        amount: number;
+    } | {
+        kind: "reporting-predicate";
+        predicate: AnalysisPredicate;
+    })[];
+}>;
+export declare const analysisScenarioGridSchema: z.ZodType<AnalysisScenarioGrid>;
+export declare const analysisClassificationSchema: z.ZodType<AnalysisClassificationDefinition>;
+export declare function parseHistoricalDatasetInput(value: unknown): HistoricalDatasetInput;
+export declare function parseCustomizationResourceLimits(value: unknown): CustomizationResourceLimits;
+export declare function parseHistoricalObservationRecord(value: unknown): HistoricalDatasetInput["records"][number];
+export declare function parseAnalysisDefinition(value: unknown): AnalysisDefinition;
+export declare function parseAnalysisRecipe(value: unknown): AnalysisRecipe;
+export declare function parseAnalysisResult(value: unknown): AnalysisResult;
+export declare function parseAnalysisScenario(value: unknown): AnalysisScenario;
+export declare function parseAnalysisScenarioGrid(value: unknown): AnalysisScenarioGrid;
+export declare function parseCustomizationExposureObservations(value: unknown): readonly CustomizationExposureObservation[];
+export declare function parseExposureAllocationTargets(value: unknown): readonly ExposureAllocationTarget[];
+export declare function parseExposureRevisionSelection(value: unknown): ExposureRevisionSelection;
+export declare function parseExposureLevelSchedule(value: unknown): ExposureLevelSchedule;
+export declare function parseAnalysisClassification(value: unknown): AnalysisClassificationDefinition;
+//# sourceMappingURL=customizationContracts.d.ts.map