@nexalink/coding-contracts 0.1.0 → 0.3.0

package/dist/index.js

@@ -1,15 +1,59 @@
 // GENERATED FILE. DO NOT EDIT.
-// Source: nexalink-cloud contracts/ (run: npm run contracts:gen)
+// Source: coding-contracts schemas/ (run: bun run contracts:gen)
 import { z } from "zod";
 const escapeRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-// Canonical workflow constants (source: contracts/workflow-constants.json).
+const ISO_DATE_PATTERN = /^(\d{4})-(\d{2})-(\d{2})$/;
+const isIsoDate = (value) => {
+    const match = ISO_DATE_PATTERN.exec(value);
+    if (!match)
+        return false;
+    const year = Number(match[1]);
+    const month = Number(match[2]);
+    const day = Number(match[3]);
+    if (year < 1 || month < 1 || month > 12)
+        return false;
+    const leapYear = year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+    const daysInMonth = [
+        31,
+        leapYear ? 29 : 28,
+        31,
+        30,
+        31,
+        30,
+        31,
+        31,
+        30,
+        31,
+        30,
+        31,
+    ];
+    return day >= 1 && day <= daysInMonth[month - 1];
+};
+const RFC3339_DATETIME_PATTERN = /^(\d{4}-\d{2}-\d{2})T(?:[01]\d|2[0-3]):[0-5]\d:[0-5]\d(?:\.\d+)?(?:Z|[+-](?:[01]\d|2[0-3]):[0-5]\d)$/;
+const isRfc3339DateTime = (value) => {
+    const match = RFC3339_DATETIME_PATTERN.exec(value);
+    return match !== null && isIsoDate(match[1]);
+};
+// Canonical workflow constants (source: workflow-constants.json).
 export const RCM_WORKFLOW_ID = "rcm-coding-assistance";
 export const RCM_MODEL_POLICY_ID = "carecompass-rcm-review-v1";
 export const RCM_HUMAN_REVIEW_POLICY_ID = "qualified-coder-review-v1";
 export const RCM_OUTPUT_SCHEMA_NAME = "carecompass_rcm_grounded_review";
 export const RCM_HUMAN_REVIEW_INSTRUCTION = "Qualified human coder review is required before billing, coding, or claim submission.";
-// Schema wire versions (source: contracts/schemas/*.schema.json).
+// Schema wire versions (source: schemas/*.schema.json).
+export const CODING_CASE_CONTEXT_SCHEMA_VERSION = "coding-case-context-v1";
+export const CODING_CASE_PAYER_SCHEMA_VERSION = "coding-case-payer-v1";
+export const CODING_CASE_CLINICAL_SCHEMA_VERSION = "coding-case-clinical-v1";
+export const CODING_SERVICE_LINE_SCHEMA_VERSION = "coding-service-line-v1";
+export const CODING_EXTENSION_SCHEMA_VERSION = "coding-extension-v1";
+export const CODING_CASE_SCHEMA_VERSION = "coding-case-v1";
+export const CODING_BATCH_SCHEMA_VERSION = "coding-batch-v1";
+export const CODING_DECISION_LINE_SCHEMA_VERSION = "coding-decision-line-v1";
+export const CODING_EVIDENCE_SCHEMA_VERSION = "coding-evidence-v1";
+export const CODING_RULE_RESULT_SCHEMA_VERSION = "coding-rule-result-v1";
+export const CODING_REVIEWER_ACTION_SCHEMA_VERSION = "coding-reviewer-action-v1";
+export const CODING_DECISION_SCHEMA_VERSION = "coding-decision-v1";
 export const RCM_REFERENCE_SCHEMA_VERSION = "rcm-supporting-reference-v1";
 export const RCM_INPUT_SCHEMA_VERSION = "rcm-coding-input-v1";
 export const RCM_OUTPUT_SCHEMA_VERSION = "rcm-grounded-human-review-v2";
@@ -18,6 +62,4159 @@ export const RCM_RETRIEVAL_SCHEMA_VERSION = "rcm-retrieval-metadata-v1";
 export const RCM_RUNTIME_EVENT_SCHEMA_VERSION = "rcm-runtime-event-v1";
 export const RCM_WORKFLOW_CATALOG_SCHEMA_VERSION = "rcm-workflow-catalog-v1";
 // --------------------------------------------------------------------
+// CodingCaseContext (schema 1.0.0, wire coding-case-context-v1)
+// --------------------------------------------------------------------
+export const codingCaseContextSchema = z
+    .object({
+    setting: z.enum([
+        "professional",
+        "facility",
+        "pharmacy",
+        "dental",
+        "risk_adjustment",
+        "other",
+    ]),
+    otherSettingDescription: z
+        .string()
+        .min(1)
+        .max(120)
+        .refine((value) => value.trim().length > 0)
+        .optional(),
+    placeOfService: z.string().regex(new RegExp("^[0-9]{2}$")).optional(),
+    jurisdiction: z.string().min(1).max(80).optional(),
+    specialty: z.string().min(1).max(120).optional(),
+    provider: z
+        .object({
+        providerId: z.string().min(1).max(64).optional(),
+        npi: z.string().regex(new RegExp("^[0-9]{10}$")).optional(),
+        name: z.string().min(1).max(160).optional(),
+        role: z
+            .enum([
+            "rendering",
+            "billing",
+            "attending",
+            "supervising",
+            "ordering",
+            "referring",
+            "other",
+        ])
+            .optional(),
+        taxonomy: z.string().min(1).max(40).optional(),
+    })
+        .strict()
+        .optional(),
+    facility: z
+        .object({
+        facilityId: z.string().min(1).max(64).optional(),
+        name: z.string().min(1).max(160).optional(),
+        facilityType: z
+            .enum([
+            "hospital_inpatient",
+            "hospital_outpatient",
+            "clinic",
+            "ambulatory_surgery_center",
+            "nursing_facility",
+            "other",
+        ])
+            .optional(),
+    })
+        .strict()
+        .optional(),
+})
+    .strict();
+export function codingCaseContextValidationError(value) {
+    if (!isRecord(value))
+        return "context";
+    if (!["setting"].every((key) => key in value))
+        return "context_keys";
+    if (!Object.keys(value).every((key) => [
+        "setting",
+        "otherSettingDescription",
+        "placeOfService",
+        "jurisdiction",
+        "specialty",
+        "provider",
+        "facility",
+    ].includes(key)))
+        return "context_keys";
+    const value_setting = value["setting"];
+    if (typeof value_setting !== "string" ||
+        ![
+            "professional",
+            "facility",
+            "pharmacy",
+            "dental",
+            "risk_adjustment",
+            "other",
+        ].includes(value_setting))
+        return "context_setting";
+    if (value["otherSettingDescription"] !== undefined) {
+        const value_otherSettingDescription = value["otherSettingDescription"];
+        if (typeof value_otherSettingDescription !== "string" ||
+            value_otherSettingDescription.length < 1 ||
+            value_otherSettingDescription.length > 120 ||
+            value_otherSettingDescription.trim().length === 0)
+            return "context_other_setting";
+    }
+    if (value["placeOfService"] !== undefined) {
+        const value_placeOfService = value["placeOfService"];
+        if (typeof value_placeOfService !== "string" ||
+            !new RegExp("^[0-9]{2}$").test(value_placeOfService))
+            return "context_place_of_service";
+    }
+    if (value["jurisdiction"] !== undefined) {
+        const value_jurisdiction = value["jurisdiction"];
+        if (typeof value_jurisdiction !== "string" ||
+            value_jurisdiction.length < 1 ||
+            value_jurisdiction.length > 80)
+            return "context_jurisdiction";
+    }
+    if (value["specialty"] !== undefined) {
+        const value_specialty = value["specialty"];
+        if (typeof value_specialty !== "string" ||
+            value_specialty.length < 1 ||
+            value_specialty.length > 120)
+            return "context_specialty";
+    }
+    if (value["provider"] !== undefined) {
+        const value_provider = value["provider"];
+        if (!isRecord(value_provider))
+            return "context_provider";
+        if (!Object.keys(value_provider).every((key) => ["providerId", "npi", "name", "role", "taxonomy"].includes(key)))
+            return "context_provider_keys";
+        if (value_provider["providerId"] !== undefined) {
+            const value_provider_providerId = value_provider["providerId"];
+            if (typeof value_provider_providerId !== "string" ||
+                value_provider_providerId.length < 1 ||
+                value_provider_providerId.length > 64)
+                return "context_provider_id";
+        }
+        if (value_provider["npi"] !== undefined) {
+            const value_provider_npi = value_provider["npi"];
+            if (typeof value_provider_npi !== "string" ||
+                !new RegExp("^[0-9]{10}$").test(value_provider_npi))
+                return "context_provider_npi";
+        }
+        if (value_provider["name"] !== undefined) {
+            const value_provider_name = value_provider["name"];
+            if (typeof value_provider_name !== "string" ||
+                value_provider_name.length < 1 ||
+                value_provider_name.length > 160)
+                return "context_provider_name";
+        }
+        if (value_provider["role"] !== undefined) {
+            const value_provider_role = value_provider["role"];
+            if (typeof value_provider_role !== "string" ||
+                ![
+                    "rendering",
+                    "billing",
+                    "attending",
+                    "supervising",
+                    "ordering",
+                    "referring",
+                    "other",
+                ].includes(value_provider_role))
+                return "context_provider_role";
+        }
+        if (value_provider["taxonomy"] !== undefined) {
+            const value_provider_taxonomy = value_provider["taxonomy"];
+            if (typeof value_provider_taxonomy !== "string" ||
+                value_provider_taxonomy.length < 1 ||
+                value_provider_taxonomy.length > 40)
+                return "context_provider_taxonomy";
+        }
+    }
+    if (value["facility"] !== undefined) {
+        const value_facility = value["facility"];
+        if (!isRecord(value_facility))
+            return "context_facility";
+        if (!Object.keys(value_facility).every((key) => ["facilityId", "name", "facilityType"].includes(key)))
+            return "context_facility_keys";
+        if (value_facility["facilityId"] !== undefined) {
+            const value_facility_facilityId = value_facility["facilityId"];
+            if (typeof value_facility_facilityId !== "string" ||
+                value_facility_facilityId.length < 1 ||
+                value_facility_facilityId.length > 64)
+                return "context_facility_id";
+        }
+        if (value_facility["name"] !== undefined) {
+            const value_facility_name = value_facility["name"];
+            if (typeof value_facility_name !== "string" ||
+                value_facility_name.length < 1 ||
+                value_facility_name.length > 160)
+                return "context_facility_name";
+        }
+        if (value_facility["facilityType"] !== undefined) {
+            const value_facility_facilityType = value_facility["facilityType"];
+            if (typeof value_facility_facilityType !== "string" ||
+                ![
+                    "hospital_inpatient",
+                    "hospital_outpatient",
+                    "clinic",
+                    "ambulatory_surgery_center",
+                    "nursing_facility",
+                    "other",
+                ].includes(value_facility_facilityType))
+                return "context_facility_type";
+        }
+    }
+    return null;
+}
+export const validCodingCaseContext = (value) => codingCaseContextValidationError(value) === null;
+export const CodingCaseContextSchemaJson = {
+    $schema: "https://json-schema.org/draft/2020-12/schema",
+    $id: "https://nexalink.care/contracts/coding-case-context.schema.json",
+    title: "CodingCaseContext",
+    description: "Where and by whom the services were rendered: setting, place of service, jurisdiction, specialty, provider, and facility. Provider identifiers are direct identifiers and must never be promoted to analytics surfaces.",
+    version: "1.0.0",
+    type: "object",
+    additionalProperties: false,
+    required: ["setting"],
+    properties: {
+        setting: {
+            type: "string",
+            enum: [
+                "professional",
+                "facility",
+                "pharmacy",
+                "dental",
+                "risk_adjustment",
+                "other",
+            ],
+        },
+        otherSettingDescription: {
+            type: "string",
+            minLength: 1,
+            maxLength: 120,
+        },
+        placeOfService: {
+            type: "string",
+            pattern: "^[0-9]{2}$",
+        },
+        jurisdiction: {
+            type: "string",
+            minLength: 1,
+            maxLength: 80,
+        },
+        specialty: {
+            type: "string",
+            minLength: 1,
+            maxLength: 120,
+        },
+        provider: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+                providerId: {
+                    type: "string",
+                    minLength: 1,
+                    maxLength: 64,
+                },
+                npi: {
+                    type: "string",
+                    pattern: "^[0-9]{10}$",
+                },
+                name: {
+                    type: "string",
+                    minLength: 1,
+                    maxLength: 160,
+                },
+                role: {
+                    type: "string",
+                    enum: [
+                        "rendering",
+                        "billing",
+                        "attending",
+                        "supervising",
+                        "ordering",
+                        "referring",
+                        "other",
+                    ],
+                },
+                taxonomy: {
+                    type: "string",
+                    minLength: 1,
+                    maxLength: 40,
+                },
+            },
+        },
+        facility: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+                facilityId: {
+                    type: "string",
+                    minLength: 1,
+                    maxLength: 64,
+                },
+                name: {
+                    type: "string",
+                    minLength: 1,
+                    maxLength: 160,
+                },
+                facilityType: {
+                    type: "string",
+                    enum: [
+                        "hospital_inpatient",
+                        "hospital_outpatient",
+                        "clinic",
+                        "ambulatory_surgery_center",
+                        "nursing_facility",
+                        "other",
+                    ],
+                },
+            },
+        },
+    },
+};
+// --------------------------------------------------------------------
+// CodingCasePayer (schema 1.0.0, wire coding-case-payer-v1)
+// --------------------------------------------------------------------
+export const codingCasePayerSchema = z
+    .object({
+    payerName: z
+        .string()
+        .min(1)
+        .max(200)
+        .refine((value) => value.trim().length > 0),
+    payerId: z.string().min(1).max(120).optional(),
+    lineOfBusiness: z
+        .enum(["commercial", "government", "self_pay", "other"])
+        .optional(),
+    memberId: z.string().min(1).max(120).optional(),
+    plan: z
+        .object({
+        planName: z.string().min(1).max(200).optional(),
+        planId: z.string().min(1).max(120).optional(),
+    })
+        .strict()
+        .optional(),
+    program: z
+        .object({
+        programName: z.string().min(1).max(160).optional(),
+        programCode: z.string().min(1).max(80).optional(),
+    })
+        .strict()
+        .optional(),
+    contract: z
+        .object({
+        contractId: z.string().min(1).max(120).optional(),
+        contractVersion: z.string().min(1).max(40).optional(),
+        effectiveDate: z
+            .string()
+            .regex(new RegExp("^\\d{4}-\\d{2}-\\d{2}$"))
+            .refine(isIsoDate)
+            .optional(),
+    })
+        .strict()
+        .optional(),
+    mac: z
+        .object({
+        macId: z.string().min(1).max(40).optional(),
+        jurisdiction: z.string().min(1).max(80).optional(),
+    })
+        .strict()
+        .optional(),
+})
+    .strict();
+export function codingCasePayerValidationError(value) {
+    if (!isRecord(value))
+        return "payer";
+    if (!["payerName"].every((key) => key in value))
+        return "payer_keys";
+    if (!Object.keys(value).every((key) => [
+        "payerName",
+        "payerId",
+        "lineOfBusiness",
+        "memberId",
+        "plan",
+        "program",
+        "contract",
+        "mac",
+    ].includes(key)))
+        return "payer_keys";
+    const value_payerName = value["payerName"];
+    if (typeof value_payerName !== "string" ||
+        value_payerName.length < 1 ||
+        value_payerName.length > 200 ||
+        value_payerName.trim().length === 0)
+        return "payer_name";
+    if (value["payerId"] !== undefined) {
+        const value_payerId = value["payerId"];
+        if (typeof value_payerId !== "string" ||
+            value_payerId.length < 1 ||
+            value_payerId.length > 120)
+            return "payer_id";
+    }
+    if (value["lineOfBusiness"] !== undefined) {
+        const value_lineOfBusiness = value["lineOfBusiness"];
+        if (typeof value_lineOfBusiness !== "string" ||
+            !["commercial", "government", "self_pay", "other"].includes(value_lineOfBusiness))
+            return "payer_line_of_business";
+    }
+    if (value["memberId"] !== undefined) {
+        const value_memberId = value["memberId"];
+        if (typeof value_memberId !== "string" ||
+            value_memberId.length < 1 ||
+            value_memberId.length > 120)
+            return "payer_member_id";
+    }
+    if (value["plan"] !== undefined) {
+        const value_plan = value["plan"];
+        if (!isRecord(value_plan))
+            return "payer_plan";
+        if (!Object.keys(value_plan).every((key) => ["planName", "planId"].includes(key)))
+            return "payer_plan_keys";
+        if (value_plan["planName"] !== undefined) {
+            const value_plan_planName = value_plan["planName"];
+            if (typeof value_plan_planName !== "string" ||
+                value_plan_planName.length < 1 ||
+                value_plan_planName.length > 200)
+                return "payer_plan_name";
+        }
+        if (value_plan["planId"] !== undefined) {
+            const value_plan_planId = value_plan["planId"];
+            if (typeof value_plan_planId !== "string" ||
+                value_plan_planId.length < 1 ||
+                value_plan_planId.length > 120)
+                return "payer_plan_id";
+        }
+    }
+    if (value["program"] !== undefined) {
+        const value_program = value["program"];
+        if (!isRecord(value_program))
+            return "payer_program";
+        if (!Object.keys(value_program).every((key) => ["programName", "programCode"].includes(key)))
+            return "payer_program_keys";
+        if (value_program["programName"] !== undefined) {
+            const value_program_programName = value_program["programName"];
+            if (typeof value_program_programName !== "string" ||
+                value_program_programName.length < 1 ||
+                value_program_programName.length > 160)
+                return "payer_program_name";
+        }
+        if (value_program["programCode"] !== undefined) {
+            const value_program_programCode = value_program["programCode"];
+            if (typeof value_program_programCode !== "string" ||
+                value_program_programCode.length < 1 ||
+                value_program_programCode.length > 80)
+                return "payer_program_code";
+        }
+    }
+    if (value["contract"] !== undefined) {
+        const value_contract = value["contract"];
+        if (!isRecord(value_contract))
+            return "payer_contract";
+        if (!Object.keys(value_contract).every((key) => ["contractId", "contractVersion", "effectiveDate"].includes(key)))
+            return "payer_contract_keys";
+        if (value_contract["contractId"] !== undefined) {
+            const value_contract_contractId = value_contract["contractId"];
+            if (typeof value_contract_contractId !== "string" ||
+                value_contract_contractId.length < 1 ||
+                value_contract_contractId.length > 120)
+                return "payer_contract_id";
+        }
+        if (value_contract["contractVersion"] !== undefined) {
+            const value_contract_contractVersion = value_contract["contractVersion"];
+            if (typeof value_contract_contractVersion !== "string" ||
+                value_contract_contractVersion.length < 1 ||
+                value_contract_contractVersion.length > 40)
+                return "payer_contract_version";
+        }
+        if (value_contract["effectiveDate"] !== undefined) {
+            const value_contract_effectiveDate = value_contract["effectiveDate"];
+            if (typeof value_contract_effectiveDate !== "string" ||
+                !new RegExp("^\\d{4}-\\d{2}-\\d{2}$").test(value_contract_effectiveDate) ||
+                !isIsoDate(value_contract_effectiveDate))
+                return "payer_contract_effective_date";
+        }
+    }
+    if (value["mac"] !== undefined) {
+        const value_mac = value["mac"];
+        if (!isRecord(value_mac))
+            return "payer_mac";
+        if (!Object.keys(value_mac).every((key) => ["macId", "jurisdiction"].includes(key)))
+            return "payer_mac_keys";
+        if (value_mac["macId"] !== undefined) {
+            const value_mac_macId = value_mac["macId"];
+            if (typeof value_mac_macId !== "string" ||
+                value_mac_macId.length < 1 ||
+                value_mac_macId.length > 40)
+                return "payer_mac_id";
+        }
+        if (value_mac["jurisdiction"] !== undefined) {
+            const value_mac_jurisdiction = value_mac["jurisdiction"];
+            if (typeof value_mac_jurisdiction !== "string" ||
+                value_mac_jurisdiction.length < 1 ||
+                value_mac_jurisdiction.length > 80)
+                return "payer_mac_jurisdiction";
+        }
+    }
+    return null;
+}
+export const validCodingCasePayer = (value) => codingCasePayerValidationError(value) === null;
+export const CodingCasePayerSchemaJson = {
+    $schema: "https://json-schema.org/draft/2020-12/schema",
+    $id: "https://nexalink.care/contracts/coding-case-payer.schema.json",
+    title: "CodingCasePayer",
+    description: "Payer, plan, program, contract, and MAC context used to resolve applicability. memberId is a direct identifier and must never leave tenant-scoped storage for analytics surfaces. Contract and program fields are customer configuration, never immutable server policy.",
+    version: "1.0.0",
+    type: "object",
+    additionalProperties: false,
+    required: ["payerName"],
+    properties: {
+        payerName: {
+            type: "string",
+            minLength: 1,
+            maxLength: 200,
+        },
+        payerId: {
+            type: "string",
+            minLength: 1,
+            maxLength: 120,
+        },
+        lineOfBusiness: {
+            type: "string",
+            enum: ["commercial", "government", "self_pay", "other"],
+        },
+        memberId: {
+            type: "string",
+            minLength: 1,
+            maxLength: 120,
+        },
+        plan: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+                planName: {
+                    type: "string",
+                    minLength: 1,
+                    maxLength: 200,
+                },
+                planId: {
+                    type: "string",
+                    minLength: 1,
+                    maxLength: 120,
+                },
+            },
+        },
+        program: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+                programName: {
+                    type: "string",
+                    minLength: 1,
+                    maxLength: 160,
+                },
+                programCode: {
+                    type: "string",
+                    minLength: 1,
+                    maxLength: 80,
+                },
+            },
+        },
+        contract: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+                contractId: {
+                    type: "string",
+                    minLength: 1,
+                    maxLength: 120,
+                },
+                contractVersion: {
+                    type: "string",
+                    minLength: 1,
+                    maxLength: 40,
+                },
+                effectiveDate: {
+                    type: "string",
+                    pattern: "^\\d{4}-\\d{2}-\\d{2}$",
+                    format: "date",
+                },
+            },
+        },
+        mac: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+                macId: {
+                    type: "string",
+                    minLength: 1,
+                    maxLength: 40,
+                },
+                jurisdiction: {
+                    type: "string",
+                    minLength: 1,
+                    maxLength: 80,
+                },
+            },
+        },
+    },
+};
+// --------------------------------------------------------------------
+// CodingCaseClinical (schema 1.0.0, wire coding-case-clinical-v1)
+// --------------------------------------------------------------------
+export const codingCaseClinicalSchema = z
+    .object({
+    diagnoses: z
+        .array(z
+        .object({
+        diagnosisId: z.string().min(1).max(60),
+        code: z.string().min(1).max(32).optional(),
+        codeSystem: z.enum(["ICD-10-CM", "ICD-9-CM", "OTHER"]).optional(),
+        codeVersion: z.string().min(1).max(40).optional(),
+        description: z.string().min(1).max(240).optional(),
+        diagnosisType: z
+            .enum(["principal", "secondary", "complication", "other"])
+            .optional(),
+        onsetDate: z
+            .string()
+            .regex(new RegExp("^\\d{4}-\\d{2}-\\d{2}$"))
+            .refine(isIsoDate)
+            .optional(),
+        presentOnAdmission: z.boolean().optional(),
+    })
+        .strict())
+        .max(100)
+        .optional(),
+    procedures: z
+        .array(z
+        .object({
+        procedureId: z.string().min(1).max(60),
+        code: z.string().min(1).max(64).optional(),
+        codeSystem: z
+            .enum(["CPT", "HCPCS", "ICD-10-PCS", "OTHER"])
+            .optional(),
+        codeVersion: z.string().min(1).max(40).optional(),
+        description: z.string().min(1).max(240).optional(),
+        performedDate: z
+            .string()
+            .regex(new RegExp("^\\d{4}-\\d{2}-\\d{2}$"))
+            .refine(isIsoDate)
+            .optional(),
+    })
+        .strict())
+        .max(100)
+        .optional(),
+    medications: z
+        .array(z
+        .object({
+        medicationId: z.string().min(1).max(60),
+        code: z.string().min(1).max(64).optional(),
+        codeSystem: z.enum(["NDC", "RxNorm", "OTHER"]).optional(),
+        name: z.string().min(1).max(240).optional(),
+        dosage: z.string().min(1).max(120).optional(),
+        route: z.string().min(1).max(80).optional(),
+        administrationDate: z
+            .string()
+            .regex(new RegExp("^\\d{4}-\\d{2}-\\d{2}$"))
+            .refine(isIsoDate)
+            .optional(),
+    })
+        .strict())
+        .max(100)
+        .optional(),
+    supplies: z
+        .array(z
+        .object({
+        supplyId: z.string().min(1).max(60),
+        code: z.string().min(1).max(64).optional(),
+        codeSystem: z.enum(["HCPCS", "NDC", "OTHER"]).optional(),
+        name: z.string().min(1).max(240).optional(),
+        quantity: z.number().int().min(0).max(999999).optional(),
+        unitOfMeasure: z.string().min(1).max(20).optional(),
+        supplyDate: z
+            .string()
+            .regex(new RegExp("^\\d{4}-\\d{2}-\\d{2}$"))
+            .refine(isIsoDate)
+            .optional(),
+    })
+        .strict())
+        .max(100)
+        .optional(),
+    timeUnits: z
+        .array(z
+        .object({
+        timeId: z.string().min(1).max(60),
+        date: z
+            .string()
+            .regex(new RegExp("^\\d{4}-\\d{2}-\\d{2}$"))
+            .refine(isIsoDate),
+        durationMinutes: z.number().int().min(1).max(1440),
+        activityCode: z.string().min(1).max(80).optional(),
+        activityDescription: z.string().min(1).max(240).optional(),
+        clinicianRole: z
+            .enum([
+            "attending",
+            "physician",
+            "nurse_practitioner",
+            "physician_assistant",
+            "resident",
+            "other",
+        ])
+            .optional(),
+        placeOfService: z
+            .string()
+            .regex(new RegExp("^[0-9]{2}$"))
+            .optional(),
+    })
+        .strict())
+        .max(200)
+        .optional(),
+    notes: z
+        .array(z
+        .object({
+        noteId: z.string().min(1).max(60),
+        noteType: z.enum([
+            "clinical_narrative",
+            "procedure_narrative",
+            "authorization",
+            "correspondence",
+            "other",
+        ]),
+        note: z
+            .string()
+            .min(1)
+            .max(10000)
+            .refine((value) => value.trim().length > 0),
+    })
+        .strict())
+        .max(50)
+        .optional(),
+    sourceReferences: z
+        .array(z
+        .object({
+        sourceId: z.string().min(1).max(60),
+        sourceLabel: z.string().min(1).max(120),
+        documentId: z.string().min(1).max(240).optional(),
+        excerpt: z
+            .string()
+            .min(1)
+            .max(2000)
+            .refine((value) => value.trim().length > 0)
+            .optional(),
+        sourceVersion: z.string().min(1).max(80).optional(),
+        corpusScope: z.enum(["base", "tenant"]).optional(),
+        publisher: z.string().min(1).max(240).optional(),
+        effectiveDate: z
+            .string()
+            .regex(new RegExp("^\\d{4}-\\d{2}-\\d{2}$"))
+            .refine(isIsoDate)
+            .optional(),
+        retrievalDate: z
+            .string()
+            .regex(new RegExp("^\\d{4}-\\d{2}-\\d{2}$"))
+            .refine(isIsoDate)
+            .optional(),
+        coveredPayerProgram: z.string().min(1).max(240).optional(),
+        sourceUrl: z.string().min(1).max(2048).optional(),
+        documentHash: z.string().min(1).max(64).optional(),
+        capturedAt: z
+            .string()
+            .regex(new RegExp("^\\d{4}-\\d{2}-\\d{2}$"))
+            .refine(isIsoDate)
+            .optional(),
+        humanReviewRequired: z.literal(true).optional(),
+    })
+        .strict())
+        .max(50)
+        .optional(),
+})
+    .strict();
+export function codingCaseClinicalValidationError(value) {
+    if (!isRecord(value))
+        return "clinical";
+    if (!Object.keys(value).every((key) => [
+        "diagnoses",
+        "procedures",
+        "medications",
+        "supplies",
+        "timeUnits",
+        "notes",
+        "sourceReferences",
+    ].includes(key)))
+        return "clinical_keys";
+    if (value["diagnoses"] !== undefined) {
+        const value_diagnoses = value["diagnoses"];
+        if (!Array.isArray(value_diagnoses) || value_diagnoses.length > 100)
+            return "clinical_diagnoses";
+        for (const item of value_diagnoses) {
+            if (!isRecord(item))
+                return "clinical_diagnosis";
+            if (!["diagnosisId"].every((key) => key in item))
+                return "clinical_diagnosis_keys";
+            if (!Object.keys(item).every((key) => [
+                "diagnosisId",
+                "code",
+                "codeSystem",
+                "codeVersion",
+                "description",
+                "diagnosisType",
+                "onsetDate",
+                "presentOnAdmission",
+            ].includes(key)))
+                return "clinical_diagnosis_keys";
+            const item_diagnosisId = item["diagnosisId"];
+            if (typeof item_diagnosisId !== "string" ||
+                item_diagnosisId.length < 1 ||
+                item_diagnosisId.length > 60)
+                return "clinical_diagnosis_id";
+            if (item["code"] !== undefined) {
+                const item_code = item["code"];
+                if (typeof item_code !== "string" ||
+                    item_code.length < 1 ||
+                    item_code.length > 32)
+                    return "clinical_diagnosis_code";
+            }
+            if (item["codeSystem"] !== undefined) {
+                const item_codeSystem = item["codeSystem"];
+                if (typeof item_codeSystem !== "string" ||
+                    !["ICD-10-CM", "ICD-9-CM", "OTHER"].includes(item_codeSystem))
+                    return "clinical_diagnosis_code_system";
+            }
+            if (item["codeVersion"] !== undefined) {
+                const item_codeVersion = item["codeVersion"];
+                if (typeof item_codeVersion !== "string" ||
+                    item_codeVersion.length < 1 ||
+                    item_codeVersion.length > 40)
+                    return "clinical_diagnosis_code_version";
+            }
+            if (item["description"] !== undefined) {
+                const item_description = item["description"];
+                if (typeof item_description !== "string" ||
+                    item_description.length < 1 ||
+                    item_description.length > 240)
+                    return "clinical_diagnosis_description";
+            }
+            if (item["diagnosisType"] !== undefined) {
+                const item_diagnosisType = item["diagnosisType"];
+                if (typeof item_diagnosisType !== "string" ||
+                    !["principal", "secondary", "complication", "other"].includes(item_diagnosisType))
+                    return "clinical_diagnosis_type";
+            }
+            if (item["onsetDate"] !== undefined) {
+                const item_onsetDate = item["onsetDate"];
+                if (typeof item_onsetDate !== "string" ||
+                    !new RegExp("^\\d{4}-\\d{2}-\\d{2}$").test(item_onsetDate) ||
+                    !isIsoDate(item_onsetDate))
+                    return "clinical_diagnosis_onset_date";
+            }
+            if (item["presentOnAdmission"] !== undefined) {
+                const item_presentOnAdmission = item["presentOnAdmission"];
+                if (typeof item_presentOnAdmission !== "boolean")
+                    return "clinical_diagnosis_present_on_admission";
+            }
+        }
+    }
+    if (value["procedures"] !== undefined) {
+        const value_procedures = value["procedures"];
+        if (!Array.isArray(value_procedures) || value_procedures.length > 100)
+            return "clinical_procedures";
+        for (const item of value_procedures) {
+            if (!isRecord(item))
+                return "clinical_procedure";
+            if (!["procedureId"].every((key) => key in item))
+                return "clinical_procedure_keys";
+            if (!Object.keys(item).every((key) => [
+                "procedureId",
+                "code",
+                "codeSystem",
+                "codeVersion",
+                "description",
+                "performedDate",
+            ].includes(key)))
+                return "clinical_procedure_keys";
+            const item_procedureId = item["procedureId"];
+            if (typeof item_procedureId !== "string" ||
+                item_procedureId.length < 1 ||
+                item_procedureId.length > 60)
+                return "clinical_procedure_id";
+            if (item["code"] !== undefined) {
+                const item_code = item["code"];
+                if (typeof item_code !== "string" ||
+                    item_code.length < 1 ||
+                    item_code.length > 64)
+                    return "clinical_procedure_code";
+            }
+            if (item["codeSystem"] !== undefined) {
+                const item_codeSystem = item["codeSystem"];
+                if (typeof item_codeSystem !== "string" ||
+                    !["CPT", "HCPCS", "ICD-10-PCS", "OTHER"].includes(item_codeSystem))
+                    return "clinical_procedure_code_system";
+            }
+            if (item["codeVersion"] !== undefined) {
+                const item_codeVersion = item["codeVersion"];
+                if (typeof item_codeVersion !== "string" ||
+                    item_codeVersion.length < 1 ||
+                    item_codeVersion.length > 40)
+                    return "clinical_procedure_code_version";
+            }
+            if (item["description"] !== undefined) {
+                const item_description = item["description"];
+                if (typeof item_description !== "string" ||
+                    item_description.length < 1 ||
+                    item_description.length > 240)
+                    return "clinical_procedure_description";
+            }
+            if (item["performedDate"] !== undefined) {
+                const item_performedDate = item["performedDate"];
+                if (typeof item_performedDate !== "string" ||
+                    !new RegExp("^\\d{4}-\\d{2}-\\d{2}$").test(item_performedDate) ||
+                    !isIsoDate(item_performedDate))
+                    return "clinical_procedure_performed_date";
+            }
+        }
+    }
+    if (value["medications"] !== undefined) {
+        const value_medications = value["medications"];
+        if (!Array.isArray(value_medications) || value_medications.length > 100)
+            return "clinical_medications";
+        for (const item of value_medications) {
+            if (!isRecord(item))
+                return "clinical_medication";
+            if (!["medicationId"].every((key) => key in item))
+                return "clinical_medication_keys";
+            if (!Object.keys(item).every((key) => [
+                "medicationId",
+                "code",
+                "codeSystem",
+                "name",
+                "dosage",
+                "route",
+                "administrationDate",
+            ].includes(key)))
+                return "clinical_medication_keys";
+            const item_medicationId = item["medicationId"];
+            if (typeof item_medicationId !== "string" ||
+                item_medicationId.length < 1 ||
+                item_medicationId.length > 60)
+                return "clinical_medication_id";
+            if (item["code"] !== undefined) {
+                const item_code = item["code"];
+                if (typeof item_code !== "string" ||
+                    item_code.length < 1 ||
+                    item_code.length > 64)
+                    return "clinical_medication_code";
+            }
+            if (item["codeSystem"] !== undefined) {
+                const item_codeSystem = item["codeSystem"];
+                if (typeof item_codeSystem !== "string" ||
+                    !["NDC", "RxNorm", "OTHER"].includes(item_codeSystem))
+                    return "clinical_medication_code_system";
+            }
+            if (item["name"] !== undefined) {
+                const item_name = item["name"];
+                if (typeof item_name !== "string" ||
+                    item_name.length < 1 ||
+                    item_name.length > 240)
+                    return "clinical_medication_name";
+            }
+            if (item["dosage"] !== undefined) {
+                const item_dosage = item["dosage"];
+                if (typeof item_dosage !== "string" ||
+                    item_dosage.length < 1 ||
+                    item_dosage.length > 120)
+                    return "clinical_medication_dosage";
+            }
+            if (item["route"] !== undefined) {
+                const item_route = item["route"];
+                if (typeof item_route !== "string" ||
+                    item_route.length < 1 ||
+                    item_route.length > 80)
+                    return "clinical_medication_route";
+            }
+            if (item["administrationDate"] !== undefined) {
+                const item_administrationDate = item["administrationDate"];
+                if (typeof item_administrationDate !== "string" ||
+                    !new RegExp("^\\d{4}-\\d{2}-\\d{2}$").test(item_administrationDate) ||
+                    !isIsoDate(item_administrationDate))
+                    return "clinical_medication_administration_date";
+            }
+        }
+    }
+    if (value["supplies"] !== undefined) {
+        const value_supplies = value["supplies"];
+        if (!Array.isArray(value_supplies) || value_supplies.length > 100)
+            return "clinical_supplies";
+        for (const item of value_supplies) {
+            if (!isRecord(item))
+                return "clinical_supply";
+            if (!["supplyId"].every((key) => key in item))
+                return "clinical_supply_keys";
+            if (!Object.keys(item).every((key) => [
+                "supplyId",
+                "code",
+                "codeSystem",
+                "name",
+                "quantity",
+                "unitOfMeasure",
+                "supplyDate",
+            ].includes(key)))
+                return "clinical_supply_keys";
+            const item_supplyId = item["supplyId"];
+            if (typeof item_supplyId !== "string" ||
+                item_supplyId.length < 1 ||
+                item_supplyId.length > 60)
+                return "clinical_supply_id";
+            if (item["code"] !== undefined) {
+                const item_code = item["code"];
+                if (typeof item_code !== "string" ||
+                    item_code.length < 1 ||
+                    item_code.length > 64)
+                    return "clinical_supply_code";
+            }
+            if (item["codeSystem"] !== undefined) {
+                const item_codeSystem = item["codeSystem"];
+                if (typeof item_codeSystem !== "string" ||
+                    !["HCPCS", "NDC", "OTHER"].includes(item_codeSystem))
+                    return "clinical_supply_code_system";
+            }
+            if (item["name"] !== undefined) {
+                const item_name = item["name"];
+                if (typeof item_name !== "string" ||
+                    item_name.length < 1 ||
+                    item_name.length > 240)
+                    return "clinical_supply_name";
+            }
+            if (item["quantity"] !== undefined) {
+                const item_quantity = item["quantity"];
+                if (typeof item_quantity !== "number" ||
+                    Number.isNaN(item_quantity) ||
+                    !Number.isInteger(item_quantity) ||
+                    item_quantity < 0 ||
+                    item_quantity > 999999)
+                    return "clinical_supply_quantity";
+            }
+            if (item["unitOfMeasure"] !== undefined) {
+                const item_unitOfMeasure = item["unitOfMeasure"];
+                if (typeof item_unitOfMeasure !== "string" ||
+                    item_unitOfMeasure.length < 1 ||
+                    item_unitOfMeasure.length > 20)
+                    return "clinical_supply_unit_of_measure";
+            }
+            if (item["supplyDate"] !== undefined) {
+                const item_supplyDate = item["supplyDate"];
+                if (typeof item_supplyDate !== "string" ||
+                    !new RegExp("^\\d{4}-\\d{2}-\\d{2}$").test(item_supplyDate) ||
+                    !isIsoDate(item_supplyDate))
+                    return "clinical_supply_date";
+            }
+        }
+    }
+    if (value["timeUnits"] !== undefined) {
+        const value_timeUnits = value["timeUnits"];
+        if (!Array.isArray(value_timeUnits) || value_timeUnits.length > 200)
+            return "clinical_time_units";
+        for (const item of value_timeUnits) {
+            if (!isRecord(item))
+                return "clinical_time_unit";
+            if (!["timeId", "date", "durationMinutes"].every((key) => key in item))
+                return "clinical_time_unit_keys";
+            if (!Object.keys(item).every((key) => [
+                "timeId",
+                "date",
+                "durationMinutes",
+                "activityCode",
+                "activityDescription",
+                "clinicianRole",
+                "placeOfService",
+            ].includes(key)))
+                return "clinical_time_unit_keys";
+            const item_timeId = item["timeId"];
+            if (typeof item_timeId !== "string" ||
+                item_timeId.length < 1 ||
+                item_timeId.length > 60)
+                return "clinical_time_unit_id";
+            const item_date = item["date"];
+            if (typeof item_date !== "string" ||
+                !new RegExp("^\\d{4}-\\d{2}-\\d{2}$").test(item_date) ||
+                !isIsoDate(item_date))
+                return "clinical_time_unit_date";
+            const item_durationMinutes = item["durationMinutes"];
+            if (typeof item_durationMinutes !== "number" ||
+                Number.isNaN(item_durationMinutes) ||
+                !Number.isInteger(item_durationMinutes) ||
+                item_durationMinutes < 1 ||
+                item_durationMinutes > 1440)
+                return "clinical_time_unit_duration";
+            if (item["activityCode"] !== undefined) {
+                const item_activityCode = item["activityCode"];
+                if (typeof item_activityCode !== "string" ||
+                    item_activityCode.length < 1 ||
+                    item_activityCode.length > 80)
+                    return "clinical_time_unit_activity_code";
+            }
+            if (item["activityDescription"] !== undefined) {
+                const item_activityDescription = item["activityDescription"];
+                if (typeof item_activityDescription !== "string" ||
+                    item_activityDescription.length < 1 ||
+                    item_activityDescription.length > 240)
+                    return "clinical_time_unit_activity_description";
+            }
+            if (item["clinicianRole"] !== undefined) {
+                const item_clinicianRole = item["clinicianRole"];
+                if (typeof item_clinicianRole !== "string" ||
+                    ![
+                        "attending",
+                        "physician",
+                        "nurse_practitioner",
+                        "physician_assistant",
+                        "resident",
+                        "other",
+                    ].includes(item_clinicianRole))
+                    return "clinical_time_unit_clinician_role";
+            }
+            if (item["placeOfService"] !== undefined) {
+                const item_placeOfService = item["placeOfService"];
+                if (typeof item_placeOfService !== "string" ||
+                    !new RegExp("^[0-9]{2}$").test(item_placeOfService))
+                    return "clinical_time_unit_place_of_service";
+            }
+        }
+    }
+    if (value["notes"] !== undefined) {
+        const value_notes = value["notes"];
+        if (!Array.isArray(value_notes) || value_notes.length > 50)
+            return "clinical_notes";
+        for (const item of value_notes) {
+            if (!isRecord(item))
+                return "clinical_note";
+            if (!["noteId", "noteType", "note"].every((key) => key in item))
+                return "clinical_note_keys";
+            if (!Object.keys(item).every((key) => ["noteId", "noteType", "note"].includes(key)))
+                return "clinical_note_keys";
+            const item_noteId = item["noteId"];
+            if (typeof item_noteId !== "string" ||
+                item_noteId.length < 1 ||
+                item_noteId.length > 60)
+                return "clinical_note_id";
+            const item_noteType = item["noteType"];
+            if (typeof item_noteType !== "string" ||
+                ![
+                    "clinical_narrative",
+                    "procedure_narrative",
+                    "authorization",
+                    "correspondence",
+                    "other",
+                ].includes(item_noteType))
+                return "clinical_note_type";
+            const item_note = item["note"];
+            if (typeof item_note !== "string" ||
+                item_note.length < 1 ||
+                item_note.length > 10000 ||
+                item_note.trim().length === 0)
+                return "clinical_note_text";
+        }
+    }
+    if (value["sourceReferences"] !== undefined) {
+        const value_sourceReferences = value["sourceReferences"];
+        if (!Array.isArray(value_sourceReferences) ||
+            value_sourceReferences.length > 50)
+            return "clinical_source_references";
+        for (const item of value_sourceReferences) {
+            if (!isRecord(item))
+                return "clinical_source_reference";
+            if (!["sourceId", "sourceLabel"].every((key) => key in item))
+                return "clinical_source_reference_keys";
+            if (!Object.keys(item).every((key) => [
+                "sourceId",
+                "sourceLabel",
+                "documentId",
+                "excerpt",
+                "sourceVersion",
+                "corpusScope",
+                "publisher",
+                "effectiveDate",
+                "retrievalDate",
+                "coveredPayerProgram",
+                "sourceUrl",
+                "documentHash",
+                "capturedAt",
+                "humanReviewRequired",
+            ].includes(key)))
+                return "clinical_source_reference_keys";
+            const item_sourceId = item["sourceId"];
+            if (typeof item_sourceId !== "string" ||
+                item_sourceId.length < 1 ||
+                item_sourceId.length > 60)
+                return "clinical_source_reference_id";
+            const item_sourceLabel = item["sourceLabel"];
+            if (typeof item_sourceLabel !== "string" ||
+                item_sourceLabel.length < 1 ||
+                item_sourceLabel.length > 120)
+                return "clinical_source_reference_label";
+            if (item["documentId"] !== undefined) {
+                const item_documentId = item["documentId"];
+                if (typeof item_documentId !== "string" ||
+                    item_documentId.length < 1 ||
+                    item_documentId.length > 240)
+                    return "clinical_source_reference_document_id";
+            }
+            if (item["excerpt"] !== undefined) {
+                const item_excerpt = item["excerpt"];
+                if (typeof item_excerpt !== "string" ||
+                    item_excerpt.length < 1 ||
+                    item_excerpt.length > 2000 ||
+                    item_excerpt.trim().length === 0)
+                    return "clinical_source_reference_excerpt";
+            }
+            if (item["sourceVersion"] !== undefined) {
+                const item_sourceVersion = item["sourceVersion"];
+                if (typeof item_sourceVersion !== "string" ||
+                    item_sourceVersion.length < 1 ||
+                    item_sourceVersion.length > 80)
+                    return "clinical_source_reference_version";
+            }
+            if (item["corpusScope"] !== undefined) {
+                const item_corpusScope = item["corpusScope"];
+                if (typeof item_corpusScope !== "string" ||
+                    !["base", "tenant"].includes(item_corpusScope))
+                    return "clinical_source_reference_corpus_scope";
+            }
+            if (item["publisher"] !== undefined) {
+                const item_publisher = item["publisher"];
+                if (typeof item_publisher !== "string" ||
+                    item_publisher.length < 1 ||
+                    item_publisher.length > 240)
+                    return "clinical_source_reference_publisher";
+            }
+            if (item["effectiveDate"] !== undefined) {
+                const item_effectiveDate = item["effectiveDate"];
+                if (typeof item_effectiveDate !== "string" ||
+                    !new RegExp("^\\d{4}-\\d{2}-\\d{2}$").test(item_effectiveDate) ||
+                    !isIsoDate(item_effectiveDate))
+                    return "clinical_source_reference_effective_date";
+            }
+            if (item["retrievalDate"] !== undefined) {
+                const item_retrievalDate = item["retrievalDate"];
+                if (typeof item_retrievalDate !== "string" ||
+                    !new RegExp("^\\d{4}-\\d{2}-\\d{2}$").test(item_retrievalDate) ||
+                    !isIsoDate(item_retrievalDate))
+                    return "clinical_source_reference_retrieval_date";
+            }
+            if (item["coveredPayerProgram"] !== undefined) {
+                const item_coveredPayerProgram = item["coveredPayerProgram"];
+                if (typeof item_coveredPayerProgram !== "string" ||
+                    item_coveredPayerProgram.length < 1 ||
+                    item_coveredPayerProgram.length > 240)
+                    return "clinical_source_reference_covered_payer_program";
+            }
+            if (item["sourceUrl"] !== undefined) {
+                const item_sourceUrl = item["sourceUrl"];
+                if (typeof item_sourceUrl !== "string" ||
+                    item_sourceUrl.length < 1 ||
+                    item_sourceUrl.length > 2048)
+                    return "clinical_source_reference_url";
+            }
+            if (item["documentHash"] !== undefined) {
+                const item_documentHash = item["documentHash"];
+                if (typeof item_documentHash !== "string" ||
+                    item_documentHash.length < 1 ||
+                    item_documentHash.length > 64)
+                    return "clinical_source_reference_hash";
+            }
+            if (item["capturedAt"] !== undefined) {
+                const item_capturedAt = item["capturedAt"];
+                if (typeof item_capturedAt !== "string" ||
+                    !new RegExp("^\\d{4}-\\d{2}-\\d{2}$").test(item_capturedAt) ||
+                    !isIsoDate(item_capturedAt))
+                    return "clinical_source_reference_captured_at";
+            }
+            if (item["humanReviewRequired"] !== undefined) {
+                const item_humanReviewRequired = item["humanReviewRequired"];
+                if (typeof item_humanReviewRequired !== "boolean" ||
+                    item_humanReviewRequired !== true)
+                    return "clinical_source_reference_human_review_required";
+            }
+        }
+    }
+    return null;
+}
+export const validCodingCaseClinical = (value) => codingCaseClinicalValidationError(value) === null;
+export const CodingCaseClinicalSchemaJson = {
+    $schema: "https://json-schema.org/draft/2020-12/schema",
+    $id: "https://nexalink.care/contracts/coding-case-clinical.schema.json",
+    title: "CodingCaseClinical",
+    description: "Structured clinical and operational facts: diagnoses, procedures, medications, supplies, time entries, notes, and source references. Time entries keep duration and activity structured so workflows such as monthly multi-activity time aggregation never depend on free text for calculations.",
+    version: "1.0.0",
+    type: "object",
+    additionalProperties: false,
+    properties: {
+        diagnoses: {
+            type: "array",
+            maxItems: 100,
+            items: {
+                type: "object",
+                additionalProperties: false,
+                required: ["diagnosisId"],
+                properties: {
+                    diagnosisId: {
+                        type: "string",
+                        minLength: 1,
+                        maxLength: 60,
+                    },
+                    code: {
+                        type: "string",
+                        minLength: 1,
+                        maxLength: 32,
+                    },
+                    codeSystem: {
+                        type: "string",
+                        enum: ["ICD-10-CM", "ICD-9-CM", "OTHER"],
+                    },
+                    codeVersion: {
+                        type: "string",
+                        minLength: 1,
+                        maxLength: 40,
+                    },
+                    description: {
+                        type: "string",
+                        minLength: 1,
+                        maxLength: 240,
+                    },
+                    diagnosisType: {
+                        type: "string",
+                        enum: ["principal", "secondary", "complication", "other"],
+                    },
+                    onsetDate: {
+                        type: "string",
+                        pattern: "^\\d{4}-\\d{2}-\\d{2}$",
+                        format: "date",
+                    },
+                    presentOnAdmission: {
+                        type: "boolean",
+                    },
+                },
+            },
+        },
+        procedures: {
+            type: "array",
+            maxItems: 100,
+            items: {
+                type: "object",
+                additionalProperties: false,
+                required: ["procedureId"],
+                properties: {
+                    procedureId: {
+                        type: "string",
+                        minLength: 1,
+                        maxLength: 60,
+                    },
+                    code: {
+                        type: "string",
+                        minLength: 1,
+                        maxLength: 64,
+                    },
+                    codeSystem: {
+                        type: "string",
+                        enum: ["CPT", "HCPCS", "ICD-10-PCS", "OTHER"],
+                    },
+                    codeVersion: {
+                        type: "string",
+                        minLength: 1,
+                        maxLength: 40,
+                    },
+                    description: {
+                        type: "string",
+                        minLength: 1,
+                        maxLength: 240,
+                    },
+                    performedDate: {
+                        type: "string",
+                        pattern: "^\\d{4}-\\d{2}-\\d{2}$",
+                        format: "date",
+                    },
+                },
+            },
+        },
+        medications: {
+            type: "array",
+            maxItems: 100,
+            items: {
+                type: "object",
+                additionalProperties: false,
+                required: ["medicationId"],
+                properties: {
+                    medicationId: {
+                        type: "string",
+                        minLength: 1,
+                        maxLength: 60,
+                    },
+                    code: {
+                        type: "string",
+                        minLength: 1,
+                        maxLength: 64,
+                    },
+                    codeSystem: {
+                        type: "string",
+                        enum: ["NDC", "RxNorm", "OTHER"],
+                    },
+                    name: {
+                        type: "string",
+                        minLength: 1,
+                        maxLength: 240,
+                    },
+                    dosage: {
+                        type: "string",
+                        minLength: 1,
+                        maxLength: 120,
+                    },
+                    route: {
+                        type: "string",
+                        minLength: 1,
+                        maxLength: 80,
+                    },
+                    administrationDate: {
+                        type: "string",
+                        pattern: "^\\d{4}-\\d{2}-\\d{2}$",
+                        format: "date",
+                    },
+                },
+            },
+        },
+        supplies: {
+            type: "array",
+            maxItems: 100,
+            items: {
+                type: "object",
+                additionalProperties: false,
+                required: ["supplyId"],
+                properties: {
+                    supplyId: {
+                        type: "string",
+                        minLength: 1,
+                        maxLength: 60,
+                    },
+                    code: {
+                        type: "string",
+                        minLength: 1,
+                        maxLength: 64,
+                    },
+                    codeSystem: {
+                        type: "string",
+                        enum: ["HCPCS", "NDC", "OTHER"],
+                    },
+                    name: {
+                        type: "string",
+                        minLength: 1,
+                        maxLength: 240,
+                    },
+                    quantity: {
+                        type: "integer",
+                        minimum: 0,
+                        maximum: 999999,
+                    },
+                    unitOfMeasure: {
+                        type: "string",
+                        minLength: 1,
+                        maxLength: 20,
+                    },
+                    supplyDate: {
+                        type: "string",
+                        pattern: "^\\d{4}-\\d{2}-\\d{2}$",
+                        format: "date",
+                    },
+                },
+            },
+        },
+        timeUnits: {
+            type: "array",
+            maxItems: 200,
+            items: {
+                type: "object",
+                additionalProperties: false,
+                required: ["timeId", "date", "durationMinutes"],
+                properties: {
+                    timeId: {
+                        type: "string",
+                        minLength: 1,
+                        maxLength: 60,
+                    },
+                    date: {
+                        type: "string",
+                        pattern: "^\\d{4}-\\d{2}-\\d{2}$",
+                        format: "date",
+                    },
+                    durationMinutes: {
+                        type: "integer",
+                        minimum: 1,
+                        maximum: 1440,
+                    },
+                    activityCode: {
+                        type: "string",
+                        minLength: 1,
+                        maxLength: 80,
+                    },
+                    activityDescription: {
+                        type: "string",
+                        minLength: 1,
+                        maxLength: 240,
+                    },
+                    clinicianRole: {
+                        type: "string",
+                        enum: [
+                            "attending",
+                            "physician",
+                            "nurse_practitioner",
+                            "physician_assistant",
+                            "resident",
+                            "other",
+                        ],
+                    },
+                    placeOfService: {
+                        type: "string",
+                        pattern: "^[0-9]{2}$",
+                    },
+                },
+            },
+        },
+        notes: {
+            type: "array",
+            maxItems: 50,
+            items: {
+                type: "object",
+                additionalProperties: false,
+                required: ["noteId", "noteType", "note"],
+                properties: {
+                    noteId: {
+                        type: "string",
+                        minLength: 1,
+                        maxLength: 60,
+                    },
+                    noteType: {
+                        type: "string",
+                        enum: [
+                            "clinical_narrative",
+                            "procedure_narrative",
+                            "authorization",
+                            "correspondence",
+                            "other",
+                        ],
+                    },
+                    note: {
+                        type: "string",
+                        minLength: 1,
+                        maxLength: 10000,
+                    },
+                },
+            },
+        },
+        sourceReferences: {
+            type: "array",
+            maxItems: 50,
+            items: {
+                type: "object",
+                additionalProperties: false,
+                required: ["sourceId", "sourceLabel"],
+                properties: {
+                    sourceId: {
+                        type: "string",
+                        minLength: 1,
+                        maxLength: 60,
+                    },
+                    sourceLabel: {
+                        type: "string",
+                        minLength: 1,
+                        maxLength: 120,
+                    },
+                    documentId: {
+                        type: "string",
+                        minLength: 1,
+                        maxLength: 240,
+                    },
+                    excerpt: {
+                        type: "string",
+                        minLength: 1,
+                        maxLength: 2000,
+                    },
+                    sourceVersion: {
+                        type: "string",
+                        minLength: 1,
+                        maxLength: 80,
+                    },
+                    corpusScope: {
+                        type: "string",
+                        enum: ["base", "tenant"],
+                    },
+                    publisher: {
+                        type: "string",
+                        minLength: 1,
+                        maxLength: 240,
+                    },
+                    effectiveDate: {
+                        type: "string",
+                        pattern: "^\\d{4}-\\d{2}-\\d{2}$",
+                        format: "date",
+                    },
+                    retrievalDate: {
+                        type: "string",
+                        pattern: "^\\d{4}-\\d{2}-\\d{2}$",
+                        format: "date",
+                    },
+                    coveredPayerProgram: {
+                        type: "string",
+                        minLength: 1,
+                        maxLength: 240,
+                    },
+                    sourceUrl: {
+                        type: "string",
+                        minLength: 1,
+                        maxLength: 2048,
+                    },
+                    documentHash: {
+                        type: "string",
+                        minLength: 1,
+                        maxLength: 64,
+                    },
+                    capturedAt: {
+                        type: "string",
+                        pattern: "^\\d{4}-\\d{2}-\\d{2}$",
+                        format: "date",
+                    },
+                    humanReviewRequired: {
+                        type: "boolean",
+                        const: true,
+                    },
+                },
+            },
+        },
+    },
+};
+// --------------------------------------------------------------------
+// CodingServiceLine (schema 1.0.0, wire coding-service-line-v1)
+// --------------------------------------------------------------------
+export const codingServiceLineSchema = z
+    .object({
+    lineId: z.string().min(1).max(60),
+    submittedCode: z
+        .object({
+        code: z
+            .string()
+            .min(1)
+            .max(64)
+            .refine((value) => value.trim().length > 0),
+        codeSystem: z.enum([
+            "ICD-10-CM",
+            "ICD-10-PCS",
+            "CPT",
+            "HCPCS",
+            "NDC",
+            "CDT",
+            "OTHER",
+        ]),
+        codeVersion: z.string().min(1).max(40).optional(),
+    })
+        .strict(),
+    modifiers: z.array(z.string().min(1).max(8)).max(8).optional(),
+    units: z
+        .object({
+        count: z.number().int().min(0).max(999999).optional(),
+        unitOfMeasure: z.string().min(1).max(20).optional(),
+    })
+        .strict()
+        .optional(),
+    linkedDiagnoses: z
+        .array(z
+        .object({
+        diagnosisRef: z.string().min(1).max(60),
+        sequence: z.number().int().min(1).max(99).optional(),
+    })
+        .strict())
+        .max(20)
+        .optional(),
+    serviceDate: z
+        .string()
+        .regex(new RegExp("^\\d{4}-\\d{2}-\\d{2}$"))
+        .refine(isIsoDate)
+        .optional(),
+})
+    .strict();
+export function codingServiceLineValidationError(value) {
+    if (!isRecord(value))
+        return "service_line";
+    if (!["lineId", "submittedCode"].every((key) => key in value))
+        return "service_line_keys";
+    if (!Object.keys(value).every((key) => [
+        "lineId",
+        "submittedCode",
+        "modifiers",
+        "units",
+        "linkedDiagnoses",
+        "serviceDate",
+    ].includes(key)))
+        return "service_line_keys";
+    const value_lineId = value["lineId"];
+    if (typeof value_lineId !== "string" ||
+        value_lineId.length < 1 ||
+        value_lineId.length > 60)
+        return "service_line_id";
+    const value_submittedCode = value["submittedCode"];
+    if (!isRecord(value_submittedCode))
+        return "service_line_submitted_code";
+    if (!["code", "codeSystem"].every((key) => key in value_submittedCode))
+        return "service_line_submitted_code_keys";
+    if (!Object.keys(value_submittedCode).every((key) => ["code", "codeSystem", "codeVersion"].includes(key)))
+        return "service_line_submitted_code_keys";
+    const value_submittedCode_code = value_submittedCode["code"];
+    if (typeof value_submittedCode_code !== "string" ||
+        value_submittedCode_code.length < 1 ||
+        value_submittedCode_code.length > 64 ||
+        value_submittedCode_code.trim().length === 0)
+        return "service_line_code";
+    const value_submittedCode_codeSystem = value_submittedCode["codeSystem"];
+    if (typeof value_submittedCode_codeSystem !== "string" ||
+        ![
+            "ICD-10-CM",
+            "ICD-10-PCS",
+            "CPT",
+            "HCPCS",
+            "NDC",
+            "CDT",
+            "OTHER",
+        ].includes(value_submittedCode_codeSystem))
+        return "service_line_code_system";
+    if (value_submittedCode["codeVersion"] !== undefined) {
+        const value_submittedCode_codeVersion = value_submittedCode["codeVersion"];
+        if (typeof value_submittedCode_codeVersion !== "string" ||
+            value_submittedCode_codeVersion.length < 1 ||
+            value_submittedCode_codeVersion.length > 40)
+            return "service_line_code_version";
+    }
+    if (value["modifiers"] !== undefined) {
+        const value_modifiers = value["modifiers"];
+        if (!Array.isArray(value_modifiers) || value_modifiers.length > 8)
+            return "service_line_modifiers";
+        for (const item of value_modifiers) {
+            if (typeof item !== "string" || item.length < 1 || item.length > 8)
+                return "service_line_modifiers";
+        }
+    }
+    if (value["units"] !== undefined) {
+        const value_units = value["units"];
+        if (!isRecord(value_units))
+            return "service_line_units";
+        if (!Object.keys(value_units).every((key) => ["count", "unitOfMeasure"].includes(key)))
+            return "service_line_units_keys";
+        if (value_units["count"] !== undefined) {
+            const value_units_count = value_units["count"];
+            if (typeof value_units_count !== "number" ||
+                Number.isNaN(value_units_count) ||
+                !Number.isInteger(value_units_count) ||
+                value_units_count < 0 ||
+                value_units_count > 999999)
+                return "service_line_units_count";
+        }
+        if (value_units["unitOfMeasure"] !== undefined) {
+            const value_units_unitOfMeasure = value_units["unitOfMeasure"];
+            if (typeof value_units_unitOfMeasure !== "string" ||
+                value_units_unitOfMeasure.length < 1 ||
+                value_units_unitOfMeasure.length > 20)
+                return "service_line_units_measure";
+        }
+    }
+    if (value["linkedDiagnoses"] !== undefined) {
+        const value_linkedDiagnoses = value["linkedDiagnoses"];
+        if (!Array.isArray(value_linkedDiagnoses) ||
+            value_linkedDiagnoses.length > 20)
+            return "service_line_linked_diagnoses";
+        for (const item of value_linkedDiagnoses) {
+            if (!isRecord(item))
+                return "service_line_linked_diagnosis";
+            if (!["diagnosisRef"].every((key) => key in item))
+                return "service_line_linked_diagnosis_keys";
+            if (!Object.keys(item).every((key) => ["diagnosisRef", "sequence"].includes(key)))
+                return "service_line_linked_diagnosis_keys";
+            const item_diagnosisRef = item["diagnosisRef"];
+            if (typeof item_diagnosisRef !== "string" ||
+                item_diagnosisRef.length < 1 ||
+                item_diagnosisRef.length > 60)
+                return "service_line_diagnosis_ref";
+            if (item["sequence"] !== undefined) {
+                const item_sequence = item["sequence"];
+                if (typeof item_sequence !== "number" ||
+                    Number.isNaN(item_sequence) ||
+                    !Number.isInteger(item_sequence) ||
+                    item_sequence < 1 ||
+                    item_sequence > 99)
+                    return "service_line_diagnosis_sequence";
+            }
+        }
+    }
+    if (value["serviceDate"] !== undefined) {
+        const value_serviceDate = value["serviceDate"];
+        if (typeof value_serviceDate !== "string" ||
+            !new RegExp("^\\d{4}-\\d{2}-\\d{2}$").test(value_serviceDate) ||
+            !isIsoDate(value_serviceDate))
+            return "service_line_service_date";
+    }
+    return null;
+}
+export const validCodingServiceLine = (value) => codingServiceLineValidationError(value) === null;
+export const CodingServiceLineSchemaJson = {
+    $schema: "https://json-schema.org/draft/2020-12/schema",
+    $id: "https://nexalink.care/contracts/coding-service-line.schema.json",
+    title: "CodingServiceLine",
+    description: "One existing (submitted) claim line on a CodingCase. Decisions reference these lines by lineId; the line action is chosen by the decision, never stored here.",
+    version: "1.0.0",
+    type: "object",
+    additionalProperties: false,
+    required: ["lineId", "submittedCode"],
+    properties: {
+        lineId: {
+            type: "string",
+            minLength: 1,
+            maxLength: 60,
+        },
+        submittedCode: {
+            type: "object",
+            additionalProperties: false,
+            required: ["code", "codeSystem"],
+            properties: {
+                code: {
+                    type: "string",
+                    minLength: 1,
+                    maxLength: 64,
+                },
+                codeSystem: {
+                    type: "string",
+                    enum: [
+                        "ICD-10-CM",
+                        "ICD-10-PCS",
+                        "CPT",
+                        "HCPCS",
+                        "NDC",
+                        "CDT",
+                        "OTHER",
+                    ],
+                },
+                codeVersion: {
+                    type: "string",
+                    minLength: 1,
+                    maxLength: 40,
+                },
+            },
+        },
+        modifiers: {
+            type: "array",
+            maxItems: 8,
+            items: {
+                type: "string",
+                minLength: 1,
+                maxLength: 8,
+            },
+        },
+        units: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+                count: {
+                    type: "integer",
+                    minimum: 0,
+                    maximum: 999999,
+                },
+                unitOfMeasure: {
+                    type: "string",
+                    minLength: 1,
+                    maxLength: 20,
+                },
+            },
+        },
+        linkedDiagnoses: {
+            type: "array",
+            maxItems: 20,
+            items: {
+                type: "object",
+                additionalProperties: false,
+                required: ["diagnosisRef"],
+                properties: {
+                    diagnosisRef: {
+                        type: "string",
+                        minLength: 1,
+                        maxLength: 60,
+                    },
+                    sequence: {
+                        type: "integer",
+                        minimum: 1,
+                        maximum: 99,
+                    },
+                },
+            },
+        },
+        serviceDate: {
+            type: "string",
+            pattern: "^\\d{4}-\\d{2}-\\d{2}$",
+            format: "date",
+        },
+    },
+};
+// --------------------------------------------------------------------
+// CodingExtension (schema 1.0.0, wire coding-extension-v1)
+// --------------------------------------------------------------------
+export const codingExtensionSchema = z
+    .object({
+    namespace: z
+        .string()
+        .regex(new RegExp("^[a-z0-9]+([._-][a-z0-9]+)*$"))
+        .min(3)
+        .max(160),
+    schemaVersion: z.string().min(1).max(40),
+    payload: z
+        .object({})
+        .passthrough()
+        .refine((value) => Object.keys(value).length <= 50),
+})
+    .strict();
+export function codingExtensionValidationError(value) {
+    if (!isRecord(value))
+        return "extension";
+    if (!["namespace", "schemaVersion", "payload"].every((key) => key in value))
+        return "extension_keys";
+    if (!Object.keys(value).every((key) => ["namespace", "schemaVersion", "payload"].includes(key)))
+        return "extension_keys";
+    const value_namespace = value["namespace"];
+    if (typeof value_namespace !== "string" ||
+        value_namespace.length < 3 ||
+        value_namespace.length > 160 ||
+        !new RegExp("^[a-z0-9]+([._-][a-z0-9]+)*$").test(value_namespace))
+        return "extension_namespace";
+    const value_schemaVersion = value["schemaVersion"];
+    if (typeof value_schemaVersion !== "string" ||
+        value_schemaVersion.length < 1 ||
+        value_schemaVersion.length > 40)
+        return "extension_schema_version";
+    const value_payload = value["payload"];
+    if (!isRecord(value_payload))
+        return "extension_payload";
+    if (Object.keys(value_payload).length > 50)
+        return "extension_payload";
+    return null;
+}
+export const validCodingExtension = (value) => codingExtensionValidationError(value) === null;
+export const CodingExtensionSchemaJson = {
+    $schema: "https://json-schema.org/draft/2020-12/schema",
+    $id: "https://nexalink.care/contracts/coding-extension.schema.json",
+    title: "CodingExtension",
+    description: "A namespaced, bounded extension attached to a CodingCase or CodingDecision. Extensions carry pack-specific data without turning the shared envelope into an unbounded bag of specialty fields. Namespace ownership follows reverse-domain convention; Nexalink reserves com.nexalink and org.nexalink.",
+    version: "1.0.0",
+    type: "object",
+    additionalProperties: false,
+    required: ["namespace", "schemaVersion", "payload"],
+    properties: {
+        namespace: {
+            type: "string",
+            pattern: "^[a-z0-9]+([._-][a-z0-9]+)*$",
+            minLength: 3,
+            maxLength: 160,
+        },
+        schemaVersion: {
+            type: "string",
+            minLength: 1,
+            maxLength: 40,
+        },
+        payload: {
+            type: "object",
+            maxProperties: 50,
+            properties: {},
+        },
+    },
+};
+// --------------------------------------------------------------------
+// CodingCase (schema 1.0.0, wire coding-case-v1)
+// --------------------------------------------------------------------
+export const codingCaseSchema = z
+    .object({
+    caseId: z.string().min(1).max(128),
+    analyticsId: z.string().min(1).max(128).optional(),
+    tenantReference: z.string().min(1).max(128).optional(),
+    codingIntent: z.enum([
+        "encounter_review",
+        "claim_review",
+        "longitudinal_review",
+        "monthly_time_aggregation",
+        "batch_review",
+    ]),
+    servicePeriod: z
+        .object({
+        startDate: z
+            .string()
+            .regex(new RegExp("^\\d{4}-\\d{2}-\\d{2}$"))
+            .refine(isIsoDate),
+        endDate: z
+            .string()
+            .regex(new RegExp("^\\d{4}-\\d{2}-\\d{2}$"))
+            .refine(isIsoDate)
+            .optional(),
+    })
+        .strict(),
+    context: codingCaseContextSchema,
+    payer: codingCasePayerSchema.optional(),
+    clinical: codingCaseClinicalSchema,
+    submittedClaimLines: z.array(codingServiceLineSchema).max(100).optional(),
+    extensions: z.array(codingExtensionSchema).max(25).optional(),
+})
+    .strict();
+export function codingCaseValidationError(value) {
+    if (!isRecord(value))
+        return "coding_case";
+    if (!["caseId", "codingIntent", "servicePeriod", "context", "clinical"].every((key) => key in value))
+        return "coding_case_keys";
+    if (!Object.keys(value).every((key) => [
+        "caseId",
+        "analyticsId",
+        "tenantReference",
+        "codingIntent",
+        "servicePeriod",
+        "context",
+        "payer",
+        "clinical",
+        "submittedClaimLines",
+        "extensions",
+    ].includes(key)))
+        return "coding_case_keys";
+    const value_caseId = value["caseId"];
+    if (typeof value_caseId !== "string" ||
+        value_caseId.length < 1 ||
+        value_caseId.length > 128)
+        return "case_id";
+    if (value["analyticsId"] !== undefined) {
+        const value_analyticsId = value["analyticsId"];
+        if (typeof value_analyticsId !== "string" ||
+            value_analyticsId.length < 1 ||
+            value_analyticsId.length > 128)
+            return "case_analytics_id";
+    }
+    if (value["tenantReference"] !== undefined) {
+        const value_tenantReference = value["tenantReference"];
+        if (typeof value_tenantReference !== "string" ||
+            value_tenantReference.length < 1 ||
+            value_tenantReference.length > 128)
+            return "case_tenant_reference";
+    }
+    const value_codingIntent = value["codingIntent"];
+    if (typeof value_codingIntent !== "string" ||
+        ![
+            "encounter_review",
+            "claim_review",
+            "longitudinal_review",
+            "monthly_time_aggregation",
+            "batch_review",
+        ].includes(value_codingIntent))
+        return "case_coding_intent";
+    const value_servicePeriod = value["servicePeriod"];
+    if (!isRecord(value_servicePeriod))
+        return "case_service_period";
+    if (!["startDate"].every((key) => key in value_servicePeriod))
+        return "case_service_period_keys";
+    if (!Object.keys(value_servicePeriod).every((key) => ["startDate", "endDate"].includes(key)))
+        return "case_service_period_keys";
+    const value_servicePeriod_startDate = value_servicePeriod["startDate"];
+    if (typeof value_servicePeriod_startDate !== "string" ||
+        !new RegExp("^\\d{4}-\\d{2}-\\d{2}$").test(value_servicePeriod_startDate) ||
+        !isIsoDate(value_servicePeriod_startDate))
+        return "case_service_period_start";
+    if (value_servicePeriod["endDate"] !== undefined) {
+        const value_servicePeriod_endDate = value_servicePeriod["endDate"];
+        if (typeof value_servicePeriod_endDate !== "string" ||
+            !new RegExp("^\\d{4}-\\d{2}-\\d{2}$").test(value_servicePeriod_endDate) ||
+            !isIsoDate(value_servicePeriod_endDate))
+            return "case_service_period_end";
+    }
+    const value_context = value["context"];
+    const value_contextRefError = codingCaseContextValidationError(value_context);
+    if (value_contextRefError !== null)
+        return value_contextRefError;
+    if (value["payer"] !== undefined) {
+        const value_payer = value["payer"];
+        const value_payerRefError = codingCasePayerValidationError(value_payer);
+        if (value_payerRefError !== null)
+            return value_payerRefError;
+    }
+    const value_clinical = value["clinical"];
+    const value_clinicalRefError = codingCaseClinicalValidationError(value_clinical);
+    if (value_clinicalRefError !== null)
+        return value_clinicalRefError;
+    if (value["submittedClaimLines"] !== undefined) {
+        const value_submittedClaimLines = value["submittedClaimLines"];
+        if (!Array.isArray(value_submittedClaimLines) ||
+            value_submittedClaimLines.length > 100)
+            return "case_submitted_claim_lines";
+        for (const item of value_submittedClaimLines) {
+            const itemRefError = codingServiceLineValidationError(item);
+            if (itemRefError !== null)
+                return itemRefError;
+        }
+    }
+    if (value["extensions"] !== undefined) {
+        const value_extensions = value["extensions"];
+        if (!Array.isArray(value_extensions) || value_extensions.length > 25)
+            return "case_extensions";
+        for (const item of value_extensions) {
+            const itemRefError = codingExtensionValidationError(item);
+            if (itemRefError !== null)
+                return itemRefError;
+        }
+    }
+    return null;
+}
+export const validCodingCase = (value) => codingCaseValidationError(value) === null;
+export const CodingCaseSchemaJson = {
+    $schema: "https://json-schema.org/draft/2020-12/schema",
+    $id: "https://nexalink.care/contracts/coding-case.schema.json",
+    title: "CodingCase",
+    description: "The canonical case envelope for encounter, claim-review, longitudinal, monthly time aggregation, and batch coding workflows. caseId is a client-supplied direct reference; analyticsId is the separate analytics-safe identifier that may be referenced by decisions and metrics without exposing case identity.",
+    version: "1.0.0",
+    type: "object",
+    additionalProperties: false,
+    required: ["caseId", "codingIntent", "servicePeriod", "context", "clinical"],
+    properties: {
+        caseId: {
+            type: "string",
+            minLength: 1,
+            maxLength: 128,
+        },
+        analyticsId: {
+            type: "string",
+            minLength: 1,
+            maxLength: 128,
+        },
+        tenantReference: {
+            type: "string",
+            minLength: 1,
+            maxLength: 128,
+        },
+        codingIntent: {
+            type: "string",
+            enum: [
+                "encounter_review",
+                "claim_review",
+                "longitudinal_review",
+                "monthly_time_aggregation",
+                "batch_review",
+            ],
+        },
+        servicePeriod: {
+            type: "object",
+            additionalProperties: false,
+            required: ["startDate"],
+            properties: {
+                startDate: {
+                    type: "string",
+                    pattern: "^\\d{4}-\\d{2}-\\d{2}$",
+                    format: "date",
+                },
+                endDate: {
+                    type: "string",
+                    pattern: "^\\d{4}-\\d{2}-\\d{2}$",
+                    format: "date",
+                },
+            },
+        },
+        context: {
+            $ref: "coding-case-context.schema.json",
+        },
+        payer: {
+            $ref: "coding-case-payer.schema.json",
+        },
+        clinical: {
+            $ref: "coding-case-clinical.schema.json",
+        },
+        submittedClaimLines: {
+            type: "array",
+            maxItems: 100,
+            items: {
+                $ref: "coding-service-line.schema.json",
+            },
+        },
+        extensions: {
+            type: "array",
+            maxItems: 25,
+            items: {
+                $ref: "coding-extension.schema.json",
+            },
+        },
+    },
+};
+// --------------------------------------------------------------------
+// CodingBatch (schema 1.0.0, wire coding-batch-v1)
+// --------------------------------------------------------------------
+export const codingBatchSchema = z
+    .object({
+    batchId: z.string().min(1).max(128),
+    tenantReference: z.string().min(1).max(128).optional(),
+    intent: z.literal("batch_review"),
+    cases: z.array(codingCaseSchema).min(1).max(100),
+    createdBy: z.string().min(1).max(128).optional(),
+    createdAt: z
+        .string()
+        .regex(new RegExp("^\\d{4}-\\d{2}-\\d{2}T(?:[01]\\d|2[0-3]):[0-5]\\d:[0-5]\\d(?:\\.\\d+)?(?:Z|[+-](?:[01]\\d|2[0-3]):[0-5]\\d)$"))
+        .refine(isRfc3339DateTime)
+        .max(64),
+    extensions: z.array(codingExtensionSchema).max(25).optional(),
+})
+    .strict();
+export function codingBatchValidationError(value) {
+    if (!isRecord(value))
+        return "coding_batch";
+    if (!["batchId", "intent", "cases", "createdAt"].every((key) => key in value))
+        return "coding_batch_keys";
+    if (!Object.keys(value).every((key) => [
+        "batchId",
+        "tenantReference",
+        "intent",
+        "cases",
+        "createdBy",
+        "createdAt",
+        "extensions",
+    ].includes(key)))
+        return "coding_batch_keys";
+    const value_batchId = value["batchId"];
+    if (typeof value_batchId !== "string" ||
+        value_batchId.length < 1 ||
+        value_batchId.length > 128)
+        return "batch_id";
+    if (value["tenantReference"] !== undefined) {
+        const value_tenantReference = value["tenantReference"];
+        if (typeof value_tenantReference !== "string" ||
+            value_tenantReference.length < 1 ||
+            value_tenantReference.length > 128)
+            return "batch_tenant_reference";
+    }
+    const value_intent = value["intent"];
+    if (typeof value_intent !== "string" || value_intent !== "batch_review")
+        return "batch_intent";
+    const value_cases = value["cases"];
+    if (!Array.isArray(value_cases) ||
+        value_cases.length < 1 ||
+        value_cases.length > 100)
+        return "batch_cases";
+    for (const item of value_cases) {
+        const itemRefError = codingCaseValidationError(item);
+        if (itemRefError !== null)
+            return itemRefError;
+    }
+    if (value["createdBy"] !== undefined) {
+        const value_createdBy = value["createdBy"];
+        if (typeof value_createdBy !== "string" ||
+            value_createdBy.length < 1 ||
+            value_createdBy.length > 128)
+            return "batch_created_by";
+    }
+    const value_createdAt = value["createdAt"];
+    if (typeof value_createdAt !== "string" ||
+        value_createdAt.length > 64 ||
+        !new RegExp("^\\d{4}-\\d{2}-\\d{2}T(?:[01]\\d|2[0-3]):[0-5]\\d:[0-5]\\d(?:\\.\\d+)?(?:Z|[+-](?:[01]\\d|2[0-3]):[0-5]\\d)$").test(value_createdAt) ||
+        !isRfc3339DateTime(value_createdAt))
+        return "batch_created_at";
+    if (value["extensions"] !== undefined) {
+        const value_extensions = value["extensions"];
+        if (!Array.isArray(value_extensions) || value_extensions.length > 25)
+            return "batch_extensions";
+        for (const item of value_extensions) {
+            const itemRefError = codingExtensionValidationError(item);
+            if (itemRefError !== null)
+                return itemRefError;
+        }
+    }
+    return null;
+}
+export const validCodingBatch = (value) => codingBatchValidationError(value) === null;
+export const CodingBatchSchemaJson = {
+    $schema: "https://json-schema.org/draft/2020-12/schema",
+    $id: "https://nexalink.care/contracts/coding-batch.schema.json",
+    title: "CodingBatch",
+    description: "A bounded batch envelope carrying CodingCase instances for batch review. Batch size is capped so one execution remains within runtime limits; unbounded or streaming workloads are out of scope for this envelope.",
+    version: "1.0.0",
+    type: "object",
+    additionalProperties: false,
+    required: ["batchId", "intent", "cases", "createdAt"],
+    properties: {
+        batchId: {
+            type: "string",
+            minLength: 1,
+            maxLength: 128,
+        },
+        tenantReference: {
+            type: "string",
+            minLength: 1,
+            maxLength: 128,
+        },
+        intent: {
+            type: "string",
+            const: "batch_review",
+        },
+        cases: {
+            type: "array",
+            minItems: 1,
+            maxItems: 100,
+            items: {
+                $ref: "coding-case.schema.json",
+            },
+        },
+        createdBy: {
+            type: "string",
+            minLength: 1,
+            maxLength: 128,
+        },
+        createdAt: {
+            type: "string",
+            pattern: "^\\d{4}-\\d{2}-\\d{2}T(?:[01]\\d|2[0-3]):[0-5]\\d:[0-5]\\d(?:\\.\\d+)?(?:Z|[+-](?:[01]\\d|2[0-3]):[0-5]\\d)$",
+            format: "date-time",
+            maxLength: 64,
+        },
+        extensions: {
+            type: "array",
+            maxItems: 25,
+            items: {
+                $ref: "coding-extension.schema.json",
+            },
+        },
+    },
+};
+// --------------------------------------------------------------------
+// CodingDecisionLine (schema 1.0.0, wire coding-decision-line-v1)
+// --------------------------------------------------------------------
+export const codingDecisionLineSchema = z
+    .object({
+    lineId: z.string().min(1).max(60),
+    action: z.enum(["add", "retain", "replace", "remove", "review"]),
+    code: z
+        .object({
+        code: z
+            .string()
+            .min(1)
+            .max(64)
+            .refine((value) => value.trim().length > 0),
+        codeSystem: z.enum([
+            "ICD-10-CM",
+            "ICD-10-PCS",
+            "CPT",
+            "HCPCS",
+            "NDC",
+            "CDT",
+            "REVENUE_CODE",
+            "DRG",
+            "OTHER",
+        ]),
+        codeVersion: z.string().min(1).max(40).optional(),
+    })
+        .strict(),
+    modifiers: z.array(z.string().min(1).max(8)).max(8).optional(),
+    units: z
+        .object({
+        count: z.number().int().min(0).max(999999).optional(),
+        unitOfMeasure: z.string().min(1).max(20).optional(),
+    })
+        .strict()
+        .optional(),
+    linkedDiagnoses: z
+        .array(z
+        .object({
+        diagnosisRef: z.string().min(1).max(60),
+        sequence: z.number().int().min(1).max(99).optional(),
+    })
+        .strict())
+        .max(20)
+        .optional(),
+    sequence: z.number().int().min(1).max(999).optional(),
+    confidence: z.enum(["low", "medium", "high"]),
+    rationale: z
+        .string()
+        .min(1)
+        .max(2000)
+        .refine((value) => value.trim().length > 0),
+    evidenceRefs: z.array(z.string().min(1).max(64)).max(10).optional(),
+    gapRefs: z.array(z.string().min(1).max(64)).max(10).optional(),
+    conflictRefs: z.array(z.string().min(1).max(64)).max(10).optional(),
+})
+    .strict();
+export function codingDecisionLineValidationError(value) {
+    if (!isRecord(value))
+        return "decision_line";
+    if (!["lineId", "action", "code", "confidence", "rationale"].every((key) => key in value))
+        return "decision_line_keys";
+    if (!Object.keys(value).every((key) => [
+        "lineId",
+        "action",
+        "code",
+        "modifiers",
+        "units",
+        "linkedDiagnoses",
+        "sequence",
+        "confidence",
+        "rationale",
+        "evidenceRefs",
+        "gapRefs",
+        "conflictRefs",
+    ].includes(key)))
+        return "decision_line_keys";
+    const value_lineId = value["lineId"];
+    if (typeof value_lineId !== "string" ||
+        value_lineId.length < 1 ||
+        value_lineId.length > 60)
+        return "decision_line_id";
+    const value_action = value["action"];
+    if (typeof value_action !== "string" ||
+        !["add", "retain", "replace", "remove", "review"].includes(value_action))
+        return "decision_line_action";
+    const value_code = value["code"];
+    if (!isRecord(value_code))
+        return "decision_line_code";
+    if (!["code", "codeSystem"].every((key) => key in value_code))
+        return "decision_line_code_keys";
+    if (!Object.keys(value_code).every((key) => ["code", "codeSystem", "codeVersion"].includes(key)))
+        return "decision_line_code_keys";
+    const value_code_code = value_code["code"];
+    if (typeof value_code_code !== "string" ||
+        value_code_code.length < 1 ||
+        value_code_code.length > 64 ||
+        value_code_code.trim().length === 0)
+        return "decision_line_code_value";
+    const value_code_codeSystem = value_code["codeSystem"];
+    if (typeof value_code_codeSystem !== "string" ||
+        ![
+            "ICD-10-CM",
+            "ICD-10-PCS",
+            "CPT",
+            "HCPCS",
+            "NDC",
+            "CDT",
+            "REVENUE_CODE",
+            "DRG",
+            "OTHER",
+        ].includes(value_code_codeSystem))
+        return "decision_line_code_system";
+    if (value_code["codeVersion"] !== undefined) {
+        const value_code_codeVersion = value_code["codeVersion"];
+        if (typeof value_code_codeVersion !== "string" ||
+            value_code_codeVersion.length < 1 ||
+            value_code_codeVersion.length > 40)
+            return "decision_line_code_version";
+    }
+    if (value["modifiers"] !== undefined) {
+        const value_modifiers = value["modifiers"];
+        if (!Array.isArray(value_modifiers) || value_modifiers.length > 8)
+            return "decision_line_modifiers";
+        for (const item of value_modifiers) {
+            if (typeof item !== "string" || item.length < 1 || item.length > 8)
+                return "decision_line_modifiers";
+        }
+    }
+    if (value["units"] !== undefined) {
+        const value_units = value["units"];
+        if (!isRecord(value_units))
+            return "decision_line_units";
+        if (!Object.keys(value_units).every((key) => ["count", "unitOfMeasure"].includes(key)))
+            return "decision_line_units_keys";
+        if (value_units["count"] !== undefined) {
+            const value_units_count = value_units["count"];
+            if (typeof value_units_count !== "number" ||
+                Number.isNaN(value_units_count) ||
+                !Number.isInteger(value_units_count) ||
+                value_units_count < 0 ||
+                value_units_count > 999999)
+                return "decision_line_units_count";
+        }
+        if (value_units["unitOfMeasure"] !== undefined) {
+            const value_units_unitOfMeasure = value_units["unitOfMeasure"];
+            if (typeof value_units_unitOfMeasure !== "string" ||
+                value_units_unitOfMeasure.length < 1 ||
+                value_units_unitOfMeasure.length > 20)
+                return "decision_line_units_measure";
+        }
+    }
+    if (value["linkedDiagnoses"] !== undefined) {
+        const value_linkedDiagnoses = value["linkedDiagnoses"];
+        if (!Array.isArray(value_linkedDiagnoses) ||
+            value_linkedDiagnoses.length > 20)
+            return "decision_line_linked_diagnoses";
+        for (const item of value_linkedDiagnoses) {
+            if (!isRecord(item))
+                return "decision_line_linked_diagnosis";
+            if (!["diagnosisRef"].every((key) => key in item))
+                return "decision_line_linked_diagnosis_keys";
+            if (!Object.keys(item).every((key) => ["diagnosisRef", "sequence"].includes(key)))
+                return "decision_line_linked_diagnosis_keys";
+            const item_diagnosisRef = item["diagnosisRef"];
+            if (typeof item_diagnosisRef !== "string" ||
+                item_diagnosisRef.length < 1 ||
+                item_diagnosisRef.length > 60)
+                return "decision_line_diagnosis_ref";
+            if (item["sequence"] !== undefined) {
+                const item_sequence = item["sequence"];
+                if (typeof item_sequence !== "number" ||
+                    Number.isNaN(item_sequence) ||
+                    !Number.isInteger(item_sequence) ||
+                    item_sequence < 1 ||
+                    item_sequence > 99)
+                    return "decision_line_diagnosis_sequence";
+            }
+        }
+    }
+    if (value["sequence"] !== undefined) {
+        const value_sequence = value["sequence"];
+        if (typeof value_sequence !== "number" ||
+            Number.isNaN(value_sequence) ||
+            !Number.isInteger(value_sequence) ||
+            value_sequence < 1 ||
+            value_sequence > 999)
+            return "decision_line_sequence";
+    }
+    const value_confidence = value["confidence"];
+    if (typeof value_confidence !== "string" ||
+        !["low", "medium", "high"].includes(value_confidence))
+        return "decision_line_confidence";
+    const value_rationale = value["rationale"];
+    if (typeof value_rationale !== "string" ||
+        value_rationale.length < 1 ||
+        value_rationale.length > 2000 ||
+        value_rationale.trim().length === 0)
+        return "decision_line_rationale";
+    if (value["evidenceRefs"] !== undefined) {
+        const value_evidenceRefs = value["evidenceRefs"];
+        if (!Array.isArray(value_evidenceRefs) || value_evidenceRefs.length > 10)
+            return "decision_line_evidence_refs";
+        for (const item of value_evidenceRefs) {
+            if (typeof item !== "string" || item.length < 1 || item.length > 64)
+                return "decision_line_evidence_refs";
+        }
+    }
+    if (value["gapRefs"] !== undefined) {
+        const value_gapRefs = value["gapRefs"];
+        if (!Array.isArray(value_gapRefs) || value_gapRefs.length > 10)
+            return "decision_line_gap_refs";
+        for (const item of value_gapRefs) {
+            if (typeof item !== "string" || item.length < 1 || item.length > 64)
+                return "decision_line_gap_refs";
+        }
+    }
+    if (value["conflictRefs"] !== undefined) {
+        const value_conflictRefs = value["conflictRefs"];
+        if (!Array.isArray(value_conflictRefs) || value_conflictRefs.length > 10)
+            return "decision_line_conflict_refs";
+        for (const item of value_conflictRefs) {
+            if (typeof item !== "string" || item.length < 1 || item.length > 64)
+                return "decision_line_conflict_refs";
+        }
+    }
+    return null;
+}
+export const validCodingDecisionLine = (value) => codingDecisionLineValidationError(value) === null;
+export const CodingDecisionLineSchemaJson = {
+    $schema: "https://json-schema.org/draft/2020-12/schema",
+    $id: "https://nexalink.care/contracts/coding-decision-line.schema.json",
+    title: "CodingDecisionLine",
+    description: "One proposed claim-line action within a CodingDecision. Actions are add, retain, replace, remove, or review; each line carries code identity, modifiers, units, linked diagnoses, sequencing, confidence, rationale, and evidence references.",
+    version: "1.0.0",
+    type: "object",
+    additionalProperties: false,
+    required: ["lineId", "action", "code", "confidence", "rationale"],
+    properties: {
+        lineId: {
+            type: "string",
+            minLength: 1,
+            maxLength: 60,
+        },
+        action: {
+            type: "string",
+            enum: ["add", "retain", "replace", "remove", "review"],
+        },
+        code: {
+            type: "object",
+            additionalProperties: false,
+            required: ["code", "codeSystem"],
+            properties: {
+                code: {
+                    type: "string",
+                    minLength: 1,
+                    maxLength: 64,
+                },
+                codeSystem: {
+                    type: "string",
+                    enum: [
+                        "ICD-10-CM",
+                        "ICD-10-PCS",
+                        "CPT",
+                        "HCPCS",
+                        "NDC",
+                        "CDT",
+                        "REVENUE_CODE",
+                        "DRG",
+                        "OTHER",
+                    ],
+                },
+                codeVersion: {
+                    type: "string",
+                    minLength: 1,
+                    maxLength: 40,
+                },
+            },
+        },
+        modifiers: {
+            type: "array",
+            maxItems: 8,
+            items: {
+                type: "string",
+                minLength: 1,
+                maxLength: 8,
+            },
+        },
+        units: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+                count: {
+                    type: "integer",
+                    minimum: 0,
+                    maximum: 999999,
+                },
+                unitOfMeasure: {
+                    type: "string",
+                    minLength: 1,
+                    maxLength: 20,
+                },
+            },
+        },
+        linkedDiagnoses: {
+            type: "array",
+            maxItems: 20,
+            items: {
+                type: "object",
+                additionalProperties: false,
+                required: ["diagnosisRef"],
+                properties: {
+                    diagnosisRef: {
+                        type: "string",
+                        minLength: 1,
+                        maxLength: 60,
+                    },
+                    sequence: {
+                        type: "integer",
+                        minimum: 1,
+                        maximum: 99,
+                    },
+                },
+            },
+        },
+        sequence: {
+            type: "integer",
+            minimum: 1,
+            maximum: 999,
+        },
+        confidence: {
+            type: "string",
+            enum: ["low", "medium", "high"],
+        },
+        rationale: {
+            type: "string",
+            minLength: 1,
+            maxLength: 2000,
+        },
+        evidenceRefs: {
+            type: "array",
+            maxItems: 10,
+            items: {
+                type: "string",
+                minLength: 1,
+                maxLength: 64,
+            },
+        },
+        gapRefs: {
+            type: "array",
+            maxItems: 10,
+            items: {
+                type: "string",
+                minLength: 1,
+                maxLength: 64,
+            },
+        },
+        conflictRefs: {
+            type: "array",
+            maxItems: 10,
+            items: {
+                type: "string",
+                minLength: 1,
+                maxLength: 64,
+            },
+        },
+    },
+};
+// --------------------------------------------------------------------
+// CodingEvidence (schema 1.0.0, wire coding-evidence-v1)
+// --------------------------------------------------------------------
+export const codingEvidenceSchema = z
+    .object({
+    evidenceId: z.string().min(1).max(64),
+    type: z.enum([
+        "clinical",
+        "coding_guideline",
+        "payer_policy",
+        "plan_policy",
+        "contract_configuration",
+        "terminology_validity",
+        "rule_execution",
+    ]),
+    source: z
+        .string()
+        .min(1)
+        .max(240)
+        .refine((value) => value.trim().length > 0),
+    sourceVersion: z.string().min(1).max(80),
+    publisher: z.string().min(1).max(240).optional(),
+    scope: z.enum(["national", "payer", "plan", "contract", "tenant"]),
+    effectiveFrom: z
+        .string()
+        .regex(new RegExp("^\\d{4}-\\d{2}-\\d{2}$"))
+        .refine(isIsoDate),
+    effectiveTo: z
+        .string()
+        .regex(new RegExp("^\\d{4}-\\d{2}-\\d{2}$"))
+        .refine(isIsoDate)
+        .optional(),
+    stableId: z.string().min(1).max(240),
+    excerpt: z
+        .string()
+        .min(1)
+        .max(2000)
+        .refine((value) => value.trim().length > 0),
+    retrievedAt: z
+        .string()
+        .regex(new RegExp("^\\d{4}-\\d{2}-\\d{2}$"))
+        .refine(isIsoDate),
+})
+    .strict();
+export function codingEvidenceValidationError(value) {
+    if (!isRecord(value))
+        return "evidence";
+    if (![
+        "evidenceId",
+        "type",
+        "source",
+        "sourceVersion",
+        "scope",
+        "effectiveFrom",
+        "stableId",
+        "excerpt",
+        "retrievedAt",
+    ].every((key) => key in value))
+        return "evidence_keys";
+    if (!Object.keys(value).every((key) => [
+        "evidenceId",
+        "type",
+        "source",
+        "sourceVersion",
+        "publisher",
+        "scope",
+        "effectiveFrom",
+        "effectiveTo",
+        "stableId",
+        "excerpt",
+        "retrievedAt",
+    ].includes(key)))
+        return "evidence_keys";
+    const value_evidenceId = value["evidenceId"];
+    if (typeof value_evidenceId !== "string" ||
+        value_evidenceId.length < 1 ||
+        value_evidenceId.length > 64)
+        return "evidence_id";
+    const value_type = value["type"];
+    if (typeof value_type !== "string" ||
+        ![
+            "clinical",
+            "coding_guideline",
+            "payer_policy",
+            "plan_policy",
+            "contract_configuration",
+            "terminology_validity",
+            "rule_execution",
+        ].includes(value_type))
+        return "evidence_type";
+    const value_source = value["source"];
+    if (typeof value_source !== "string" ||
+        value_source.length < 1 ||
+        value_source.length > 240 ||
+        value_source.trim().length === 0)
+        return "evidence_source";
+    const value_sourceVersion = value["sourceVersion"];
+    if (typeof value_sourceVersion !== "string" ||
+        value_sourceVersion.length < 1 ||
+        value_sourceVersion.length > 80)
+        return "evidence_source_version";
+    if (value["publisher"] !== undefined) {
+        const value_publisher = value["publisher"];
+        if (typeof value_publisher !== "string" ||
+            value_publisher.length < 1 ||
+            value_publisher.length > 240)
+            return "evidence_publisher";
+    }
+    const value_scope = value["scope"];
+    if (typeof value_scope !== "string" ||
+        !["national", "payer", "plan", "contract", "tenant"].includes(value_scope))
+        return "evidence_scope";
+    const value_effectiveFrom = value["effectiveFrom"];
+    if (typeof value_effectiveFrom !== "string" ||
+        !new RegExp("^\\d{4}-\\d{2}-\\d{2}$").test(value_effectiveFrom) ||
+        !isIsoDate(value_effectiveFrom))
+        return "evidence_effective_from";
+    if (value["effectiveTo"] !== undefined) {
+        const value_effectiveTo = value["effectiveTo"];
+        if (typeof value_effectiveTo !== "string" ||
+            !new RegExp("^\\d{4}-\\d{2}-\\d{2}$").test(value_effectiveTo) ||
+            !isIsoDate(value_effectiveTo))
+            return "evidence_effective_to";
+    }
+    const value_stableId = value["stableId"];
+    if (typeof value_stableId !== "string" ||
+        value_stableId.length < 1 ||
+        value_stableId.length > 240)
+        return "evidence_stable_id";
+    const value_excerpt = value["excerpt"];
+    if (typeof value_excerpt !== "string" ||
+        value_excerpt.length < 1 ||
+        value_excerpt.length > 2000 ||
+        value_excerpt.trim().length === 0)
+        return "evidence_excerpt";
+    const value_retrievedAt = value["retrievedAt"];
+    if (typeof value_retrievedAt !== "string" ||
+        !new RegExp("^\\d{4}-\\d{2}-\\d{2}$").test(value_retrievedAt) ||
+        !isIsoDate(value_retrievedAt))
+        return "evidence_retrieved_at";
+    return null;
+}
+export const validCodingEvidence = (value) => codingEvidenceValidationError(value) === null;
+export const CodingEvidenceSchemaJson = {
+    $schema: "https://json-schema.org/draft/2020-12/schema",
+    $id: "https://nexalink.care/contracts/coding-evidence.schema.json",
+    title: "CodingEvidence",
+    description: "One typed, traced evidence item attached to a decision. Every item carries source, scope, version, effective period, and a stable identifier so reviews can be reconstructed. Licensed terminology content is never distributed through evidence excerpts.",
+    version: "1.0.0",
+    type: "object",
+    additionalProperties: false,
+    required: [
+        "evidenceId",
+        "type",
+        "source",
+        "sourceVersion",
+        "scope",
+        "effectiveFrom",
+        "stableId",
+        "excerpt",
+        "retrievedAt",
+    ],
+    properties: {
+        evidenceId: {
+            type: "string",
+            minLength: 1,
+            maxLength: 64,
+        },
+        type: {
+            type: "string",
+            enum: [
+                "clinical",
+                "coding_guideline",
+                "payer_policy",
+                "plan_policy",
+                "contract_configuration",
+                "terminology_validity",
+                "rule_execution",
+            ],
+        },
+        source: {
+            type: "string",
+            minLength: 1,
+            maxLength: 240,
+        },
+        sourceVersion: {
+            type: "string",
+            minLength: 1,
+            maxLength: 80,
+        },
+        publisher: {
+            type: "string",
+            minLength: 1,
+            maxLength: 240,
+        },
+        scope: {
+            type: "string",
+            enum: ["national", "payer", "plan", "contract", "tenant"],
+        },
+        effectiveFrom: {
+            type: "string",
+            pattern: "^\\d{4}-\\d{2}-\\d{2}$",
+            format: "date",
+        },
+        effectiveTo: {
+            type: "string",
+            pattern: "^\\d{4}-\\d{2}-\\d{2}$",
+            format: "date",
+        },
+        stableId: {
+            type: "string",
+            minLength: 1,
+            maxLength: 240,
+        },
+        excerpt: {
+            type: "string",
+            minLength: 1,
+            maxLength: 2000,
+        },
+        retrievedAt: {
+            type: "string",
+            pattern: "^\\d{4}-\\d{2}-\\d{2}$",
+            format: "date",
+        },
+    },
+};
+// --------------------------------------------------------------------
+// CodingRuleResult (schema 1.0.0, wire coding-rule-result-v1)
+// --------------------------------------------------------------------
+export const codingRuleResultSchema = z
+    .object({
+    ruleId: z.string().min(1).max(120),
+    ruleVersion: z.string().min(1).max(40),
+    outcome: z.enum([
+        "satisfied",
+        "failed",
+        "rejected",
+        "escalated",
+        "conflicted",
+        "warning",
+    ]),
+    severity: z.enum(["info", "warning", "blocking"]).optional(),
+    inputs: z
+        .array(z
+        .object({
+        name: z.string().min(1).max(80),
+        value: z.string().min(1).max(2000),
+    })
+        .strict())
+        .max(30)
+        .optional(),
+    reason: z.string().min(1).max(120).optional(),
+    explanation: z
+        .string()
+        .min(1)
+        .max(1000)
+        .refine((value) => value.trim().length > 0)
+        .optional(),
+    evidence: z.string().min(1).max(2000).optional(),
+})
+    .strict();
+export function codingRuleResultValidationError(value) {
+    if (!isRecord(value))
+        return "rule_result";
+    if (!["ruleId", "ruleVersion", "outcome"].every((key) => key in value))
+        return "rule_result_keys";
+    if (!Object.keys(value).every((key) => [
+        "ruleId",
+        "ruleVersion",
+        "outcome",
+        "severity",
+        "inputs",
+        "reason",
+        "explanation",
+        "evidence",
+    ].includes(key)))
+        return "rule_result_keys";
+    const value_ruleId = value["ruleId"];
+    if (typeof value_ruleId !== "string" ||
+        value_ruleId.length < 1 ||
+        value_ruleId.length > 120)
+        return "rule_result_id";
+    const value_ruleVersion = value["ruleVersion"];
+    if (typeof value_ruleVersion !== "string" ||
+        value_ruleVersion.length < 1 ||
+        value_ruleVersion.length > 40)
+        return "rule_result_version";
+    const value_outcome = value["outcome"];
+    if (typeof value_outcome !== "string" ||
+        ![
+            "satisfied",
+            "failed",
+            "rejected",
+            "escalated",
+            "conflicted",
+            "warning",
+        ].includes(value_outcome))
+        return "rule_result_outcome";
+    if (value["severity"] !== undefined) {
+        const value_severity = value["severity"];
+        if (typeof value_severity !== "string" ||
+            !["info", "warning", "blocking"].includes(value_severity))
+            return "rule_result_severity";
+    }
+    if (value["inputs"] !== undefined) {
+        const value_inputs = value["inputs"];
+        if (!Array.isArray(value_inputs) || value_inputs.length > 30)
+            return "rule_result_inputs";
+        for (const item of value_inputs) {
+            if (!isRecord(item))
+                return "rule_result_input";
+            if (!["name", "value"].every((key) => key in item))
+                return "rule_result_input_keys";
+            if (!Object.keys(item).every((key) => ["name", "value"].includes(key)))
+                return "rule_result_input_keys";
+            const item_name = item["name"];
+            if (typeof item_name !== "string" ||
+                item_name.length < 1 ||
+                item_name.length > 80)
+                return "rule_result_input_name";
+            const item_value = item["value"];
+            if (typeof item_value !== "string" ||
+                item_value.length < 1 ||
+                item_value.length > 2000)
+                return "rule_result_input_value";
+        }
+    }
+    if (value["reason"] !== undefined) {
+        const value_reason = value["reason"];
+        if (typeof value_reason !== "string" ||
+            value_reason.length < 1 ||
+            value_reason.length > 120)
+            return "rule_result_reason";
+    }
+    if (value["explanation"] !== undefined) {
+        const value_explanation = value["explanation"];
+        if (typeof value_explanation !== "string" ||
+            value_explanation.length < 1 ||
+            value_explanation.length > 1000 ||
+            value_explanation.trim().length === 0)
+            return "rule_result_explanation";
+    }
+    if (value["evidence"] !== undefined) {
+        const value_evidence = value["evidence"];
+        if (typeof value_evidence !== "string" ||
+            value_evidence.length < 1 ||
+            value_evidence.length > 2000)
+            return "rule_result_evidence";
+    }
+    return null;
+}
+export const validCodingRuleResult = (value) => codingRuleResultValidationError(value) === null;
+export const CodingRuleResultSchemaJson = {
+    $schema: "https://json-schema.org/draft/2020-12/schema",
+    $id: "https://nexalink.care/contracts/coding-rule-result.schema.json",
+    title: "CodingRuleResult",
+    description: "One deterministic rule execution trace attached to a decision. Rules never rely on the model for validity, bundling, sequencing, modifiers, units, or time calculations; each trace records the rule identity, version, inputs, outcome, and explanation needed to replay the decision.",
+    version: "1.0.0",
+    type: "object",
+    additionalProperties: false,
+    required: ["ruleId", "ruleVersion", "outcome"],
+    properties: {
+        ruleId: {
+            type: "string",
+            minLength: 1,
+            maxLength: 120,
+        },
+        ruleVersion: {
+            type: "string",
+            minLength: 1,
+            maxLength: 40,
+        },
+        outcome: {
+            type: "string",
+            enum: [
+                "satisfied",
+                "failed",
+                "rejected",
+                "escalated",
+                "conflicted",
+                "warning",
+            ],
+        },
+        severity: {
+            type: "string",
+            enum: ["info", "warning", "blocking"],
+        },
+        inputs: {
+            type: "array",
+            maxItems: 30,
+            items: {
+                type: "object",
+                additionalProperties: false,
+                required: ["name", "value"],
+                properties: {
+                    name: {
+                        type: "string",
+                        minLength: 1,
+                        maxLength: 80,
+                    },
+                    value: {
+                        type: "string",
+                        minLength: 1,
+                        maxLength: 2000,
+                    },
+                },
+            },
+        },
+        reason: {
+            type: "string",
+            minLength: 1,
+            maxLength: 120,
+        },
+        explanation: {
+            type: "string",
+            minLength: 1,
+            maxLength: 1000,
+        },
+        evidence: {
+            type: "string",
+            minLength: 1,
+            maxLength: 2000,
+        },
+    },
+};
+// --------------------------------------------------------------------
+// CodingReviewerAction (schema 1.0.0, wire coding-reviewer-action-v1)
+// --------------------------------------------------------------------
+export const codingReviewerActionSchema = z
+    .object({
+    reviewerId: z.string().min(1).max(128),
+    reviewerRole: z.string().min(1).max(80).optional(),
+    action: z.enum([
+        "approved",
+        "approved_with_changes",
+        "rejected",
+        "escalated",
+    ]),
+    resolutionCode: z.string().min(1).max(80).optional(),
+    notes: z
+        .string()
+        .min(1)
+        .max(2000)
+        .refine((value) => value.trim().length > 0)
+        .optional(),
+    occurredAt: z
+        .string()
+        .regex(new RegExp("^\\d{4}-\\d{2}-\\d{2}T(?:[01]\\d|2[0-3]):[0-5]\\d:[0-5]\\d(?:\\.\\d+)?(?:Z|[+-](?:[01]\\d|2[0-3]):[0-5]\\d)$"))
+        .refine(isRfc3339DateTime)
+        .max(64),
+})
+    .strict();
+export function codingReviewerActionValidationError(value) {
+    if (!isRecord(value))
+        return "reviewer_action";
+    if (!["reviewerId", "action", "occurredAt"].every((key) => key in value))
+        return "reviewer_action_keys";
+    if (!Object.keys(value).every((key) => [
+        "reviewerId",
+        "reviewerRole",
+        "action",
+        "resolutionCode",
+        "notes",
+        "occurredAt",
+    ].includes(key)))
+        return "reviewer_action_keys";
+    const value_reviewerId = value["reviewerId"];
+    if (typeof value_reviewerId !== "string" ||
+        value_reviewerId.length < 1 ||
+        value_reviewerId.length > 128)
+        return "reviewer_action_id";
+    if (value["reviewerRole"] !== undefined) {
+        const value_reviewerRole = value["reviewerRole"];
+        if (typeof value_reviewerRole !== "string" ||
+            value_reviewerRole.length < 1 ||
+            value_reviewerRole.length > 80)
+            return "reviewer_action_role";
+    }
+    const value_action = value["action"];
+    if (typeof value_action !== "string" ||
+        !["approved", "approved_with_changes", "rejected", "escalated"].includes(value_action))
+        return "reviewer_action_type";
+    if (value["resolutionCode"] !== undefined) {
+        const value_resolutionCode = value["resolutionCode"];
+        if (typeof value_resolutionCode !== "string" ||
+            value_resolutionCode.length < 1 ||
+            value_resolutionCode.length > 80)
+            return "reviewer_action_resolution_code";
+    }
+    if (value["notes"] !== undefined) {
+        const value_notes = value["notes"];
+        if (typeof value_notes !== "string" ||
+            value_notes.length < 1 ||
+            value_notes.length > 2000 ||
+            value_notes.trim().length === 0)
+            return "reviewer_action_notes";
+    }
+    const value_occurredAt = value["occurredAt"];
+    if (typeof value_occurredAt !== "string" ||
+        value_occurredAt.length > 64 ||
+        !new RegExp("^\\d{4}-\\d{2}-\\d{2}T(?:[01]\\d|2[0-3]):[0-5]\\d:[0-5]\\d(?:\\.\\d+)?(?:Z|[+-](?:[01]\\d|2[0-3]):[0-5]\\d)$").test(value_occurredAt) ||
+        !isRfc3339DateTime(value_occurredAt))
+        return "reviewer_action_occurred_at";
+    return null;
+}
+export const validCodingReviewerAction = (value) => codingReviewerActionValidationError(value) === null;
+export const CodingReviewerActionSchemaJson = {
+    $schema: "https://json-schema.org/draft/2020-12/schema",
+    $id: "https://nexalink.care/contracts/coding-reviewer-action.schema.json",
+    title: "CodingReviewerAction",
+    description: "Attributable human-review disposition appended to an otherwise immutable decision. A decision plus its reviewer actions remains replayable: original and reviewer versions are both preserved.",
+    version: "1.0.0",
+    type: "object",
+    additionalProperties: false,
+    required: ["reviewerId", "action", "occurredAt"],
+    properties: {
+        reviewerId: {
+            type: "string",
+            minLength: 1,
+            maxLength: 128,
+        },
+        reviewerRole: {
+            type: "string",
+            minLength: 1,
+            maxLength: 80,
+        },
+        action: {
+            type: "string",
+            enum: ["approved", "approved_with_changes", "rejected", "escalated"],
+        },
+        resolutionCode: {
+            type: "string",
+            minLength: 1,
+            maxLength: 80,
+        },
+        notes: {
+            type: "string",
+            minLength: 1,
+            maxLength: 2000,
+        },
+        occurredAt: {
+            type: "string",
+            pattern: "^\\d{4}-\\d{2}-\\d{2}T(?:[01]\\d|2[0-3]):[0-5]\\d:[0-5]\\d(?:\\.\\d+)?(?:Z|[+-](?:[01]\\d|2[0-3]):[0-5]\\d)$",
+            format: "date-time",
+            maxLength: 64,
+        },
+    },
+};
+// --------------------------------------------------------------------
+// CodingDecision (schema 1.0.0, wire coding-decision-v1)
+// --------------------------------------------------------------------
+export const codingDecisionSchema = z
+    .object({
+    decisionId: z.string().min(1).max(128),
+    caseRef: z.string().min(1).max(128),
+    disposition: z.enum(["review_required", "abstain", "escalate"]),
+    humanReviewRequired: z.literal(true),
+    rationale: z
+        .string()
+        .min(1)
+        .max(4000)
+        .refine((value) => value.trim().length > 0),
+    overallConfidence: z.enum(["low", "medium", "high"]).optional(),
+    lineDecisions: z.array(codingDecisionLineSchema).max(100),
+    facts: z
+        .array(z
+        .object({
+        factId: z.string().min(1).max(60),
+        statement: z
+            .string()
+            .min(1)
+            .max(2000)
+            .refine((value) => value.trim().length > 0),
+        evidenceRefs: z.array(z.string().min(1).max(64)).max(10).optional(),
+    })
+        .strict())
+        .max(50)
+        .optional(),
+    gaps: z
+        .array(z
+        .object({
+        gapId: z.string().min(1).max(60),
+        type: z.enum([
+            "missing_documentation",
+            "unsupported_scope",
+            "insufficient_evidence",
+            "policy_conflict",
+            "terminology_unavailable",
+            "other",
+        ]),
+        description: z
+            .string()
+            .min(1)
+            .max(1000)
+            .refine((value) => value.trim().length > 0),
+        severity: z.enum(["low", "medium", "high", "blocking"]),
+    })
+        .strict())
+        .max(30)
+        .optional(),
+    conflicts: z
+        .array(z
+        .object({
+        conflictId: z.string().min(1).max(60),
+        type: z.enum([
+            "payer_vs_national",
+            "plan_vs_contract",
+            "terminology_period",
+            "rule_vs_rule",
+            "model_vs_rule",
+            "other",
+        ]),
+        summary: z
+            .string()
+            .min(1)
+            .max(1000)
+            .refine((value) => value.trim().length > 0),
+        references: z.array(z.string().min(1).max(120)).max(10).optional(),
+    })
+        .strict())
+        .max(20)
+        .optional(),
+    evidenceItems: z.array(codingEvidenceSchema).max(40).optional(),
+    ruleTraces: z.array(codingRuleResultSchema).max(50).optional(),
+    provenance: z
+        .object({
+        decisionSchemaVersion: z.string().min(1).max(40),
+        caseSchemaVersion: z.string().min(1).max(40),
+        pack: z
+            .object({
+            packId: z.string().min(1).max(120),
+            packVersion: z.string().min(1).max(40),
+        })
+            .strict(),
+        model: z
+            .object({
+            modelId: z.string().min(1).max(120),
+            modelVersion: z.string().min(1).max(40),
+        })
+            .strict(),
+        terminology: z
+            .array(z
+            .object({
+            system: z.enum([
+                "ICD-10-CM",
+                "ICD-10-PCS",
+                "CPT",
+                "HCPCS",
+                "NDC",
+                "CDT",
+                "REVENUE_CODE",
+                "DRG",
+                "MODIFIERS",
+                "OTHER",
+            ]),
+            editionVersion: z.string().min(1).max(40),
+            licenseApproved: z.boolean(),
+        })
+            .strict())
+            .max(20),
+        rules: z
+            .array(z
+            .object({
+            ruleId: z.string().min(1).max(120),
+            ruleVersion: z.string().min(1).max(40),
+        })
+            .strict())
+            .max(30),
+        retrievalCorpus: z
+            .object({
+            corpusId: z.string().min(1).max(120).optional(),
+            corpusVersion: z.string().min(1).max(120).optional(),
+        })
+            .strict()
+            .optional(),
+        generatedAt: z
+            .string()
+            .regex(new RegExp("^\\d{4}-\\d{2}-\\d{2}T(?:[01]\\d|2[0-3]):[0-5]\\d:[0-5]\\d(?:\\.\\d+)?(?:Z|[+-](?:[01]\\d|2[0-3]):[0-5]\\d)$"))
+            .refine(isRfc3339DateTime)
+            .max(64),
+    })
+        .strict(),
+    reviewerAction: codingReviewerActionSchema.optional(),
+    extensions: z.array(codingExtensionSchema).max(25).optional(),
+})
+    .strict()
+    .superRefine((value, ctx) => {
+    if (value["disposition"] === "review_required") {
+        if (!Array.isArray(value["lineDecisions"]) ||
+            value["lineDecisions"].length === 0) {
+            ctx.addIssue({
+                code: "custom",
+                path: ["lineDecisions"],
+                message: "decision_review_required_lines",
+            });
+        }
+    }
+    else {
+        if (Array.isArray(value["lineDecisions"]) &&
+            value["lineDecisions"].length > 0) {
+            ctx.addIssue({
+                code: "custom",
+                path: ["lineDecisions"],
+                message: "decision_disposition_lines",
+            });
+        }
+    }
+})
+    .superRefine((value, ctx) => {
+    const semanticValue = value;
+    const provenance = isRecord(semanticValue["provenance"])
+        ? semanticValue["provenance"]
+        : {};
+    if (Array.isArray(semanticValue["lineDecisions"]) &&
+        semanticValue["lineDecisions"].length > 0 &&
+        (!Array.isArray(provenance["terminology"]) ||
+            provenance["terminology"].length === 0 ||
+            !Array.isArray(provenance["rules"]) ||
+            provenance["rules"].length === 0)) {
+        ctx.addIssue({
+            code: "custom",
+            path: ["provenance"],
+            message: "decision_provenance_replay",
+        });
+    }
+});
+export function codingDecisionValidationError(value, options) {
+    if (!isRecord(value))
+        return "coding_decision";
+    if (![
+        "decisionId",
+        "caseRef",
+        "disposition",
+        "humanReviewRequired",
+        "rationale",
+        "lineDecisions",
+        "provenance",
+    ].every((key) => key in value))
+        return "coding_decision_keys";
+    if (!Object.keys(value).every((key) => [
+        "decisionId",
+        "caseRef",
+        "disposition",
+        "humanReviewRequired",
+        "rationale",
+        "overallConfidence",
+        "lineDecisions",
+        "facts",
+        "gaps",
+        "conflicts",
+        "evidenceItems",
+        "ruleTraces",
+        "provenance",
+        "reviewerAction",
+        "extensions",
+    ].includes(key)))
+        return "coding_decision_keys";
+    const value_decisionId = value["decisionId"];
+    if (typeof value_decisionId !== "string" ||
+        value_decisionId.length < 1 ||
+        value_decisionId.length > 128)
+        return "decision_id";
+    const value_caseRef = value["caseRef"];
+    if (typeof value_caseRef !== "string" ||
+        value_caseRef.length < 1 ||
+        value_caseRef.length > 128)
+        return "decision_case_ref";
+    const value_disposition = value["disposition"];
+    if (typeof value_disposition !== "string" ||
+        !["review_required", "abstain", "escalate"].includes(value_disposition))
+        return "decision_disposition";
+    const value_humanReviewRequired = value["humanReviewRequired"];
+    if (typeof value_humanReviewRequired !== "boolean" ||
+        value_humanReviewRequired !== true)
+        return "decision_human_review_required";
+    const value_rationale = value["rationale"];
+    if (typeof value_rationale !== "string" ||
+        value_rationale.length < 1 ||
+        value_rationale.length > 4000 ||
+        value_rationale.trim().length === 0)
+        return "decision_rationale";
+    if (value["overallConfidence"] !== undefined) {
+        const value_overallConfidence = value["overallConfidence"];
+        if (typeof value_overallConfidence !== "string" ||
+            !["low", "medium", "high"].includes(value_overallConfidence))
+            return "decision_overall_confidence";
+    }
+    const value_lineDecisions = value["lineDecisions"];
+    if (!Array.isArray(value_lineDecisions) || value_lineDecisions.length > 100)
+        return "decision_lines";
+    for (const item of value_lineDecisions) {
+        const itemRefError = codingDecisionLineValidationError(item);
+        if (itemRefError !== null)
+            return itemRefError;
+    }
+    if (value["facts"] !== undefined) {
+        const value_facts = value["facts"];
+        if (!Array.isArray(value_facts) || value_facts.length > 50)
+            return "decision_facts";
+        for (const item of value_facts) {
+            if (!isRecord(item))
+                return "decision_fact";
+            if (!["factId", "statement"].every((key) => key in item))
+                return "decision_fact_keys";
+            if (!Object.keys(item).every((key) => ["factId", "statement", "evidenceRefs"].includes(key)))
+                return "decision_fact_keys";
+            const item_factId = item["factId"];
+            if (typeof item_factId !== "string" ||
+                item_factId.length < 1 ||
+                item_factId.length > 60)
+                return "decision_fact_id";
+            const item_statement = item["statement"];
+            if (typeof item_statement !== "string" ||
+                item_statement.length < 1 ||
+                item_statement.length > 2000 ||
+                item_statement.trim().length === 0)
+                return "decision_fact_statement";
+            if (item["evidenceRefs"] !== undefined) {
+                const item_evidenceRefs = item["evidenceRefs"];
+                if (!Array.isArray(item_evidenceRefs) || item_evidenceRefs.length > 10)
+                    return "decision_fact_evidence_refs";
+                for (const item of item_evidenceRefs) {
+                    if (typeof item !== "string" || item.length < 1 || item.length > 64)
+                        return "decision_fact_evidence_refs";
+                }
+            }
+        }
+    }
+    if (value["gaps"] !== undefined) {
+        const value_gaps = value["gaps"];
+        if (!Array.isArray(value_gaps) || value_gaps.length > 30)
+            return "decision_gaps";
+        for (const item of value_gaps) {
+            if (!isRecord(item))
+                return "decision_gap";
+            if (!["gapId", "type", "description", "severity"].every((key) => key in item))
+                return "decision_gap_keys";
+            if (!Object.keys(item).every((key) => ["gapId", "type", "description", "severity"].includes(key)))
+                return "decision_gap_keys";
+            const item_gapId = item["gapId"];
+            if (typeof item_gapId !== "string" ||
+                item_gapId.length < 1 ||
+                item_gapId.length > 60)
+                return "decision_gap_id";
+            const item_type = item["type"];
+            if (typeof item_type !== "string" ||
+                ![
+                    "missing_documentation",
+                    "unsupported_scope",
+                    "insufficient_evidence",
+                    "policy_conflict",
+                    "terminology_unavailable",
+                    "other",
+                ].includes(item_type))
+                return "decision_gap_type";
+            const item_description = item["description"];
+            if (typeof item_description !== "string" ||
+                item_description.length < 1 ||
+                item_description.length > 1000 ||
+                item_description.trim().length === 0)
+                return "decision_gap_description";
+            const item_severity = item["severity"];
+            if (typeof item_severity !== "string" ||
+                !["low", "medium", "high", "blocking"].includes(item_severity))
+                return "decision_gap_severity";
+        }
+    }
+    if (value["conflicts"] !== undefined) {
+        const value_conflicts = value["conflicts"];
+        if (!Array.isArray(value_conflicts) || value_conflicts.length > 20)
+            return "decision_conflicts";
+        for (const item of value_conflicts) {
+            if (!isRecord(item))
+                return "decision_conflict";
+            if (!["conflictId", "type", "summary"].every((key) => key in item))
+                return "decision_conflict_keys";
+            if (!Object.keys(item).every((key) => ["conflictId", "type", "summary", "references"].includes(key)))
+                return "decision_conflict_keys";
+            const item_conflictId = item["conflictId"];
+            if (typeof item_conflictId !== "string" ||
+                item_conflictId.length < 1 ||
+                item_conflictId.length > 60)
+                return "decision_conflict_id";
+            const item_type = item["type"];
+            if (typeof item_type !== "string" ||
+                ![
+                    "payer_vs_national",
+                    "plan_vs_contract",
+                    "terminology_period",
+                    "rule_vs_rule",
+                    "model_vs_rule",
+                    "other",
+                ].includes(item_type))
+                return "decision_conflict_type";
+            const item_summary = item["summary"];
+            if (typeof item_summary !== "string" ||
+                item_summary.length < 1 ||
+                item_summary.length > 1000 ||
+                item_summary.trim().length === 0)
+                return "decision_conflict_summary";
+            if (item["references"] !== undefined) {
+                const item_references = item["references"];
+                if (!Array.isArray(item_references) || item_references.length > 10)
+                    return "decision_conflict_references";
+                for (const item of item_references) {
+                    if (typeof item !== "string" || item.length < 1 || item.length > 120)
+                        return "decision_conflict_references";
+                }
+            }
+        }
+    }
+    if (value["evidenceItems"] !== undefined) {
+        const value_evidenceItems = value["evidenceItems"];
+        if (!Array.isArray(value_evidenceItems) || value_evidenceItems.length > 40)
+            return "decision_evidence_items";
+        for (const item of value_evidenceItems) {
+            const itemRefError = codingEvidenceValidationError(item);
+            if (itemRefError !== null)
+                return itemRefError;
+        }
+    }
+    if (value["ruleTraces"] !== undefined) {
+        const value_ruleTraces = value["ruleTraces"];
+        if (!Array.isArray(value_ruleTraces) || value_ruleTraces.length > 50)
+            return "decision_rule_traces";
+        for (const item of value_ruleTraces) {
+            const itemRefError = codingRuleResultValidationError(item);
+            if (itemRefError !== null)
+                return itemRefError;
+        }
+    }
+    const value_provenance = value["provenance"];
+    if (!isRecord(value_provenance))
+        return "decision_provenance";
+    if (![
+        "decisionSchemaVersion",
+        "caseSchemaVersion",
+        "pack",
+        "model",
+        "terminology",
+        "rules",
+        "generatedAt",
+    ].every((key) => key in value_provenance))
+        return "decision_provenance_keys";
+    if (!Object.keys(value_provenance).every((key) => [
+        "decisionSchemaVersion",
+        "caseSchemaVersion",
+        "pack",
+        "model",
+        "terminology",
+        "rules",
+        "retrievalCorpus",
+        "generatedAt",
+    ].includes(key)))
+        return "decision_provenance_keys";
+    const value_provenance_decisionSchemaVersion = value_provenance["decisionSchemaVersion"];
+    if (typeof value_provenance_decisionSchemaVersion !== "string" ||
+        value_provenance_decisionSchemaVersion.length < 1 ||
+        value_provenance_decisionSchemaVersion.length > 40)
+        return "decision_provenance_decision_schema_version";
+    const value_provenance_caseSchemaVersion = value_provenance["caseSchemaVersion"];
+    if (typeof value_provenance_caseSchemaVersion !== "string" ||
+        value_provenance_caseSchemaVersion.length < 1 ||
+        value_provenance_caseSchemaVersion.length > 40)
+        return "decision_provenance_case_schema_version";
+    const value_provenance_pack = value_provenance["pack"];
+    if (!isRecord(value_provenance_pack))
+        return "decision_provenance_pack";
+    if (!["packId", "packVersion"].every((key) => key in value_provenance_pack))
+        return "decision_provenance_pack_keys";
+    if (!Object.keys(value_provenance_pack).every((key) => ["packId", "packVersion"].includes(key)))
+        return "decision_provenance_pack_keys";
+    const value_provenance_pack_packId = value_provenance_pack["packId"];
+    if (typeof value_provenance_pack_packId !== "string" ||
+        value_provenance_pack_packId.length < 1 ||
+        value_provenance_pack_packId.length > 120)
+        return "decision_provenance_pack_id";
+    const value_provenance_pack_packVersion = value_provenance_pack["packVersion"];
+    if (typeof value_provenance_pack_packVersion !== "string" ||
+        value_provenance_pack_packVersion.length < 1 ||
+        value_provenance_pack_packVersion.length > 40)
+        return "decision_provenance_pack_version";
+    const value_provenance_model = value_provenance["model"];
+    if (!isRecord(value_provenance_model))
+        return "decision_provenance_model";
+    if (!["modelId", "modelVersion"].every((key) => key in value_provenance_model))
+        return "decision_provenance_model_keys";
+    if (!Object.keys(value_provenance_model).every((key) => ["modelId", "modelVersion"].includes(key)))
+        return "decision_provenance_model_keys";
+    const value_provenance_model_modelId = value_provenance_model["modelId"];
+    if (typeof value_provenance_model_modelId !== "string" ||
+        value_provenance_model_modelId.length < 1 ||
+        value_provenance_model_modelId.length > 120)
+        return "decision_provenance_model_id";
+    const value_provenance_model_modelVersion = value_provenance_model["modelVersion"];
+    if (typeof value_provenance_model_modelVersion !== "string" ||
+        value_provenance_model_modelVersion.length < 1 ||
+        value_provenance_model_modelVersion.length > 40)
+        return "decision_provenance_model_version";
+    const value_provenance_terminology = value_provenance["terminology"];
+    if (!Array.isArray(value_provenance_terminology) ||
+        value_provenance_terminology.length > 20)
+        return "decision_provenance_terminology";
+    for (const item of value_provenance_terminology) {
+        if (!isRecord(item))
+            return "decision_provenance_terminology_item";
+        if (!["system", "editionVersion", "licenseApproved"].every((key) => key in item))
+            return "decision_provenance_terminology_item_keys";
+        if (!Object.keys(item).every((key) => ["system", "editionVersion", "licenseApproved"].includes(key)))
+            return "decision_provenance_terminology_item_keys";
+        const item_system = item["system"];
+        if (typeof item_system !== "string" ||
+            ![
+                "ICD-10-CM",
+                "ICD-10-PCS",
+                "CPT",
+                "HCPCS",
+                "NDC",
+                "CDT",
+                "REVENUE_CODE",
+                "DRG",
+                "MODIFIERS",
+                "OTHER",
+            ].includes(item_system))
+            return "decision_provenance_terminology_system";
+        const item_editionVersion = item["editionVersion"];
+        if (typeof item_editionVersion !== "string" ||
+            item_editionVersion.length < 1 ||
+            item_editionVersion.length > 40)
+            return "decision_provenance_terminology_edition";
+        const item_licenseApproved = item["licenseApproved"];
+        if (typeof item_licenseApproved !== "boolean")
+            return "decision_provenance_terminology_license";
+    }
+    const value_provenance_rules = value_provenance["rules"];
+    if (!Array.isArray(value_provenance_rules) ||
+        value_provenance_rules.length > 30)
+        return "decision_provenance_rules";
+    for (const item of value_provenance_rules) {
+        if (!isRecord(item))
+            return "decision_provenance_rule";
+        if (!["ruleId", "ruleVersion"].every((key) => key in item))
+            return "decision_provenance_rule_keys";
+        if (!Object.keys(item).every((key) => ["ruleId", "ruleVersion"].includes(key)))
+            return "decision_provenance_rule_keys";
+        const item_ruleId = item["ruleId"];
+        if (typeof item_ruleId !== "string" ||
+            item_ruleId.length < 1 ||
+            item_ruleId.length > 120)
+            return "decision_provenance_rule_id";
+        const item_ruleVersion = item["ruleVersion"];
+        if (typeof item_ruleVersion !== "string" ||
+            item_ruleVersion.length < 1 ||
+            item_ruleVersion.length > 40)
+            return "decision_provenance_rule_version";
+    }
+    if (value_provenance["retrievalCorpus"] !== undefined) {
+        const value_provenance_retrievalCorpus = value_provenance["retrievalCorpus"];
+        if (!isRecord(value_provenance_retrievalCorpus))
+            return "decision_provenance_corpus";
+        if (!Object.keys(value_provenance_retrievalCorpus).every((key) => ["corpusId", "corpusVersion"].includes(key)))
+            return "decision_provenance_corpus_keys";
+        if (value_provenance_retrievalCorpus["corpusId"] !== undefined) {
+            const value_provenance_retrievalCorpus_corpusId = value_provenance_retrievalCorpus["corpusId"];
+            if (typeof value_provenance_retrievalCorpus_corpusId !== "string" ||
+                value_provenance_retrievalCorpus_corpusId.length < 1 ||
+                value_provenance_retrievalCorpus_corpusId.length > 120)
+                return "decision_provenance_corpus_id";
+        }
+        if (value_provenance_retrievalCorpus["corpusVersion"] !== undefined) {
+            const value_provenance_retrievalCorpus_corpusVersion = value_provenance_retrievalCorpus["corpusVersion"];
+            if (typeof value_provenance_retrievalCorpus_corpusVersion !== "string" ||
+                value_provenance_retrievalCorpus_corpusVersion.length < 1 ||
+                value_provenance_retrievalCorpus_corpusVersion.length > 120)
+                return "decision_provenance_corpus_version";
+        }
+    }
+    const value_provenance_generatedAt = value_provenance["generatedAt"];
+    if (typeof value_provenance_generatedAt !== "string" ||
+        value_provenance_generatedAt.length > 64 ||
+        !new RegExp("^\\d{4}-\\d{2}-\\d{2}T(?:[01]\\d|2[0-3]):[0-5]\\d:[0-5]\\d(?:\\.\\d+)?(?:Z|[+-](?:[01]\\d|2[0-3]):[0-5]\\d)$").test(value_provenance_generatedAt) ||
+        !isRfc3339DateTime(value_provenance_generatedAt))
+        return "decision_provenance_generated_at";
+    if (value["reviewerAction"] !== undefined) {
+        const value_reviewerAction = value["reviewerAction"];
+        const value_reviewerActionRefError = codingReviewerActionValidationError(value_reviewerAction);
+        if (value_reviewerActionRefError !== null)
+            return value_reviewerActionRefError;
+    }
+    if (value["extensions"] !== undefined) {
+        const value_extensions = value["extensions"];
+        if (!Array.isArray(value_extensions) || value_extensions.length > 25)
+            return "decision_extensions";
+        for (const item of value_extensions) {
+            const itemRefError = codingExtensionValidationError(item);
+            if (itemRefError !== null)
+                return itemRefError;
+        }
+    }
+    if (value["disposition"] === "review_required") {
+        if (!Array.isArray(value["lineDecisions"]) ||
+            value["lineDecisions"].length === 0)
+            return "decision_review_required_lines";
+    }
+    else {
+        if (Array.isArray(value["lineDecisions"]) &&
+            value["lineDecisions"].length > 0)
+            return "decision_disposition_lines";
+    }
+    if (Array.isArray(value["lineDecisions"]) &&
+        value["lineDecisions"].length > 0) {
+        const provenance = isRecord(value["provenance"]) ? value["provenance"] : {};
+        if (!Array.isArray(provenance["terminology"]) ||
+            provenance["terminology"].length === 0 ||
+            !Array.isArray(provenance["rules"]) ||
+            provenance["rules"].length === 0)
+            return "decision_provenance_replay";
+    }
+    return null;
+}
+export const validCodingDecision = (value) => codingDecisionValidationError(value) === null;
+export const CodingDecisionSchemaJson = {
+    $schema: "https://json-schema.org/draft/2020-12/schema",
+    $id: "https://nexalink.care/contracts/coding-decision.schema.json",
+    title: "CodingDecision",
+    description: "The canonical, reconstructable decision for a CodingCase. caseRef is an analytics-safe reference (the case's analyticsId or a runtime opaque reference) and never a direct identifier. provenance pins the pack, model, terminology, rules, and schema versions needed to replay every recommendation.",
+    version: "1.0.0",
+    type: "object",
+    additionalProperties: false,
+    required: [
+        "decisionId",
+        "caseRef",
+        "disposition",
+        "humanReviewRequired",
+        "rationale",
+        "lineDecisions",
+        "provenance",
+    ],
+    properties: {
+        decisionId: {
+            type: "string",
+            minLength: 1,
+            maxLength: 128,
+        },
+        caseRef: {
+            type: "string",
+            minLength: 1,
+            maxLength: 128,
+        },
+        disposition: {
+            type: "string",
+            enum: ["review_required", "abstain", "escalate"],
+        },
+        humanReviewRequired: {
+            type: "boolean",
+            const: true,
+        },
+        rationale: {
+            type: "string",
+            minLength: 1,
+            maxLength: 4000,
+        },
+        overallConfidence: {
+            type: "string",
+            enum: ["low", "medium", "high"],
+        },
+        lineDecisions: {
+            type: "array",
+            maxItems: 100,
+            items: {
+                $ref: "coding-decision-line.schema.json",
+            },
+        },
+        facts: {
+            type: "array",
+            maxItems: 50,
+            items: {
+                type: "object",
+                additionalProperties: false,
+                required: ["factId", "statement"],
+                properties: {
+                    factId: {
+                        type: "string",
+                        minLength: 1,
+                        maxLength: 60,
+                    },
+                    statement: {
+                        type: "string",
+                        minLength: 1,
+                        maxLength: 2000,
+                    },
+                    evidenceRefs: {
+                        type: "array",
+                        maxItems: 10,
+                        items: {
+                            type: "string",
+                            minLength: 1,
+                            maxLength: 64,
+                        },
+                    },
+                },
+            },
+        },
+        gaps: {
+            type: "array",
+            maxItems: 30,
+            items: {
+                type: "object",
+                additionalProperties: false,
+                required: ["gapId", "type", "description", "severity"],
+                properties: {
+                    gapId: {
+                        type: "string",
+                        minLength: 1,
+                        maxLength: 60,
+                    },
+                    type: {
+                        type: "string",
+                        enum: [
+                            "missing_documentation",
+                            "unsupported_scope",
+                            "insufficient_evidence",
+                            "policy_conflict",
+                            "terminology_unavailable",
+                            "other",
+                        ],
+                    },
+                    description: {
+                        type: "string",
+                        minLength: 1,
+                        maxLength: 1000,
+                    },
+                    severity: {
+                        type: "string",
+                        enum: ["low", "medium", "high", "blocking"],
+                    },
+                },
+            },
+        },
+        conflicts: {
+            type: "array",
+            maxItems: 20,
+            items: {
+                type: "object",
+                additionalProperties: false,
+                required: ["conflictId", "type", "summary"],
+                properties: {
+                    conflictId: {
+                        type: "string",
+                        minLength: 1,
+                        maxLength: 60,
+                    },
+                    type: {
+                        type: "string",
+                        enum: [
+                            "payer_vs_national",
+                            "plan_vs_contract",
+                            "terminology_period",
+                            "rule_vs_rule",
+                            "model_vs_rule",
+                            "other",
+                        ],
+                    },
+                    summary: {
+                        type: "string",
+                        minLength: 1,
+                        maxLength: 1000,
+                    },
+                    references: {
+                        type: "array",
+                        maxItems: 10,
+                        items: {
+                            type: "string",
+                            minLength: 1,
+                            maxLength: 120,
+                        },
+                    },
+                },
+            },
+        },
+        evidenceItems: {
+            type: "array",
+            maxItems: 40,
+            items: {
+                $ref: "coding-evidence.schema.json",
+            },
+        },
+        ruleTraces: {
+            type: "array",
+            maxItems: 50,
+            items: {
+                $ref: "coding-rule-result.schema.json",
+            },
+        },
+        provenance: {
+            type: "object",
+            additionalProperties: false,
+            required: [
+                "decisionSchemaVersion",
+                "caseSchemaVersion",
+                "pack",
+                "model",
+                "terminology",
+                "rules",
+                "generatedAt",
+            ],
+            properties: {
+                decisionSchemaVersion: {
+                    type: "string",
+                    minLength: 1,
+                    maxLength: 40,
+                },
+                caseSchemaVersion: {
+                    type: "string",
+                    minLength: 1,
+                    maxLength: 40,
+                },
+                pack: {
+                    type: "object",
+                    additionalProperties: false,
+                    required: ["packId", "packVersion"],
+                    properties: {
+                        packId: {
+                            type: "string",
+                            minLength: 1,
+                            maxLength: 120,
+                        },
+                        packVersion: {
+                            type: "string",
+                            minLength: 1,
+                            maxLength: 40,
+                        },
+                    },
+                },
+                model: {
+                    type: "object",
+                    additionalProperties: false,
+                    required: ["modelId", "modelVersion"],
+                    properties: {
+                        modelId: {
+                            type: "string",
+                            minLength: 1,
+                            maxLength: 120,
+                        },
+                        modelVersion: {
+                            type: "string",
+                            minLength: 1,
+                            maxLength: 40,
+                        },
+                    },
+                },
+                terminology: {
+                    type: "array",
+                    maxItems: 20,
+                    items: {
+                        type: "object",
+                        additionalProperties: false,
+                        required: ["system", "editionVersion", "licenseApproved"],
+                        properties: {
+                            system: {
+                                type: "string",
+                                enum: [
+                                    "ICD-10-CM",
+                                    "ICD-10-PCS",
+                                    "CPT",
+                                    "HCPCS",
+                                    "NDC",
+                                    "CDT",
+                                    "REVENUE_CODE",
+                                    "DRG",
+                                    "MODIFIERS",
+                                    "OTHER",
+                                ],
+                            },
+                            editionVersion: {
+                                type: "string",
+                                minLength: 1,
+                                maxLength: 40,
+                            },
+                            licenseApproved: {
+                                type: "boolean",
+                            },
+                        },
+                    },
+                },
+                rules: {
+                    type: "array",
+                    maxItems: 30,
+                    items: {
+                        type: "object",
+                        additionalProperties: false,
+                        required: ["ruleId", "ruleVersion"],
+                        properties: {
+                            ruleId: {
+                                type: "string",
+                                minLength: 1,
+                                maxLength: 120,
+                            },
+                            ruleVersion: {
+                                type: "string",
+                                minLength: 1,
+                                maxLength: 40,
+                            },
+                        },
+                    },
+                },
+                retrievalCorpus: {
+                    type: "object",
+                    additionalProperties: false,
+                    properties: {
+                        corpusId: {
+                            type: "string",
+                            minLength: 1,
+                            maxLength: 120,
+                        },
+                        corpusVersion: {
+                            type: "string",
+                            minLength: 1,
+                            maxLength: 120,
+                        },
+                    },
+                },
+                generatedAt: {
+                    type: "string",
+                    pattern: "^\\d{4}-\\d{2}-\\d{2}T(?:[01]\\d|2[0-3]):[0-5]\\d:[0-5]\\d(?:\\.\\d+)?(?:Z|[+-](?:[01]\\d|2[0-3]):[0-5]\\d)$",
+                    format: "date-time",
+                    maxLength: 64,
+                },
+            },
+        },
+        reviewerAction: {
+            $ref: "coding-reviewer-action.schema.json",
+        },
+        extensions: {
+            type: "array",
+            maxItems: 25,
+            items: {
+                $ref: "coding-extension.schema.json",
+            },
+        },
+    },
+    if: {
+        properties: {
+            disposition: {
+                const: "review_required",
+            },
+        },
+        required: ["disposition"],
+    },
+    then: {
+        properties: {
+            lineDecisions: {
+                minItems: 1,
+            },
+            provenance: {
+                properties: {
+                    terminology: {
+                        minItems: 1,
+                    },
+                    rules: {
+                        minItems: 1,
+                    },
+                },
+            },
+        },
+    },
+    else: {
+        properties: {
+            lineDecisions: {
+                maxItems: 0,
+            },
+        },
+    },
+};
+// --------------------------------------------------------------------
 // RcmSupportingReference (schema 1.0.0, wire rcm-supporting-reference-v1)
 // --------------------------------------------------------------------
 export const rcmSupportingReferenceSchema = z
@@ -48,6 +4245,8 @@ export const rcmSupportingReferenceSchema = z
 export function rcmSupportingReferenceValidationError(value) {
     if (!isRecord(value))
         return "reference";
+    if (!["referenceId", "title", "excerpt"].every((key) => key in value))
+        return "reference_keys";
     if (!Object.keys(value).every((key) => [
         "referenceId",
         "documentId",
@@ -61,8 +4260,7 @@ export function rcmSupportingReferenceValidationError(value) {
         "coveredPayerProgram",
         "sourceUrl",
         "humanReviewRequired",
-    ].includes(key)) ||
-        !["referenceId", "title", "excerpt"].every((key) => key in value))
+    ].includes(key)))
         return "reference_keys";
     const value_referenceId = value["referenceId"];
     if (typeof value_referenceId !== "string" ||
@@ -231,6 +4429,8 @@ export const rcmCodingInputSchema = z
 export function rcmCodingInputValidationError(value) {
     if (!isRecord(value))
         return "coding_input";
+    if (!["encounterId", "diagnosisNarrative"].every((key) => key in value))
+        return "coding_input_keys";
     if (!Object.keys(value).every((key) => [
         "encounterId",
         "diagnosisNarrative",
@@ -239,8 +4439,7 @@ export function rcmCodingInputValidationError(value) {
         "placeOfService",
         "claimContext",
         "supportingReferences",
-    ].includes(key)) ||
-        !["encounterId", "diagnosisNarrative"].every((key) => key in value))
+    ].includes(key)))
         return "coding_input_keys";
     const value_encounterId = value["encounterId"];
     if (typeof value_encounterId !== "string" ||
@@ -307,9 +4506,9 @@ export function rcmCodingInputValidationError(value) {
             value_supportingReferences.length > 10)
             return "supporting_references";
         for (const item of value_supportingReferences) {
-            const itemError = rcmSupportingReferenceValidationError(item);
-            if (itemError !== null)
-                return itemError;
+            const itemRefError = rcmSupportingReferenceValidationError(item);
+            if (itemRefError !== null)
+                return itemRefError;
         }
     }
     return null;
@@ -453,20 +4652,21 @@ export const rcmCodingOutputSchema = z
 export function rcmCodingOutputValidationError(value, options) {
     if (!isRecord(value))
         return "not_object";
+    if (![
+        "disposition",
+        "humanReviewRequired",
+        "recommendations",
+        "documentationGaps",
+        "rationale",
+    ].every((key) => key in value))
+        return "top_level_keys";
     if (!Object.keys(value).every((key) => [
         "disposition",
         "humanReviewRequired",
         "rationale",
         "recommendations",
         "documentationGaps",
-    ].includes(key)) ||
-        ![
-            "disposition",
-            "humanReviewRequired",
-            "recommendations",
-            "documentationGaps",
-            "rationale",
-        ].every((key) => key in value))
+    ].includes(key)))
         return "top_level_keys";
     const value_disposition = value["disposition"];
     if (typeof value_disposition !== "string" ||
@@ -489,14 +4689,15 @@ export function rcmCodingOutputValidationError(value, options) {
     for (const item of value_recommendations) {
         if (!isRecord(item))
             return "recommendation_keys";
+        if (!["code", "codeSystem", "confidence", "rationale", "evidenceIds"].every((key) => key in item))
+            return "recommendation_keys";
         if (!Object.keys(item).every((key) => [
             "code",
             "codeSystem",
             "confidence",
             "rationale",
             "evidenceIds",
-        ].includes(key)) ||
-            !["code", "codeSystem", "confidence", "rationale", "evidenceIds"].every((key) => key in item))
+        ].includes(key)))
             return "recommendation_keys";
         const item_code = item["code"];
         if (typeof item_code !== "string" ||
@@ -724,12 +4925,15 @@ export const rcmModelPromptSchema = z
 export function rcmModelPromptValidationError(value) {
     if (!isRecord(value))
         return "model_prompt";
-    if (!Object.keys(value).every((key) => ["encounter", "supportingReferences"].includes(key)) ||
-        !["encounter", "supportingReferences"].every((key) => key in value))
+    if (!["encounter", "supportingReferences"].every((key) => key in value))
+        return "model_prompt_keys";
+    if (!Object.keys(value).every((key) => ["encounter", "supportingReferences"].includes(key)))
         return "model_prompt_keys";
     const value_encounter = value["encounter"];
     if (!isRecord(value_encounter))
         return "encounter";
+    if (!["encounterId", "diagnosisNarrative"].every((key) => key in value_encounter))
+        return "encounter_keys";
     if (!Object.keys(value_encounter).every((key) => [
         "encounterId",
         "diagnosisNarrative",
@@ -737,8 +4941,7 @@ export function rcmModelPromptValidationError(value) {
         "serviceDate",
         "placeOfService",
         "claimContext",
-    ].includes(key)) ||
-        !["encounterId", "diagnosisNarrative"].every((key) => key in value_encounter))
+    ].includes(key)))
         return "encounter_keys";
     const value_encounter_encounterId = value_encounter["encounterId"];
     if (typeof value_encounter_encounterId !== "string" ||
@@ -804,9 +5007,9 @@ export function rcmModelPromptValidationError(value) {
         value_supportingReferences.length > 5)
         return "model_prompt_references";
     for (const item of value_supportingReferences) {
-        const itemError = rcmSupportingReferenceValidationError(item);
-        if (itemError !== null)
-            return itemError;
+        const itemRefError = rcmSupportingReferenceValidationError(item);
+        if (itemRefError !== null)
+            return itemRefError;
     }
     return null;
 }
@@ -901,6 +5104,8 @@ export const rcmRetrievalMetadataSchema = z
 export function rcmRetrievalMetadataValidationError(value) {
     if (!isRecord(value))
         return "retrieval_metadata";
+    if (!["corpusId", "corpusVersion", "outcome", "latencyMs", "references"].every((key) => key in value))
+        return "retrieval_metadata_keys";
     if (!Object.keys(value).every((key) => [
         "corpusId",
         "corpusVersion",
@@ -909,8 +5114,7 @@ export function rcmRetrievalMetadataValidationError(value) {
         "knowledgeBaseId",
         "tenantId",
         "references",
-    ].includes(key)) ||
-        !["corpusId", "corpusVersion", "outcome", "latencyMs", "references"].every((key) => key in value))
+    ].includes(key)))
         return "retrieval_metadata_keys";
     const value_corpusId = value["corpusId"];
     if (typeof value_corpusId !== "string" ||
@@ -947,9 +5151,9 @@ export function rcmRetrievalMetadataValidationError(value) {
     if (!Array.isArray(value_references))
         return "retrieval_references";
     for (const item of value_references) {
-        const itemError = rcmSupportingReferenceValidationError(item);
-        if (itemError !== null)
-            return itemError;
+        const itemRefError = rcmSupportingReferenceValidationError(item);
+        if (itemRefError !== null)
+            return itemRefError;
     }
     return null;
 }
@@ -1060,6 +5264,8 @@ export const rcmRuntimeEventSchema = z
 export function rcmRuntimeEventValidationError(value) {
     if (!isRecord(value))
         return "runtime_event";
+    if (!["type", "outcome", "reason", "occurredAt", "workflowId"].every((key) => key in value))
+        return "runtime_event_keys";
     if (!Object.keys(value).every((key) => [
         "type",
         "outcome",
@@ -1068,8 +5274,7 @@ export function rcmRuntimeEventValidationError(value) {
         "workflowId",
         "guardrail",
         "retrieval",
-    ].includes(key)) ||
-        !["type", "outcome", "reason", "occurredAt", "workflowId"].every((key) => key in value))
+    ].includes(key)))
         return "runtime_event_keys";
     const value_type = value["type"];
     if (typeof value_type !== "string" ||
@@ -1119,8 +5324,9 @@ export function rcmRuntimeEventValidationError(value) {
             for (const item of value_guardrail_actions) {
                 if (!isRecord(item))
                     return "runtime_event_guardrail_action";
-                if (!Object.keys(item).every((key) => ["scope", "policyType", "rule", "action"].includes(key)) ||
-                    !["scope", "policyType", "rule", "action"].every((key) => key in item))
+                if (!["scope", "policyType", "rule", "action"].every((key) => key in item))
+                    return "runtime_event_guardrail_action_keys";
+                if (!Object.keys(item).every((key) => ["scope", "policyType", "rule", "action"].includes(key)))
                     return "runtime_event_guardrail_action_keys";
                 const item_scope = item["scope"];
                 if (typeof item_scope !== "string" || item_scope.length > 64)
@@ -1141,6 +5347,15 @@ export function rcmRuntimeEventValidationError(value) {
         const value_retrieval = value["retrieval"];
         if (!isRecord(value_retrieval))
             return "runtime_event_retrieval";
+        if (![
+            "corpusId",
+            "corpusVersion",
+            "outcome",
+            "referenceCount",
+            "latencyMs",
+            "references",
+        ].every((key) => key in value_retrieval))
+            return "runtime_event_retrieval_keys";
         if (!Object.keys(value_retrieval).every((key) => [
             "corpusId",
             "corpusVersion",
@@ -1148,15 +5363,7 @@ export function rcmRuntimeEventValidationError(value) {
             "referenceCount",
             "latencyMs",
             "references",
-        ].includes(key)) ||
-            ![
-                "corpusId",
-                "corpusVersion",
-                "outcome",
-                "referenceCount",
-                "latencyMs",
-                "references",
-            ].every((key) => key in value_retrieval))
+        ].includes(key)))
             return "runtime_event_retrieval_keys";
         const value_retrieval_corpusId = value_retrieval["corpusId"];
         if (typeof value_retrieval_corpusId !== "string" ||
@@ -1190,8 +5397,9 @@ export function rcmRuntimeEventValidationError(value) {
         for (const item of value_retrieval_references) {
             if (!isRecord(item))
                 return "runtime_event_retrieval_reference";
-            if (!Object.keys(item).every((key) => ["referenceId", "documentId", "version"].includes(key)) ||
-                !["referenceId", "documentId", "version"].every((key) => key in item))
+            if (!["referenceId", "documentId", "version"].every((key) => key in item))
+                return "runtime_event_retrieval_reference_keys";
+            if (!Object.keys(item).every((key) => ["referenceId", "documentId", "version"].includes(key)))
                 return "runtime_event_retrieval_reference_keys";
             const item_referenceId = item["referenceId"];
             if (typeof item_referenceId !== "string" ||
@@ -1382,6 +5590,16 @@ export const rcmWorkflowCatalogSchema = z
 export function rcmWorkflowCatalogValidationError(value) {
     if (!isRecord(value))
         return "workflow_catalog";
+    if (![
+        "id",
+        "name",
+        "description",
+        "environments",
+        "modelPolicy",
+        "humanReviewPolicy",
+        "outputSchemaVersion",
+    ].every((key) => key in value))
+        return "workflow_catalog_keys";
     if (!Object.keys(value).every((key) => [
         "id",
         "name",
@@ -1390,16 +5608,7 @@ export function rcmWorkflowCatalogValidationError(value) {
         "modelPolicy",
         "humanReviewPolicy",
         "outputSchemaVersion",
-    ].includes(key)) ||
-        ![
-            "id",
-            "name",
-            "description",
-            "environments",
-            "modelPolicy",
-            "humanReviewPolicy",
-            "outputSchemaVersion",
-        ].every((key) => key in value))
+    ].includes(key)))
         return "workflow_catalog_keys";
     const value_id = value["id"];
     if (typeof value_id !== "string" ||
@@ -1426,6 +5635,15 @@ export function rcmWorkflowCatalogValidationError(value) {
     const value_modelPolicy = value["modelPolicy"];
     if (!isRecord(value_modelPolicy))
         return "model_policy";
+    if (![
+        "policyId",
+        "inferencePath",
+        "maxNewTokens",
+        "temperature",
+        "outputSchemaVersion",
+        "requireHumanReview",
+    ].every((key) => key in value_modelPolicy))
+        return "model_policy_keys";
     if (!Object.keys(value_modelPolicy).every((key) => [
         "policyId",
         "inferencePath",
@@ -1433,15 +5651,7 @@ export function rcmWorkflowCatalogValidationError(value) {
         "temperature",
         "outputSchemaVersion",
         "requireHumanReview",
-    ].includes(key)) ||
-        ![
-            "policyId",
-            "inferencePath",
-            "maxNewTokens",
-            "temperature",
-            "outputSchemaVersion",
-            "requireHumanReview",
-        ].every((key) => key in value_modelPolicy))
+    ].includes(key)))
         return "model_policy_keys";
     const value_modelPolicy_policyId = value_modelPolicy["policyId"];
     if (typeof value_modelPolicy_policyId !== "string" ||
@@ -1475,8 +5685,9 @@ export function rcmWorkflowCatalogValidationError(value) {
     const value_humanReviewPolicy = value["humanReviewPolicy"];
     if (!isRecord(value_humanReviewPolicy))
         return "human_review_policy";
-    if (!Object.keys(value_humanReviewPolicy).every((key) => ["policyId", "humanReviewRequired"].includes(key)) ||
-        !["policyId", "humanReviewRequired"].every((key) => key in value_humanReviewPolicy))
+    if (!["policyId", "humanReviewRequired"].every((key) => key in value_humanReviewPolicy))
+        return "human_review_policy_keys";
+    if (!Object.keys(value_humanReviewPolicy).every((key) => ["policyId", "humanReviewRequired"].includes(key)))
         return "human_review_policy_keys";
     const value_humanReviewPolicy_policyId = value_humanReviewPolicy["policyId"];
     if (typeof value_humanReviewPolicy_policyId !== "string" ||