@actuarial-ts/data 0.7.1 → 0.8.0

package/dist/customizationContracts.js

@@ -0,0 +1,845 @@
+import { ANALYSIS_DEFINITION_CONTRACT_VERSION, ANALYSIS_RECIPE_CONTRACT_VERSION, ANALYSIS_RESULT_CONTRACT_VERSION, CUSTOMIZATION_CAPABILITIES, HISTORICAL_DATASET_CONTRACT_VERSION, DiagnosticValidationError, diagnosticJsonPreflight, isDiagnosticToken, isRealIsoDate, } from "@actuarial-ts/core";
+import { z } from "zod";
+const token = z
+    .string()
+    .refine(isDiagnosticToken, "Expected a nonempty token with valid Unicode and no U+0000");
+const date = z.string().refine(isRealIsoDate, "Expected a real Gregorian yyyy-mm-dd date");
+const timestamp = z.string().datetime({ offset: true });
+const finite = z.number().finite();
+const scalar = z.union([z.string(), finite, z.boolean(), z.null()]);
+const positiveSafeInteger = z.number().int().positive().safe();
+/** Complete, closed resource policy for every customization streaming boundary. */
+export const customizationResourceLimitsSchema = z
+    .object({
+    maximumInputRecords: positiveSafeInteger,
+    maximumInMemoryBytes: positiveSafeInteger,
+    maximumRecordBytes: positiveSafeInteger,
+    maximumPartitionRecords: positiveSafeInteger,
+    maximumOutputValues: positiveSafeInteger,
+    maximumActiveScenarios: positiveSafeInteger,
+})
+    .strict();
+const jsonValue = z.lazy(() => z.union([z.null(), z.boolean(), finite, z.string(), z.array(jsonValue), z.record(jsonValue)]));
+const predicate = z.lazy(() => z.union([
+    z.object({ op: z.literal("true") }).strict(),
+    z.object({ op: z.literal("eq"), dimensionId: token, value: scalar }).strict(),
+    z.object({ op: z.literal("in"), dimensionId: token, values: z.array(scalar) }).strict(),
+    z
+        .object({
+        op: z.literal("range"),
+        dimensionId: token,
+        minimum: z.union([finite, date]).optional(),
+        maximum: z.union([finite, date]).optional(),
+        includeMinimum: z.boolean(),
+        includeMaximum: z.boolean(),
+    })
+        .strict()
+        .superRefine((value, context) => {
+        if (value.minimum === undefined && value.maximum === undefined)
+            context.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ["minimum"],
+                message: "Range requires a minimum, maximum, or both",
+            });
+        if (value.minimum !== undefined &&
+            value.maximum !== undefined &&
+            typeof value.minimum !== typeof value.maximum)
+            context.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ["maximum"],
+                message: "Range endpoints must have the same type",
+            });
+    }),
+    z.object({ op: z.literal("missing"), dimensionId: token, isMissing: z.boolean() }).strict(),
+    z.object({ op: z.enum(["and", "or"]), terms: z.array(predicate).min(1) }).strict(),
+    z.object({ op: z.literal("not"), term: predicate }).strict(),
+]));
+const sourceLocation = z
+    .object({
+    artifactId: token,
+    sourceFile: token.optional(),
+    sourceSheet: token.optional(),
+    sourceRow: z.number().int().positive().safe().optional(),
+})
+    .strict();
+export const customizationExposureObservationSchema = z
+    .object({
+    id: token,
+    measureId: token,
+    value: finite.nullable(),
+    startDate: date.optional(),
+    endDate: date.optional(),
+    pointDate: date.optional(),
+    evaluationDate: date.optional(),
+    dimensions: z.record(token, scalar),
+    revisionId: token,
+    revision: z.object({
+        action: z.enum(["upsert", "delete"]),
+        sequence: z.number().int().nonnegative().safe().optional(),
+        correctedAt: timestamp.optional(),
+    }).strict().optional(),
+    source: sourceLocation,
+})
+    .strict()
+    .superRefine((value, context) => {
+    if ((value.startDate === undefined) !== (value.endDate === undefined))
+        context.addIssue({ code: z.ZodIssueCode.custom, path: ["endDate"], message: "Exposure interval requires both startDate and endDate" });
+    if (value.startDate !== undefined && value.endDate !== undefined && value.startDate >= value.endDate)
+        context.addIssue({ code: z.ZodIssueCode.custom, path: ["endDate"], message: "Exposure endDate must be after startDate" });
+});
+export const exposureAllocationTargetSchema = z
+    .object({
+    id: token,
+    startDate: date,
+    endDate: date,
+    dimensions: z.record(token, scalar),
+    weights: z.record(token, finite.nonnegative()).optional(),
+})
+    .strict()
+    .refine((value) => value.startDate < value.endDate, { path: ["endDate"], message: "Exposure target endDate must be after startDate" });
+export const exposureRevisionSelectionSchema = z.object({
+    revisionView: z.discriminatedUnion("kind", [
+        z.object({ kind: z.literal("as-known"), knowledgeCutoff: timestamp }).strict(),
+        z.object({ kind: z.literal("restated") }).strict(),
+    ]),
+    revisionPrecedence: z.enum(["sequence", "corrected-at"]),
+}).strict();
+export const exposureLevelScheduleSchema = z.object({
+    id: token,
+    measureId: token,
+    startDate: date,
+    endDate: date,
+    initialDailyLevel: finite.nonnegative(),
+    movements: z.array(z.discriminatedUnion("kind", [
+        z.object({ id: token, effectiveDate: date, kind: z.literal("set-daily-level"), dailyLevel: finite.nonnegative() }).strict(),
+        z.object({ id: token, effectiveDate: date, kind: z.literal("cancel") }).strict(),
+    ])),
+    dimensions: z.record(token, scalar),
+    evaluationDate: date.optional(),
+    revisionId: token,
+    source: sourceLocation,
+}).strict().superRefine((schedule, context) => {
+    if (schedule.startDate >= schedule.endDate)
+        context.addIssue({ code: z.ZodIssueCode.custom, path: ["endDate"], message: "endDate must be after startDate" });
+    duplicatePaths(schedule.movements, "movements", context);
+});
+export const historicalRecordSchema = z
+    .object({
+    recordId: token,
+    sourceNamespace: token,
+    claimId: token,
+    grain: z.enum(["claim-snapshot", "claim-component-snapshot", "transaction"]),
+    componentId: token.optional(),
+    accidentDate: date.optional(),
+    reportDate: date.optional(),
+    evaluationDate: date.optional(),
+    effectiveDate: date.optional(),
+    measures: z.record(token, z.union([finite, z.null()])),
+    status: token.optional(),
+    dimensions: z.record(token, z.union([scalar, z.array(scalar)])).optional(),
+    relationships: z
+        .object({
+        claimantIds: z.array(token).optional(),
+        occurrenceId: token.optional(),
+        policyIds: z.array(token).optional(),
+        coverageIds: z.array(token).optional(),
+    })
+        .strict()
+        .optional(),
+    completeness: z.enum(["complete-snapshot", "partial-snapshot", "change-only"]),
+    revision: z
+        .object({
+        id: token,
+        action: z.enum(["upsert", "delete"]),
+        sequence: z.number().int().nonnegative().safe().optional(),
+        correctedAt: timestamp.optional(),
+    })
+        .strict(),
+    source: sourceLocation,
+})
+    .strict()
+    .superRefine((record, context) => {
+    if (record.grain === "claim-component-snapshot" && record.componentId === undefined)
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["componentId"],
+            message: "Claim-component snapshots require componentId",
+        });
+    if (record.grain !== "claim-component-snapshot" && record.componentId !== undefined)
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["componentId"],
+            message: "componentId is only valid for claim-component snapshots",
+        });
+    if (record.grain === "transaction" && record.effectiveDate === undefined)
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["effectiveDate"],
+            message: "Transactions require effectiveDate",
+        });
+    if (record.grain !== "transaction" && record.evaluationDate === undefined)
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["evaluationDate"],
+            message: "Snapshots require evaluationDate",
+        });
+    if (record.revision.action === "delete" && Object.keys(record.measures).length > 0)
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["measures"],
+            message: "Deletion tombstones cannot carry measures",
+        });
+});
+export const historicalDatasetInputSchema = z
+    .object({
+    historyContractVersion: z.literal(HISTORICAL_DATASET_CONTRACT_VERSION),
+    datasetId: token,
+    historyMode: z.enum(["full-snapshots", "changes", "mixed"]),
+    revisionView: z.discriminatedUnion("kind", [
+        z.object({ kind: z.literal("as-known"), knowledgeCutoff: timestamp }).strict(),
+        z.object({ kind: z.literal("restated") }).strict(),
+    ]),
+    revisionPrecedence: z.enum(["sequence", "corrected-at"]),
+    missingSnapshotRecord: z.enum(["unknown", "carried-forward"]),
+    sources: z
+        .array(z
+        .object({ namespace: token, artifactId: token, mappingVersion: token })
+        .strict())
+        .min(1),
+    evaluationDates: z.array(date).optional(),
+    openingBalances: z
+        .array(z
+        .object({
+        sourceNamespace: token,
+        claimId: token,
+        asOfDate: date,
+        measures: z.record(token, finite),
+        source: sourceLocation,
+    })
+        .strict())
+        .optional(),
+    records: z.array(historicalRecordSchema),
+})
+    .strict()
+    .superRefine((input, context) => {
+    const namespaces = new Set();
+    const artifactByNamespace = new Map();
+    input.sources.forEach((source, index) => {
+        if (namespaces.has(source.namespace))
+            context.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ["sources", index, "namespace"],
+                message: "Source namespace is duplicated",
+            });
+        namespaces.add(source.namespace);
+        artifactByNamespace.set(source.namespace, source.artifactId);
+    });
+    input.records.forEach((record, index) => {
+        if (!namespaces.has(record.sourceNamespace))
+            context.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ["records", index, "sourceNamespace"],
+                message: "Record references an unknown source namespace",
+            });
+        if (artifactByNamespace.has(record.sourceNamespace) &&
+            artifactByNamespace.get(record.sourceNamespace) !== record.source.artifactId)
+            context.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ["records", index, "source", "artifactId"],
+                message: "Record artifact does not match its source namespace",
+            });
+        if (input.revisionPrecedence === "sequence" && record.revision.sequence === undefined)
+            context.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ["records", index, "revision", "sequence"],
+                message: "Sequence precedence requires a sequence on every revision",
+            });
+        if (input.revisionPrecedence === "corrected-at" && record.revision.correctedAt === undefined)
+            context.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ["records", index, "revision", "correctedAt"],
+                message: "Corrected-at precedence requires correctedAt on every revision",
+            });
+        if (input.revisionView.kind === "as-known" &&
+            record.revision.correctedAt === undefined)
+            context.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ["records", index, "revision", "correctedAt"],
+                message: "As-known revision views require correctedAt on every revision",
+            });
+        if (record.accidentDate !== undefined &&
+            record.reportDate !== undefined &&
+            record.reportDate < record.accidentDate)
+            context.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ["records", index, "reportDate"],
+                message: "reportDate must not precede accidentDate",
+            });
+        for (const [field, observationDate] of [
+            ["evaluationDate", record.evaluationDate],
+            ["effectiveDate", record.effectiveDate],
+        ])
+            if (record.reportDate !== undefined &&
+                observationDate !== undefined &&
+                observationDate < record.reportDate)
+                context.addIssue({
+                    code: z.ZodIssueCode.custom,
+                    path: ["records", index, field],
+                    message: "Observation date must not precede reportDate",
+                });
+        if (input.historyMode === "full-snapshots" &&
+            (record.grain === "transaction" || record.completeness === "change-only"))
+            context.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ["records", index, "grain"],
+                message: "Full-snapshot history cannot contain transaction/change-only records",
+            });
+        if (input.historyMode === "changes" &&
+            (record.grain !== "transaction" || record.completeness !== "change-only"))
+            context.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ["records", index, "grain"],
+                message: "Changes history requires transaction grain and change-only completeness",
+            });
+    });
+    if (input.historyMode !== "full-snapshots" && input.evaluationDates === undefined)
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["evaluationDates"],
+            message: "Changes or mixed history requires explicit evaluationDates",
+        });
+    if (input.evaluationDates !== undefined) {
+        const ordered = [...input.evaluationDates].sort();
+        if (new Set(input.evaluationDates).size !== input.evaluationDates.length ||
+            ordered.some((value, index) => value !== input.evaluationDates[index]))
+            context.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ["evaluationDates"],
+                message: "evaluationDates must be unique and ascending",
+            });
+    }
+    input.openingBalances?.forEach((balance, index) => {
+        if (!namespaces.has(balance.sourceNamespace))
+            context.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ["openingBalances", index, "sourceNamespace"],
+                message: "Opening balance references an unknown source namespace",
+            });
+        if (artifactByNamespace.has(balance.sourceNamespace) &&
+            artifactByNamespace.get(balance.sourceNamespace) !== balance.source.artifactId)
+            context.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ["openingBalances", index, "source", "artifactId"],
+                message: "Opening balance artifact does not match its source namespace",
+            });
+    });
+});
+const scope = z
+    .object({
+    id: token,
+    subject: z.enum(["claim", "claimant", "occurrence", "policy", "coverage"]),
+    predicate,
+    classification: z.discriminatedUnion("kind", [
+        z.object({ kind: z.literal("as-observed") }).strict(),
+        z.object({ kind: z.literal("latest-as-of-analysis"), asOfDate: date }).strict(),
+        z.object({ kind: z.literal("frozen-cohort"), asOfDate: date }).strict(),
+    ]),
+})
+    .strict();
+const statistic = z.discriminatedUnion("kind", [
+    z.object({ kind: z.literal("sum"), measureId: token }).strict(),
+    z
+        .object({
+        kind: z.literal("ratio"),
+        numeratorMeasureId: token,
+        denominatorMeasureId: token,
+        scale: finite,
+        denominatorRule: z.enum(["positive", "nonzero"]),
+    })
+        .strict(),
+    z
+        .object({
+        kind: z.literal("distinct-count"),
+        entity: z.enum(["claim", "claimant", "occurrence", "policy", "coverage"]),
+    })
+        .strict(),
+    z
+        .object({ kind: z.literal("weighted-mean"), measureId: token, weightMeasureId: token })
+        .strict(),
+    z.object({ kind: z.enum(["minimum", "maximum"]), measureId: token }).strict(),
+    z
+        .object({
+        kind: z.literal("quantile"),
+        measureId: token,
+        probability: finite.min(0).max(1),
+        method: z.literal("hf-type-7"),
+    })
+        .strict(),
+    z
+        .object({
+        kind: z.literal("duration"),
+        start: z.enum(["accident-date", "report-date"]),
+        end: z.enum(["report-date", "closed-date", "evaluation-date"]),
+        unit: z.literal("days"),
+        population: z.enum(["all-with-observed-endpoint", "closed-only"]),
+    })
+        .strict(),
+    z
+        .object({
+        kind: z.literal("survival-quantile"),
+        start: z.enum(["accident-date", "report-date"]),
+        event: z.literal("closed-date"),
+        censor: z.literal("evaluation-date"),
+        unit: z.literal("days"),
+        probability: finite.min(0).max(1),
+        method: z.literal("kaplan-meier-product-limit"),
+    })
+        .strict(),
+]);
+const financialTerm = z.discriminatedUnion("kind", [
+    z
+        .object({
+        kind: z.enum(["claim-layer", "occurrence-layer"]),
+        id: token,
+        measureId: token,
+        attachment: finite.nonnegative(),
+        limit: finite.positive().nullable(),
+        allocation: z.literal("proportional"),
+    })
+        .strict(),
+    z
+        .object({
+        kind: z.literal("policy-aggregate"),
+        id: token,
+        measureId: token,
+        deductible: finite.nonnegative(),
+        limit: finite.positive().nullable(),
+        allocation: z.enum(["proportional", "chronological"]),
+    })
+        .strict(),
+]);
+const financialAdjustment = z.discriminatedUnion("kind", [
+    z.object({ kind: z.literal("scale"), id: token, purpose: z.enum(["trend", "index"]), factor: finite.positive() }).strict(),
+    z.object({ kind: z.literal("currency"), id: token, fromUnit: token, toUnit: token, rate: finite.positive(), rateDate: date }).strict(),
+    z.object({ kind: z.enum(["include-expense", "exclude-expense"]), id: token, expenseMeasureId: token }).strict(),
+    z.object({ kind: z.literal("net-recovery"), id: token, recoveryMeasureId: token }).strict(),
+]);
+function predicateDimensions(value) {
+    switch (value.op) {
+        case "true":
+            return [];
+        case "eq":
+        case "in":
+        case "range":
+        case "missing":
+            return [value.dimensionId];
+        case "not":
+            return predicateDimensions(value.term);
+        case "and":
+        case "or":
+            return value.terms.flatMap(predicateDimensions);
+    }
+}
+function duplicatePaths(values, base, context) {
+    const seen = new Set();
+    values.forEach((value, index) => {
+        if (seen.has(value.id))
+            context.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: [base, index, "id"],
+                message: `${base} ID is duplicated`,
+            });
+        seen.add(value.id);
+    });
+}
+export const analysisDefinitionSchema = z
+    .object({
+    analysisContractVersion: z.literal(ANALYSIS_DEFINITION_CONTRACT_VERSION),
+    id: token,
+    version: token,
+    dimensions: z.array(z
+        .object({
+        id: token,
+        type: z.enum(["string", "number", "boolean", "date", "entity-reference"]),
+        multiple: z.boolean(),
+    })
+        .strict()),
+    scopes: z
+        .object({
+        financial: scope,
+        reporting: scope,
+        exposure: z.array(z
+            .object({
+            id: token,
+            populationKeys: z.array(token),
+            timeBasis: z.enum(["interval", "point-in-time", "already-earned"]),
+            reportingFilterEffect: z.enum(["none", "matching-exposure-dimensions"]),
+            valuationSelection: z.enum(["origin-static", "exact", "latest-on-or-before"]).optional(),
+        })
+            .strict()),
+    })
+        .strict(),
+    policySchedule: z.array(z
+        .object({
+        id: token,
+        label: token,
+        scope: z.record(token, scalar),
+        startDate: date,
+        endDate: date,
+        revisionId: token,
+    })
+        .strict()
+        .refine((period) => period.startDate < period.endDate, {
+        path: ["endDate"],
+        message: "Policy period endDate must be after startDate",
+    })),
+    period: z
+        .object({
+        originBasis: z.enum(["accident", "report", "policy"]),
+        grouping: z.discriminatedUnion("kind", [
+            z.object({ kind: z.literal("calendar"), cadence: z.enum(["month", "quarter", "year"]) }).strict(),
+            z
+                .object({
+                kind: z.literal("fiscal"),
+                cadence: z.enum(["quarter", "year"]),
+                startMonth: z.number().int().min(1).max(12),
+            })
+                .strict(),
+            z.object({ kind: z.literal("policy-schedule"), periodIds: z.array(token) }).strict(),
+        ]),
+        comparisonClock: z.enum([
+            "common-evaluation-date",
+            "since-period-start",
+            "since-period-end",
+            "matched-accident-cohorts",
+        ]),
+        ageConvention: z.enum(["exact-days", "calendar-months"]),
+        observationSelection: z.enum(["exact", "latest-on-or-before"]),
+    })
+        .strict(),
+    exposures: z.array(z
+        .object({
+        id: token,
+        unit: token,
+        sourceMeaning: z.enum([
+            "already-earned",
+            "written-over-interval",
+            "flow-over-interval",
+            "point-in-time",
+        ]),
+        earning: z.discriminatedUnion("kind", [
+            z.object({ kind: z.literal("supplied") }).strict(),
+            z.object({ kind: z.literal("uniform-daily"), dayCount: z.literal("actual-days") }).strict(),
+            z.object({ kind: z.literal("weighted"), scheduleId: token }).strict(),
+        ]),
+        allocation: z.discriminatedUnion("kind", [
+            z.object({ kind: z.literal("exact-match") }).strict(),
+            z.object({ kind: z.literal("time-overlap") }).strict(),
+            z.object({ kind: z.literal("supplied-weights"), weightMeasureId: token }).strict(),
+        ]),
+        scopeId: token,
+    })
+        .strict()),
+    measures: z.array(z
+        .object({
+        id: token,
+        unit: token,
+        developmentSemantics: z.enum(["cumulative", "incremental", "point-in-time"]),
+        statistic,
+        populationScopeId: token,
+        condition: predicate.optional(),
+    })
+        .strict()),
+    financialTerms: z.array(financialTerm),
+    financialAdjustments: z.array(financialAdjustment).optional(),
+})
+    .strict()
+    .superRefine((definition, context) => {
+    duplicatePaths(definition.dimensions, "dimensions", context);
+    duplicatePaths(definition.scopes.exposure, "scopes.exposure", context);
+    duplicatePaths(definition.policySchedule, "policySchedule", context);
+    duplicatePaths(definition.exposures, "exposures", context);
+    duplicatePaths(definition.measures, "measures", context);
+    duplicatePaths(definition.financialTerms, "financialTerms", context);
+    duplicatePaths(definition.financialAdjustments ?? [], "financialAdjustments", context);
+    const financialStageIds = [...definition.financialTerms.map((item) => item.id), ...(definition.financialAdjustments ?? []).map((item) => item.id)];
+    if (new Set(financialStageIds).size !== financialStageIds.length)
+        context.addIssue({ code: z.ZodIssueCode.custom, path: ["financialAdjustments"], message: "Financial term and adjustment IDs must be distinct" });
+    const scopeIds = new Set([
+        definition.scopes.financial.id,
+        definition.scopes.reporting.id,
+        ...definition.scopes.exposure.map((scope) => scope.id),
+    ]);
+    if (scopeIds.size !== definition.scopes.exposure.length + 2)
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["scopes"],
+            message: "Financial, reporting, and exposure scope IDs must be distinct",
+        });
+    const dimensions = new Set(definition.dimensions.map((dimension) => dimension.id));
+    for (const [scopeName, selectedScope] of [
+        ["financial", definition.scopes.financial],
+        ["reporting", definition.scopes.reporting],
+    ])
+        for (const dimensionId of predicateDimensions(selectedScope.predicate))
+            if (!dimensions.has(dimensionId))
+                context.addIssue({
+                    code: z.ZodIssueCode.custom,
+                    path: ["scopes", scopeName, "predicate"],
+                    message: `Predicate references unknown dimension ${dimensionId}`,
+                });
+    definition.exposures.forEach((exposure, index) => {
+        if (!definition.scopes.exposure.some((scope) => scope.id === exposure.scopeId))
+            context.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ["exposures", index, "scopeId"],
+                message: "Exposure references an unknown exposure scope",
+            });
+    });
+    definition.measures.forEach((measure, index) => {
+        if (measure.populationScopeId !== definition.scopes.financial.id &&
+            measure.populationScopeId !== definition.scopes.reporting.id)
+            context.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ["measures", index, "populationScopeId"],
+                message: "Measure references an unknown population scope",
+            });
+        if (measure.developmentSemantics === "cumulative" &&
+            measure.statistic.kind !== "sum")
+            context.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ["measures", index, "statistic"],
+                message: "Cumulative measures initially support explicit-evaluation sums only",
+            });
+        for (const dimensionId of measure.condition === undefined ? [] : predicateDimensions(measure.condition))
+            if (!dimensions.has(dimensionId))
+                context.addIssue({ code: z.ZodIssueCode.custom, path: ["measures", index, "condition"], message: `Measure condition references unknown dimension ${dimensionId}` });
+    });
+    const measureIds = new Set(definition.measures.map((measure) => measure.id));
+    definition.financialTerms.forEach((term, index) => {
+        if (!measureIds.has(term.measureId))
+            context.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ["financialTerms", index, "measureId"],
+                message: "Financial term references an unknown measure",
+            });
+    });
+    if (definition.period.grouping.kind === "policy-schedule") {
+        const periodIds = new Set(definition.policySchedule.map((period) => period.id));
+        definition.period.grouping.periodIds.forEach((id, index) => {
+            if (!periodIds.has(id))
+                context.addIssue({
+                    code: z.ZodIssueCode.custom,
+                    path: ["period", "grouping", "periodIds", index],
+                    message: "Policy grouping references an unknown policy period",
+                });
+        });
+    }
+});
+const recipeStep = z.discriminatedUnion("kind", [
+    z.object({ kind: z.literal("prepare-history"), historyContractId: token }).strict(),
+    z.object({ kind: z.literal("assign-periods"), analysisDefinitionId: token }).strict(),
+    z.object({ kind: z.literal("earn-exposure"), exposureMeasureIds: z.array(token) }).strict(),
+    z.object({ kind: z.literal("apply-financial-terms"), termIds: z.array(token) }).strict(),
+    z.object({ kind: z.literal("apply-financial-pipeline"), amountMeasureId: token, stageIds: z.array(token).min(1) }).strict(),
+    z.object({ kind: z.literal("calculate"), measureIds: z.array(token) }).strict(),
+    z.object({ kind: z.literal("adapt-diagnostics"), diagnosticDefinitionId: token }).strict(),
+]);
+export const analysisRecipeSchema = z
+    .object({
+    recipeContractVersion: z.literal(ANALYSIS_RECIPE_CONTRACT_VERSION),
+    id: token,
+    version: token,
+    analysisDefinitionId: token,
+    steps: z.array(recipeStep).min(1),
+    requiredCapabilities: z.array(z.enum(CUSTOMIZATION_CAPABILITIES)),
+    parameters: z.record(token, jsonValue),
+})
+    .strict()
+    .superRefine((recipe, context) => {
+    if (new Set(recipe.requiredCapabilities).size !== recipe.requiredCapabilities.length)
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["requiredCapabilities"],
+            message: "Required capabilities must be unique",
+        });
+    const firstPrepare = recipe.steps.findIndex((step) => step.kind === "prepare-history");
+    const firstAssign = recipe.steps.findIndex((step) => step.kind === "assign-periods");
+    const firstCalculate = recipe.steps.findIndex((step) => step.kind === "calculate");
+    if (firstPrepare !== 0)
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["steps"],
+            message: "Recipe must begin with prepare-history",
+        });
+    if (firstAssign < 0 || (firstPrepare >= 0 && firstAssign < firstPrepare))
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["steps"],
+            message: "Recipe must assign periods after preparing history",
+        });
+    if (firstCalculate < 0 || (firstAssign >= 0 && firstCalculate < firstAssign))
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["steps"],
+            message: "Recipe must calculate after assigning periods",
+        });
+    recipe.steps.forEach((step, index) => {
+        if (step.kind === "assign-periods" && step.analysisDefinitionId !== recipe.analysisDefinitionId)
+            context.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ["steps", index, "analysisDefinitionId"],
+                message: "assign-periods must reference the recipe analysis definition",
+            });
+    });
+});
+const capabilityFinding = z.object({
+    code: z.enum([
+        "missing-prerequisite",
+        "unsupported-operation",
+        "incompatible-scope",
+        "resource-limit",
+        "ambiguous-attribution",
+        "incomplete-financial-population",
+        "incompatible-semantics",
+        "invalid-configuration",
+    ]),
+    capability: z.enum(CUSTOMIZATION_CAPABILITIES),
+    path: z.string(),
+    message: z.string(),
+    requiredFields: z.array(z.string()).optional(),
+}).strict();
+const identity = z.string().regex(/^fnv1a64-jcs-v1:[0-9a-f]{16}$/);
+export const analysisResultSchema = z.object({
+    resultContractVersion: z.literal(ANALYSIS_RESULT_CONTRACT_VERSION),
+    datasetRevisionId: identity,
+    analysisDefinitionId: token,
+    recipeId: token,
+    calculationIdentity: identity,
+    lineageIdentity: identity,
+    values: z.array(z.object({
+        measureId: token,
+        unit: token,
+        coordinates: z.record(token, scalar),
+        value: finite.nullable(),
+        status: z.enum(["available", "unavailable"]),
+        contributingObservations: z.number().int().nonnegative(),
+        excludedObservations: z.number().int().nonnegative(),
+        exact: z.literal(true),
+        numerator: finite.nullable(),
+        denominator: finite.nullable(),
+        findings: z.array(capabilityFinding),
+    }).strict()),
+}).strict();
+const scenarioChange = z.discriminatedUnion("kind", [
+    z.object({ kind: z.literal("financial-term-limit"), termId: token, limit: finite.positive().nullable() }).strict(),
+    z.object({ kind: z.literal("financial-term-attachment"), termId: token, amount: finite.nonnegative() }).strict(),
+    z.object({ kind: z.literal("reporting-predicate"), predicate }).strict(),
+]);
+export const analysisScenarioSchema = z.object({
+    id: token,
+    changes: z.array(scenarioChange).min(1).max(100),
+}).strict().superRefine((scenario, context) => {
+    const keys = scenario.changes.map((change) => change.kind === "reporting-predicate" ? change.kind : `${change.kind}:${change.termId}`);
+    if (new Set(keys).size !== keys.length)
+        context.addIssue({ code: z.ZodIssueCode.custom, path: ["changes"], message: "Scenario changes must target each parameter at most once" });
+});
+export const analysisScenarioGridSchema = z
+    .object({
+    id: token,
+    axes: z
+        .array(z
+        .object({
+        id: token,
+        options: z
+            .array(z.object({ id: token, change: scenarioChange.nullable() }).strict())
+            .min(1),
+    })
+        .strict()
+        .superRefine((axis, context) => {
+        if (new Set(axis.options.map((option) => option.id)).size !== axis.options.length)
+            context.addIssue({ code: z.ZodIssueCode.custom, path: ["options"], message: "Scenario grid option IDs must be unique within an axis" });
+    }))
+        .min(1),
+})
+    .strict()
+    .superRefine((grid, context) => {
+    if (new Set(grid.axes.map((axis) => axis.id)).size !== grid.axes.length)
+        context.addIssue({ code: z.ZodIssueCode.custom, path: ["axes"], message: "Scenario grid axis IDs must be unique" });
+});
+export const analysisClassificationSchema = z.discriminatedUnion("kind", [
+    z.object({
+        kind: z.literal("numeric-bands"), id: token, dimensionId: token,
+        groups: z.array(z.object({ id: token, minimum: finite.optional(), maximum: finite.optional(), includeMinimum: z.boolean(), includeMaximum: z.boolean() }).strict()),
+        overlapPolicy: z.enum(["reject", "allow"]), gapPolicy: z.enum(["unclassified", "reject"]),
+    }).strict(),
+    z.object({
+        kind: z.literal("lookup"), id: token, dimensionId: token,
+        entries: z.array(z.object({ value: scalar, groupId: token }).strict()), unmappedPolicy: z.enum(["unclassified", "reject"]),
+    }).strict(),
+    z.object({
+        kind: z.literal("hierarchy"), id: token, dimensionId: token,
+        entries: z.array(z.object({ value: scalar, groupIds: z.array(token).min(1) }).strict()), unmappedPolicy: z.enum(["unclassified", "reject"]),
+    }).strict(),
+    z.object({
+        kind: z.literal("rules"), id: token,
+        groups: z.array(z.object({ id: token, predicate }).strict()), overlapPolicy: z.enum(["reject", "allow"]), gapPolicy: z.enum(["unclassified", "reject"]),
+    }).strict(),
+]);
+function zodIssues(error, domain) {
+    return error.issues.map((issue) => ({
+        domain,
+        code: issue.code === z.ZodIssueCode.unrecognized_keys ? "unknown-key" : "invalid-configuration",
+        path: `$${issue.path.map((part) => (typeof part === "number" ? `[${part}]` : `.${part}`)).join("")}`,
+        message: issue.message,
+    }));
+}
+function parseContract(value, schema, domain) {
+    const preflight = diagnosticJsonPreflight(value, domain);
+    if (preflight.length > 0)
+        throw new DiagnosticValidationError(preflight);
+    const parsed = schema.safeParse(value);
+    if (!parsed.success)
+        throw new DiagnosticValidationError(zodIssues(parsed.error, domain));
+    return parsed.data;
+}
+export function parseHistoricalDatasetInput(value) {
+    return parseContract(value, historicalDatasetInputSchema, "input");
+}
+export function parseCustomizationResourceLimits(value) {
+    return parseContract(value, customizationResourceLimitsSchema, "configuration");
+}
+export function parseHistoricalObservationRecord(value) {
+    return parseContract(value, historicalRecordSchema, "input");
+}
+export function parseAnalysisDefinition(value) {
+    return parseContract(value, analysisDefinitionSchema, "definition");
+}
+export function parseAnalysisRecipe(value) {
+    return parseContract(value, analysisRecipeSchema, "configuration");
+}
+export function parseAnalysisResult(value) {
+    return parseContract(value, analysisResultSchema, "input");
+}
+export function parseAnalysisScenario(value) {
+    return parseContract(value, analysisScenarioSchema, "configuration");
+}
+export function parseAnalysisScenarioGrid(value) {
+    return parseContract(value, analysisScenarioGridSchema, "configuration");
+}
+export function parseCustomizationExposureObservations(value) {
+    return parseContract(value, z.array(customizationExposureObservationSchema), "input");
+}
+export function parseExposureAllocationTargets(value) {
+    return parseContract(value, z.array(exposureAllocationTargetSchema), "input");
+}
+export function parseExposureRevisionSelection(value) {
+    return parseContract(value, exposureRevisionSelectionSchema, "configuration");
+}
+export function parseExposureLevelSchedule(value) {
+    return parseContract(value, exposureLevelScheduleSchema, "input");
+}
+export function parseAnalysisClassification(value) {
+    return parseContract(value, analysisClassificationSchema, "configuration");
+}
+//# sourceMappingURL=customizationContracts.js.map