import { type AnalysisDefinition, type AnalysisMeasureExpression, 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.ZodEffects<z.ZodRecord<z.ZodEffects<z.ZodType<string, z.ZodTypeDef, string>, string, string>, z.ZodUnion<[z.ZodNumber, z.ZodNull]>>, Record<string, number | null>, Record<string, number | null>>;
    status: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
    dimensions: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodEffects<z.ZodType<string, z.ZodTypeDef, string>, 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">]>>, Record<string, string | number | boolean | (string | number | boolean | null)[] | null>, Record<string, string | number | boolean | (string | number | boolean | null)[] | null>>>;
    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, {
    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;
    claimId: 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;
}, {
    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;
    claimId: 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;
}>, {
    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;
    claimId: 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;
}, {
    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;
    claimId: 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;
}>;
/** Prepared observations retain the same measure/dimension key behavior as historical records. */
export declare const preparedHistoricalObservationSchema: z.ZodObject<{
    sourceNamespace: z.ZodEffects<z.ZodString, string, string>;
    claimId: z.ZodEffects<z.ZodString, string, string>;
    evaluationDate: z.ZodEffects<z.ZodString, string, string>;
    observationKind: z.ZodOptional<z.ZodEnum<["observed-snapshot", "carried-forward", "reconstructed-from-changes"]>>;
    accidentDate: z.ZodNullable<z.ZodEffects<z.ZodString, string, string>>;
    reportDate: z.ZodNullable<z.ZodEffects<z.ZodString, string, string>>;
    status: z.ZodNullable<z.ZodEffects<z.ZodString, string, string>>;
    measures: z.ZodEffects<z.ZodRecord<z.ZodEffects<z.ZodType<string, z.ZodTypeDef, string>, string, string>, z.ZodUnion<[z.ZodNumber, z.ZodNull]>>, Record<string, number | null>, Record<string, number | null>>;
    dimensions: z.ZodEffects<z.ZodRecord<z.ZodEffects<z.ZodType<string, z.ZodTypeDef, string>, 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">]>>, Record<string, string | number | boolean | (string | number | boolean | null)[] | null>, Record<string, string | number | boolean | (string | number | boolean | null)[] | null>>;
    relationships: 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;
    }>;
    sources: z.ZodArray<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;
    }>, "many">;
}, "strict", z.ZodTypeAny, {
    status: string | null;
    evaluationDate: string;
    dimensions: Record<string, string | number | boolean | (string | number | boolean | null)[] | null>;
    sourceNamespace: string;
    claimId: string;
    accidentDate: string | null;
    reportDate: string | null;
    measures: Record<string, number | null>;
    relationships: {
        claimantIds?: string[] | undefined;
        occurrenceId?: string | undefined;
        policyIds?: string[] | undefined;
        coverageIds?: string[] | undefined;
    };
    sources: {
        artifactId: string;
        sourceFile?: string | undefined;
        sourceSheet?: string | undefined;
        sourceRow?: number | undefined;
    }[];
    observationKind?: "observed-snapshot" | "carried-forward" | "reconstructed-from-changes" | undefined;
}, {
    status: string | null;
    evaluationDate: string;
    dimensions: Record<string, string | number | boolean | (string | number | boolean | null)[] | null>;
    sourceNamespace: string;
    claimId: string;
    accidentDate: string | null;
    reportDate: string | null;
    measures: Record<string, number | null>;
    relationships: {
        claimantIds?: string[] | undefined;
        occurrenceId?: string | undefined;
        policyIds?: string[] | undefined;
        coverageIds?: string[] | undefined;
    };
    sources: {
        artifactId: string;
        sourceFile?: string | undefined;
        sourceSheet?: string | undefined;
        sourceRow?: number | undefined;
    }[];
    observationKind?: "observed-snapshot" | "carried-forward" | "reconstructed-from-changes" | 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>;
        additionalArtifacts: z.ZodOptional<z.ZodArray<z.ZodObject<{
            artifactId: z.ZodEffects<z.ZodString, string, string>;
            mappingVersion: z.ZodEffects<z.ZodString, string, string>;
        }, "strict", z.ZodTypeAny, {
            artifactId: string;
            mappingVersion: string;
        }, {
            artifactId: string;
            mappingVersion: string;
        }>, "many">>;
    }, "strict", z.ZodTypeAny, {
        artifactId: string;
        namespace: string;
        mappingVersion: string;
        additionalArtifacts?: {
            artifactId: string;
            mappingVersion: string;
        }[] | undefined;
    }, {
        artifactId: string;
        namespace: string;
        mappingVersion: string;
        additionalArtifacts?: {
            artifactId: string;
            mappingVersion: string;
        }[] | undefined;
    }>, "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.ZodEffects<z.ZodRecord<z.ZodEffects<z.ZodType<string, z.ZodTypeDef, string>, string, string>, z.ZodNumber>, Record<string, number>, Record<string, number>>;
        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, {
        source: {
            artifactId: string;
            sourceFile?: string | undefined;
            sourceSheet?: string | undefined;
            sourceRow?: number | undefined;
        };
        sourceNamespace: string;
        claimId: string;
        measures: Record<string, number>;
        asOfDate: string;
    }, {
        source: {
            artifactId: string;
            sourceFile?: string | undefined;
            sourceSheet?: string | undefined;
            sourceRow?: number | undefined;
        };
        sourceNamespace: string;
        claimId: 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.ZodEffects<z.ZodRecord<z.ZodEffects<z.ZodType<string, z.ZodTypeDef, string>, string, string>, z.ZodUnion<[z.ZodNumber, z.ZodNull]>>, Record<string, number | null>, Record<string, number | null>>;
        status: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
        dimensions: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodEffects<z.ZodType<string, z.ZodTypeDef, string>, 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">]>>, Record<string, string | number | boolean | (string | number | boolean | null)[] | null>, Record<string, string | number | boolean | (string | number | boolean | null)[] | null>>>;
        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, {
        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;
        claimId: 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;
    }, {
        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;
        claimId: 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;
    }>, {
        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;
        claimId: 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;
    }, {
        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;
        claimId: 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, {
    revisionView: {
        kind: "as-known";
        knowledgeCutoff: string;
    } | {
        kind: "restated";
    };
    revisionPrecedence: "sequence" | "corrected-at";
    sources: {
        artifactId: string;
        namespace: string;
        mappingVersion: string;
        additionalArtifacts?: {
            artifactId: string;
            mappingVersion: string;
        }[] | undefined;
    }[];
    historyContractVersion: "actuarial-history/1";
    datasetId: string;
    historyMode: "full-snapshots" | "changes" | "mixed";
    missingSnapshotRecord: "unknown" | "carried-forward";
    records: {
        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;
        claimId: 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?: {
        source: {
            artifactId: string;
            sourceFile?: string | undefined;
            sourceSheet?: string | undefined;
            sourceRow?: number | undefined;
        };
        sourceNamespace: string;
        claimId: string;
        measures: Record<string, number>;
        asOfDate: string;
    }[] | undefined;
}, {
    revisionView: {
        kind: "as-known";
        knowledgeCutoff: string;
    } | {
        kind: "restated";
    };
    revisionPrecedence: "sequence" | "corrected-at";
    sources: {
        artifactId: string;
        namespace: string;
        mappingVersion: string;
        additionalArtifacts?: {
            artifactId: string;
            mappingVersion: string;
        }[] | undefined;
    }[];
    historyContractVersion: "actuarial-history/1";
    datasetId: string;
    historyMode: "full-snapshots" | "changes" | "mixed";
    missingSnapshotRecord: "unknown" | "carried-forward";
    records: {
        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;
        claimId: 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?: {
        source: {
            artifactId: string;
            sourceFile?: string | undefined;
            sourceSheet?: string | undefined;
            sourceRow?: number | undefined;
        };
        sourceNamespace: string;
        claimId: string;
        measures: Record<string, number>;
        asOfDate: string;
    }[] | undefined;
}>, {
    revisionView: {
        kind: "as-known";
        knowledgeCutoff: string;
    } | {
        kind: "restated";
    };
    revisionPrecedence: "sequence" | "corrected-at";
    sources: {
        artifactId: string;
        namespace: string;
        mappingVersion: string;
        additionalArtifacts?: {
            artifactId: string;
            mappingVersion: string;
        }[] | undefined;
    }[];
    historyContractVersion: "actuarial-history/1";
    datasetId: string;
    historyMode: "full-snapshots" | "changes" | "mixed";
    missingSnapshotRecord: "unknown" | "carried-forward";
    records: {
        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;
        claimId: 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?: {
        source: {
            artifactId: string;
            sourceFile?: string | undefined;
            sourceSheet?: string | undefined;
            sourceRow?: number | undefined;
        };
        sourceNamespace: string;
        claimId: string;
        measures: Record<string, number>;
        asOfDate: string;
    }[] | undefined;
}, {
    revisionView: {
        kind: "as-known";
        knowledgeCutoff: string;
    } | {
        kind: "restated";
    };
    revisionPrecedence: "sequence" | "corrected-at";
    sources: {
        artifactId: string;
        namespace: string;
        mappingVersion: string;
        additionalArtifacts?: {
            artifactId: string;
            mappingVersion: string;
        }[] | undefined;
    }[];
    historyContractVersion: "actuarial-history/1";
    datasetId: string;
    historyMode: "full-snapshots" | "changes" | "mixed";
    missingSnapshotRecord: "unknown" | "carried-forward";
    records: {
        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;
        claimId: 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?: {
        source: {
            artifactId: string;
            sourceFile?: string | undefined;
            sourceSheet?: string | undefined;
            sourceRow?: number | undefined;
        };
        sourceNamespace: string;
        claimId: string;
        measures: Record<string, number>;
        asOfDate: string;
    }[] | undefined;
}>;
export declare const financialTermSchema: 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, {
    id: string;
    measureId: string;
    kind: "claim-layer" | "occurrence-layer";
    attachment: number;
    limit: number | null;
    allocation: "proportional";
}, {
    id: string;
    measureId: string;
    kind: "claim-layer" | "occurrence-layer";
    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, {
    id: string;
    measureId: string;
    kind: "policy-aggregate";
    limit: number | null;
    allocation: "proportional" | "chronological";
    deductible: number;
}, {
    id: string;
    measureId: string;
    kind: "policy-aggregate";
    limit: number | null;
    allocation: "proportional" | "chronological";
    deductible: number;
}>]>;
/** Shared measure contract used by recipe definitions and standalone statistic boundaries. */
export declare const analysisMeasureDefinitionSchema: 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.ZodLiteral<"positive">;
    }, "strict", z.ZodTypeAny, {
        kind: "ratio";
        numeratorMeasureId: string;
        denominatorMeasureId: string;
        scale: number;
        denominatorRule: "positive";
    }, {
        kind: "ratio";
        numeratorMeasureId: string;
        denominatorMeasureId: string;
        scale: number;
        denominatorRule: "positive";
    }>, 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";
    }>]>;
    unitFactors: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodRecord<z.ZodEffects<z.ZodType<string, z.ZodTypeDef, string>, string, string>, z.ZodNumber>, Record<string, number>, Record<string, number>>, Record<string, number>, Record<string, number>>>;
    populationScopeId: z.ZodEffects<z.ZodString, string, string>;
    condition: z.ZodOptional<z.ZodType<AnalysisPredicate, z.ZodTypeDef, AnalysisPredicate>>;
}, "strict", z.ZodTypeAny, {
    id: string;
    unit: string;
    developmentSemantics: "cumulative" | "incremental" | "point-in-time";
    statistic: {
        measureId: string;
        kind: "sum";
    } | {
        kind: "ratio";
        numeratorMeasureId: string;
        denominatorMeasureId: string;
        scale: number;
        denominatorRule: "positive";
    } | {
        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;
    unitFactors?: Record<string, number> | undefined;
    condition?: AnalysisPredicate | undefined;
}, {
    id: string;
    unit: string;
    developmentSemantics: "cumulative" | "incremental" | "point-in-time";
    statistic: {
        measureId: string;
        kind: "sum";
    } | {
        kind: "ratio";
        numeratorMeasureId: string;
        denominatorMeasureId: string;
        scale: number;
        denominatorRule: "positive";
    } | {
        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;
    unitFactors?: Record<string, number> | undefined;
    condition?: AnalysisPredicate | 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: "point-in-time" | "interval" | "already-earned";
            reportingFilterEffect: "none" | "matching-exposure-dimensions";
            valuationSelection?: "exact" | "origin-static" | "latest-on-or-before" | undefined;
        }, {
            id: string;
            populationKeys: string[];
            timeBasis: "point-in-time" | "interval" | "already-earned";
            reportingFilterEffect: "none" | "matching-exposure-dimensions";
            valuationSelection?: "exact" | "origin-static" | "latest-on-or-before" | undefined;
        }>, "many">;
    }, "strict", z.ZodTypeAny, {
        exposure: {
            id: string;
            populationKeys: string[];
            timeBasis: "point-in-time" | "interval" | "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: "point-in-time" | "interval" | "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;
            };
        };
    }>;
    policySchedule: z.ZodArray<z.ZodEffects<z.ZodObject<{
        id: z.ZodEffects<z.ZodString, string, string>;
        label: z.ZodEffects<z.ZodString, string, string>;
        scope: z.ZodEffects<z.ZodRecord<z.ZodEffects<z.ZodType<string, z.ZodTypeDef, string>, string, string>, z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>, Record<string, string | number | boolean | null>, Record<string, string | number | boolean | null>>;
        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: "month" | "quarter" | "year";
        }, {
            kind: "calendar";
            cadence: "month" | "quarter" | "year";
        }>, z.ZodObject<{
            kind: z.ZodLiteral<"fiscal">;
            cadence: z.ZodEnum<["quarter", "year"]>;
            startMonth: z.ZodNumber;
        }, "strict", z.ZodTypeAny, {
            kind: "fiscal";
            cadence: "quarter" | "year";
            startMonth: number;
        }, {
            kind: "fiscal";
            cadence: "quarter" | "year";
            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: "month" | "quarter" | "year";
        } | {
            kind: "fiscal";
            cadence: "quarter" | "year";
            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: "month" | "quarter" | "year";
        } | {
            kind: "fiscal";
            cadence: "quarter" | "year";
            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.ZodLiteral<"positive">;
        }, "strict", z.ZodTypeAny, {
            kind: "ratio";
            numeratorMeasureId: string;
            denominatorMeasureId: string;
            scale: number;
            denominatorRule: "positive";
        }, {
            kind: "ratio";
            numeratorMeasureId: string;
            denominatorMeasureId: string;
            scale: number;
            denominatorRule: "positive";
        }>, 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";
        }>]>;
        unitFactors: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodRecord<z.ZodEffects<z.ZodType<string, z.ZodTypeDef, string>, string, string>, z.ZodNumber>, Record<string, number>, Record<string, number>>, Record<string, number>, Record<string, number>>>;
        populationScopeId: z.ZodEffects<z.ZodString, string, string>;
        condition: z.ZodOptional<z.ZodType<AnalysisPredicate, z.ZodTypeDef, AnalysisPredicate>>;
    }, "strict", z.ZodTypeAny, {
        id: string;
        unit: string;
        developmentSemantics: "cumulative" | "incremental" | "point-in-time";
        statistic: {
            measureId: string;
            kind: "sum";
        } | {
            kind: "ratio";
            numeratorMeasureId: string;
            denominatorMeasureId: string;
            scale: number;
            denominatorRule: "positive";
        } | {
            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;
        unitFactors?: Record<string, number> | undefined;
        condition?: AnalysisPredicate | undefined;
    }, {
        id: string;
        unit: string;
        developmentSemantics: "cumulative" | "incremental" | "point-in-time";
        statistic: {
            measureId: string;
            kind: "sum";
        } | {
            kind: "ratio";
            numeratorMeasureId: string;
            denominatorMeasureId: string;
            scale: number;
            denominatorRule: "positive";
        } | {
            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;
        unitFactors?: Record<string, number> | undefined;
        condition?: AnalysisPredicate | undefined;
    }>, "many">;
    derivedMeasures: z.ZodOptional<z.ZodArray<z.ZodObject<{
        id: z.ZodEffects<z.ZodString, string, string>;
        expression: z.ZodType<AnalysisMeasureExpression, z.ZodTypeDef, AnalysisMeasureExpression>;
        developmentSemantics: z.ZodEnum<["cumulative", "incremental", "point-in-time"]>;
    }, "strict", z.ZodTypeAny, {
        id: string;
        developmentSemantics: "cumulative" | "incremental" | "point-in-time";
        expression: AnalysisMeasureExpression;
    }, {
        id: string;
        developmentSemantics: "cumulative" | "incremental" | "point-in-time";
        expression: AnalysisMeasureExpression;
    }>, "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, {
        id: string;
        measureId: string;
        kind: "claim-layer" | "occurrence-layer";
        attachment: number;
        limit: number | null;
        allocation: "proportional";
    }, {
        id: string;
        measureId: string;
        kind: "claim-layer" | "occurrence-layer";
        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, {
        id: string;
        measureId: string;
        kind: "policy-aggregate";
        limit: number | null;
        allocation: "proportional" | "chronological";
        deductible: number;
    }, {
        id: string;
        measureId: string;
        kind: "policy-aggregate";
        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, {
        id: string;
        kind: "scale";
        purpose: "trend" | "index";
        factor: number;
    }, {
        id: string;
        kind: "scale";
        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, {
        id: string;
        kind: "currency";
        fromUnit: string;
        toUnit: string;
        rate: number;
        rateDate: string;
    }, {
        id: string;
        kind: "currency";
        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, {
        id: string;
        kind: "include-expense" | "exclude-expense";
        expenseMeasureId: string;
    }, {
        id: string;
        kind: "include-expense" | "exclude-expense";
        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, {
        id: string;
        kind: "net-recovery";
        recoveryMeasureId: string;
    }, {
        id: string;
        kind: "net-recovery";
        recoveryMeasureId: string;
    }>]>, "many">>;
    classifications: z.ZodOptional<z.ZodArray<z.ZodLazy<z.ZodType<AnalysisClassificationDefinition, z.ZodTypeDef, AnalysisClassificationDefinition>>, "many">>;
}, "strict", z.ZodTypeAny, {
    id: string;
    dimensions: {
        type: "string" | "number" | "boolean" | "date" | "entity-reference";
        id: string;
        multiple: boolean;
    }[];
    measures: {
        id: string;
        unit: string;
        developmentSemantics: "cumulative" | "incremental" | "point-in-time";
        statistic: {
            measureId: string;
            kind: "sum";
        } | {
            kind: "ratio";
            numeratorMeasureId: string;
            denominatorMeasureId: string;
            scale: number;
            denominatorRule: "positive";
        } | {
            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;
        unitFactors?: Record<string, number> | undefined;
        condition?: AnalysisPredicate | undefined;
    }[];
    analysisContractVersion: "actuarial-analysis/1";
    version: string;
    scopes: {
        exposure: {
            id: string;
            populationKeys: string[];
            timeBasis: "point-in-time" | "interval" | "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;
            };
        };
    };
    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: "month" | "quarter" | "year";
        } | {
            kind: "fiscal";
            cadence: "quarter" | "year";
            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: ({
        id: string;
        measureId: string;
        kind: "claim-layer" | "occurrence-layer";
        attachment: number;
        limit: number | null;
        allocation: "proportional";
    } | {
        id: string;
        measureId: string;
        kind: "policy-aggregate";
        limit: number | null;
        allocation: "proportional" | "chronological";
        deductible: number;
    })[];
    derivedMeasures?: {
        id: string;
        developmentSemantics: "cumulative" | "incremental" | "point-in-time";
        expression: AnalysisMeasureExpression;
    }[] | undefined;
    financialAdjustments?: ({
        id: string;
        kind: "scale";
        purpose: "trend" | "index";
        factor: number;
    } | {
        id: string;
        kind: "currency";
        fromUnit: string;
        toUnit: string;
        rate: number;
        rateDate: string;
    } | {
        id: string;
        kind: "include-expense" | "exclude-expense";
        expenseMeasureId: string;
    } | {
        id: string;
        kind: "net-recovery";
        recoveryMeasureId: string;
    })[] | undefined;
    classifications?: AnalysisClassificationDefinition[] | undefined;
}, {
    id: string;
    dimensions: {
        type: "string" | "number" | "boolean" | "date" | "entity-reference";
        id: string;
        multiple: boolean;
    }[];
    measures: {
        id: string;
        unit: string;
        developmentSemantics: "cumulative" | "incremental" | "point-in-time";
        statistic: {
            measureId: string;
            kind: "sum";
        } | {
            kind: "ratio";
            numeratorMeasureId: string;
            denominatorMeasureId: string;
            scale: number;
            denominatorRule: "positive";
        } | {
            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;
        unitFactors?: Record<string, number> | undefined;
        condition?: AnalysisPredicate | undefined;
    }[];
    analysisContractVersion: "actuarial-analysis/1";
    version: string;
    scopes: {
        exposure: {
            id: string;
            populationKeys: string[];
            timeBasis: "point-in-time" | "interval" | "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;
            };
        };
    };
    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: "month" | "quarter" | "year";
        } | {
            kind: "fiscal";
            cadence: "quarter" | "year";
            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: ({
        id: string;
        measureId: string;
        kind: "claim-layer" | "occurrence-layer";
        attachment: number;
        limit: number | null;
        allocation: "proportional";
    } | {
        id: string;
        measureId: string;
        kind: "policy-aggregate";
        limit: number | null;
        allocation: "proportional" | "chronological";
        deductible: number;
    })[];
    derivedMeasures?: {
        id: string;
        developmentSemantics: "cumulative" | "incremental" | "point-in-time";
        expression: AnalysisMeasureExpression;
    }[] | undefined;
    financialAdjustments?: ({
        id: string;
        kind: "scale";
        purpose: "trend" | "index";
        factor: number;
    } | {
        id: string;
        kind: "currency";
        fromUnit: string;
        toUnit: string;
        rate: number;
        rateDate: string;
    } | {
        id: string;
        kind: "include-expense" | "exclude-expense";
        expenseMeasureId: string;
    } | {
        id: string;
        kind: "net-recovery";
        recoveryMeasureId: string;
    })[] | undefined;
    classifications?: AnalysisClassificationDefinition[] | undefined;
}>, {
    id: string;
    dimensions: {
        type: "string" | "number" | "boolean" | "date" | "entity-reference";
        id: string;
        multiple: boolean;
    }[];
    measures: {
        id: string;
        unit: string;
        developmentSemantics: "cumulative" | "incremental" | "point-in-time";
        statistic: {
            measureId: string;
            kind: "sum";
        } | {
            kind: "ratio";
            numeratorMeasureId: string;
            denominatorMeasureId: string;
            scale: number;
            denominatorRule: "positive";
        } | {
            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;
        unitFactors?: Record<string, number> | undefined;
        condition?: AnalysisPredicate | undefined;
    }[];
    analysisContractVersion: "actuarial-analysis/1";
    version: string;
    scopes: {
        exposure: {
            id: string;
            populationKeys: string[];
            timeBasis: "point-in-time" | "interval" | "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;
            };
        };
    };
    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: "month" | "quarter" | "year";
        } | {
            kind: "fiscal";
            cadence: "quarter" | "year";
            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: ({
        id: string;
        measureId: string;
        kind: "claim-layer" | "occurrence-layer";
        attachment: number;
        limit: number | null;
        allocation: "proportional";
    } | {
        id: string;
        measureId: string;
        kind: "policy-aggregate";
        limit: number | null;
        allocation: "proportional" | "chronological";
        deductible: number;
    })[];
    derivedMeasures?: {
        id: string;
        developmentSemantics: "cumulative" | "incremental" | "point-in-time";
        expression: AnalysisMeasureExpression;
    }[] | undefined;
    financialAdjustments?: ({
        id: string;
        kind: "scale";
        purpose: "trend" | "index";
        factor: number;
    } | {
        id: string;
        kind: "currency";
        fromUnit: string;
        toUnit: string;
        rate: number;
        rateDate: string;
    } | {
        id: string;
        kind: "include-expense" | "exclude-expense";
        expenseMeasureId: string;
    } | {
        id: string;
        kind: "net-recovery";
        recoveryMeasureId: string;
    })[] | undefined;
    classifications?: AnalysisClassificationDefinition[] | undefined;
}, {
    id: string;
    dimensions: {
        type: "string" | "number" | "boolean" | "date" | "entity-reference";
        id: string;
        multiple: boolean;
    }[];
    measures: {
        id: string;
        unit: string;
        developmentSemantics: "cumulative" | "incremental" | "point-in-time";
        statistic: {
            measureId: string;
            kind: "sum";
        } | {
            kind: "ratio";
            numeratorMeasureId: string;
            denominatorMeasureId: string;
            scale: number;
            denominatorRule: "positive";
        } | {
            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;
        unitFactors?: Record<string, number> | undefined;
        condition?: AnalysisPredicate | undefined;
    }[];
    analysisContractVersion: "actuarial-analysis/1";
    version: string;
    scopes: {
        exposure: {
            id: string;
            populationKeys: string[];
            timeBasis: "point-in-time" | "interval" | "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;
            };
        };
    };
    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: "month" | "quarter" | "year";
        } | {
            kind: "fiscal";
            cadence: "quarter" | "year";
            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: ({
        id: string;
        measureId: string;
        kind: "claim-layer" | "occurrence-layer";
        attachment: number;
        limit: number | null;
        allocation: "proportional";
    } | {
        id: string;
        measureId: string;
        kind: "policy-aggregate";
        limit: number | null;
        allocation: "proportional" | "chronological";
        deductible: number;
    })[];
    derivedMeasures?: {
        id: string;
        developmentSemantics: "cumulative" | "incremental" | "point-in-time";
        expression: AnalysisMeasureExpression;
    }[] | undefined;
    financialAdjustments?: ({
        id: string;
        kind: "scale";
        purpose: "trend" | "index";
        factor: number;
    } | {
        id: string;
        kind: "currency";
        fromUnit: string;
        toUnit: string;
        rate: number;
        rateDate: string;
    } | {
        id: string;
        kind: "include-expense" | "exclude-expense";
        expenseMeasureId: string;
    } | {
        id: string;
        kind: "net-recovery";
        recoveryMeasureId: string;
    })[] | undefined;
    classifications?: AnalysisClassificationDefinition[] | 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<"classify">;
        classificationIds: z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">;
    }, "strict", z.ZodTypeAny, {
        kind: "classify";
        classificationIds: string[];
    }, {
        kind: "classify";
        classificationIds: 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", "derived-analysis-measures", "reserving-triangle-adapter", "bounded-execution", "shared-financial-terms", "recipes", "scenarios"]>, "many">;
    parameters: z.ZodEffects<z.ZodRecord<z.ZodEffects<z.ZodType<string, z.ZodTypeDef, string>, string, string>, z.ZodType<JsonValue, z.ZodTypeDef, JsonValue>>, Record<string, JsonValue>, Record<string, 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: "classify";
        classificationIds: string[];
    } | {
        kind: "adapt-diagnostics";
        diagnosticDefinitionId: string;
    })[];
    requiredCapabilities: ("history-snapshots" | "history-changes" | "irregular-periods" | "exposure-earning" | "typed-populations" | "descriptive-statistics" | "derived-analysis-measures" | "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: "classify";
        classificationIds: string[];
    } | {
        kind: "adapt-diagnostics";
        diagnosticDefinitionId: string;
    })[];
    requiredCapabilities: ("history-snapshots" | "history-changes" | "irregular-periods" | "exposure-earning" | "typed-populations" | "descriptive-statistics" | "derived-analysis-measures" | "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: "classify";
        classificationIds: string[];
    } | {
        kind: "adapt-diagnostics";
        diagnosticDefinitionId: string;
    })[];
    requiredCapabilities: ("history-snapshots" | "history-changes" | "irregular-periods" | "exposure-earning" | "typed-populations" | "descriptive-statistics" | "derived-analysis-measures" | "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: "classify";
        classificationIds: string[];
    } | {
        kind: "adapt-diagnostics";
        diagnosticDefinitionId: string;
    })[];
    requiredCapabilities: ("history-snapshots" | "history-changes" | "irregular-periods" | "exposure-earning" | "typed-populations" | "descriptive-statistics" | "derived-analysis-measures" | "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<"financial-adjustment-factor">;
        adjustmentId: z.ZodEffects<z.ZodString, string, string>;
        factor: z.ZodNumber;
    }, "strict", z.ZodTypeAny, {
        kind: "financial-adjustment-factor";
        factor: number;
        adjustmentId: string;
    }, {
        kind: "financial-adjustment-factor";
        factor: number;
        adjustmentId: string;
    }>, 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: "financial-adjustment-factor";
        factor: number;
        adjustmentId: string;
    } | {
        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: "financial-adjustment-factor";
        factor: number;
        adjustmentId: string;
    } | {
        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: "financial-adjustment-factor";
        factor: number;
        adjustmentId: string;
    } | {
        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: "financial-adjustment-factor";
        factor: number;
        adjustmentId: string;
    } | {
        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