@centricare/contract 0.1.2 → 0.2.1

package/dist/index.mjs

@@ -0,0 +1,1820 @@
+import z5, { z } from 'zod';
+import { toMongooseSchema } from '@nullix/zod-mongoose';
+import { model } from 'mongoose';
+
+// src/commons/timestamp.ts
+var isoDatetimeRegex = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[+-]\d{2}:?\d{2})$/;
+var timestampSchema = z.string().refine(
+  (val) => isoDatetimeRegex.test(val),
+  { message: "Invalid timestamp: must be an ISO 8601 datetime" }
+);
+var metadataSchema = z.object({
+  total: z.number().int().nonnegative(),
+  offset: z.number().int().nonnegative(),
+  limit: z.number().int().nonnegative(),
+  next: z.string().nullable(),
+  previous: z.string().nullable()
+});
+var apiResponseSchema = (dataSchema) => z.object({
+  success: z.boolean(),
+  message: z.string(),
+  status_code: z.string(),
+  data: z.array(dataSchema),
+  metadata: metadataSchema
+});
+var singleResourceResponseSchema = (dataSchema) => apiResponseSchema(dataSchema).refine(
+  (data) => data.metadata.total === 1 && data.metadata.offset === 0 && data.metadata.limit === 0 && data.metadata.next === null && data.metadata.previous === null,
+  {
+    message: "Single resource response metadata must have total=1, offset=0, limit=0, next=null, previous=null"
+  }
+);
+var settingOptionTypeSchema = z.union([
+  z.enum(["string", "number", "boolean", "date"]),
+  z.array(z.enum(["string", "number", "boolean", "date"])),
+  z.string()
+]);
+var settingOptionSchema = z.object({
+  field: z.string().min(1, { message: "field is required" }),
+  label: z.string().optional(),
+  type: settingOptionTypeSchema,
+  default: z.string().nullable(),
+  value: z.union([z.string(), z.boolean(), z.number()]).nullable()
+});
+
+// src/registry/registry.json
+var registry_default = {
+  systems: [
+    {
+      system: "crn:status:system",
+      domain: "status",
+      variant: "system",
+      display: "System Status",
+      description: "Status of a record",
+      type: "parameter",
+      values: [
+        {
+          value: "active",
+          display: "Active",
+          description: "Record is still active and valid",
+          status: "Active"
+        },
+        {
+          value: "inactive",
+          display: "Inactive",
+          description: "Record is no longer active and valid",
+          status: "Active"
+        },
+        {
+          value: "suspended",
+          display: "Suspended",
+          description: "Record is suspended and may not be used or valid until the suspension is over",
+          status: "Active"
+        }
+      ]
+    },
+    {
+      system: "crn:status:patient",
+      domain: "status",
+      variant: "patient",
+      display: "Patient Status",
+      description: "Patient-specific status codes",
+      type: "parameter",
+      values: [
+        {
+          value: "blacklisted",
+          display: "Blacklisted",
+          description: "Patient is blacklisted from the facility",
+          status: "Active"
+        },
+        {
+          value: "deceased",
+          display: "Deceased",
+          description: "Patient is already deceased",
+          status: "Active"
+        }
+      ]
+    },
+    {
+      system: "crn:status:marital",
+      domain: "status",
+      variant: "marital",
+      display: "Marital Status",
+      description: "Marital status codes",
+      type: "parameter",
+      values: [
+        {
+          value: "married",
+          display: "Married",
+          description: "Person is married",
+          status: "Active"
+        },
+        {
+          value: "unmarried",
+          display: "Unmarried",
+          description: "Person is not married",
+          status: "Active"
+        },
+        {
+          value: "widowed",
+          display: "Widowed",
+          description: "Person is widowed due to the death of their spouse",
+          status: "Active"
+        },
+        {
+          value: "divorced",
+          display: "Divorced",
+          description: "Person is legally divorced",
+          status: "Active"
+        }
+      ]
+    },
+    {
+      system: "crn:status:operational",
+      domain: "status",
+      variant: "operational",
+      display: "Operational Status",
+      description: "Resource operational status",
+      type: "parameter",
+      values: [
+        {
+          value: "open",
+          display: "Open",
+          description: "Resource is open and operating",
+          status: "Active"
+        },
+        {
+          value: "closed",
+          display: "Closed",
+          description: "Resource is closed and not operating",
+          status: "Active"
+        },
+        {
+          value: "maintenance",
+          display: "Maintenance",
+          description: "Resource is in maintenance and not operating",
+          status: "Active"
+        }
+      ]
+    },
+    {
+      system: "crn:status:queue",
+      domain: "status",
+      variant: "queue",
+      display: "Queue Status",
+      description: "Queue number status",
+      type: "parameter",
+      values: [
+        {
+          value: "idle",
+          display: "Idle",
+          description: "Queue number are not in progress",
+          status: "Active"
+        },
+        {
+          value: "in-progress",
+          display: "In Progress",
+          description: "Queue number are in progress",
+          status: "Active"
+        },
+        {
+          value: "done",
+          display: "Done",
+          description: "Queue number are done with service",
+          status: "Active"
+        },
+        {
+          value: "skip",
+          display: "Skip",
+          description: "Indicate the queue number are skipped and at the bottom of call priority",
+          status: "Active"
+        }
+      ]
+    },
+    {
+      system: "crn:salutation",
+      domain: "salutation",
+      variant: null,
+      display: "Salutation",
+      description: "Person salutations/honorifics",
+      type: "parameter",
+      values: [
+        {
+          value: "tuan",
+          display: "Tn.",
+          description: "Adult male honorific or title (Mr.)",
+          status: "Active"
+        },
+        {
+          value: "nyonya",
+          display: "Ny.",
+          description: "Married or adult female honorific or title (Mrs.)",
+          status: "Active"
+        },
+        {
+          value: "anak",
+          display: "An.",
+          description: "Child or pediatric patient honorific",
+          status: "Active"
+        }
+      ]
+    },
+    {
+      system: "crn:sex",
+      domain: "sex",
+      variant: null,
+      display: "Biological Sex",
+      description: "Biological and physiological characteristics",
+      type: "parameter",
+      values: [
+        {
+          value: "m",
+          display: "Male",
+          description: "Male characteristics",
+          status: "Active"
+        },
+        {
+          value: "f",
+          display: "Female",
+          description: "Female characteristics",
+          status: "Active"
+        },
+        {
+          value: "i",
+          display: "Intersex",
+          description: "Biological sex characteristics that do not fit typical medical definitions",
+          status: "Proposed"
+        }
+      ]
+    },
+    {
+      system: "crn:believes",
+      domain: "believes",
+      variant: null,
+      display: "Religion/Belief",
+      description: "Religion or belief system",
+      type: "parameter",
+      values: [
+        {
+          value: "islam",
+          display: "Islam",
+          description: "The islamic belief system",
+          status: "Active"
+        },
+        {
+          value: "protestantism",
+          display: "Protestant",
+          description: "The protestantism belief system",
+          status: "Active"
+        },
+        {
+          value: "catholicism",
+          display: "Catholic",
+          description: "The catholicism belief system",
+          status: "Active"
+        },
+        {
+          value: "hinduism",
+          display: "Hindu",
+          description: "The hinduism belief system",
+          status: "Active"
+        },
+        {
+          value: "buddhism",
+          display: "Buddha",
+          description: "The buddhism belief system",
+          status: "Active"
+        },
+        {
+          value: "confucianism",
+          display: "Confucian",
+          description: "The confucianism belief system",
+          status: "Active"
+        }
+      ]
+    },
+    {
+      system: "crn:blood:type",
+      domain: "blood",
+      variant: "type",
+      display: "Blood Type",
+      description: "Blood group types",
+      type: "parameter",
+      values: [
+        {
+          value: "a",
+          display: "A",
+          description: "Blood group A",
+          status: "Active"
+        },
+        {
+          value: "b",
+          display: "B",
+          description: "Blood group B",
+          status: "Active"
+        },
+        {
+          value: "ab",
+          display: "AB",
+          description: "Blood group AB",
+          status: "Active"
+        },
+        {
+          value: "o",
+          display: "O",
+          description: "Blood group O",
+          status: "Active"
+        }
+      ]
+    },
+    {
+      system: "crn:blood:rhesus",
+      domain: "blood",
+      variant: "rhesus",
+      display: "Rhesus Factor",
+      description: "RhD antigen presence",
+      type: "parameter",
+      values: [
+        {
+          value: "positive",
+          display: "Rh-Positive (+)",
+          description: "Presence of Rhesus (RhD) antigen",
+          status: "Active"
+        },
+        {
+          value: "negative",
+          display: "Rh-Negative (-)",
+          description: "Absence of Rhesus (RhD) antigen",
+          status: "Active"
+        }
+      ]
+    },
+    {
+      system: "crn:flag:tier",
+      domain: "flag",
+      variant: "tier",
+      display: "Priority Tier",
+      description: "Priority/precedence levels",
+      type: "parameter",
+      values: [
+        {
+          value: "primary",
+          display: "Primary",
+          description: "Highest level of priority",
+          status: "Active"
+        },
+        {
+          value: "secondary",
+          display: "Secondary",
+          description: "Secondary level of priority",
+          status: "Active"
+        },
+        {
+          value: "tertiary",
+          display: "Tertiary",
+          description: "Third-tier or lowest level of priority",
+          status: "Active"
+        }
+      ]
+    },
+    {
+      system: "crn:flag:intensity",
+      domain: "flag",
+      variant: "intensity",
+      display: "Intensity Level",
+      description: "Intensity/severity levels",
+      type: "parameter",
+      values: [
+        {
+          value: "very-low",
+          display: "Very Low",
+          description: "Minimal or lowest level of intensity",
+          status: "Active"
+        },
+        {
+          value: "low",
+          display: "Low",
+          description: "Minor or low level of intensity",
+          status: "Active"
+        },
+        {
+          value: "medium",
+          display: "Medium",
+          description: "Moderate or average level of intensity",
+          status: "Active"
+        },
+        {
+          value: "high",
+          display: "High",
+          description: "High or elevated level of intensity",
+          status: "Active"
+        },
+        {
+          value: "very-high",
+          display: "Very High",
+          description: "Extreme or critical level of intensity",
+          status: "Active"
+        }
+      ]
+    },
+    {
+      system: "crn:mrn:separator",
+      domain: "mrn",
+      variant: "separator",
+      display: "MRN Separator",
+      description: "Medical Record Number separators",
+      type: "parameter",
+      values: [
+        {
+          value: "dash",
+          display: "Dash (-)",
+          description: "Use dash as separator",
+          status: "Active"
+        },
+        {
+          value: "dot",
+          display: "Dot (.)",
+          description: "Use dot as separator",
+          status: "Active"
+        },
+        {
+          value: "none",
+          display: "None",
+          description: "No separator",
+          status: "Active"
+        }
+      ]
+    },
+    {
+      system: "crn:patient:additional",
+      domain: "patient",
+      variant: "additional",
+      display: "Patient Additional Info Types",
+      description: "Types of patient additional information",
+      type: "parameter",
+      values: [
+        {
+          value: "emergency-contact",
+          display: "Emergency Contact",
+          description: "Patient emergency contact info",
+          status: "Active"
+        },
+        {
+          value: "emergency-address",
+          display: "Emergency Address",
+          description: "Patient emergency address info",
+          status: "Active"
+        },
+        {
+          value: "relationship",
+          display: "Relationship",
+          description: "Patient relationship information",
+          status: "Active"
+        },
+        {
+          value: "blood-info",
+          display: "Blood Information",
+          description: "Patient blood information",
+          status: "Active"
+        },
+        {
+          value: "payer",
+          display: "Payer Information",
+          description: "Patient payer information",
+          status: "Active"
+        }
+      ]
+    },
+    {
+      system: "crn:payer:category",
+      domain: "payer",
+      variant: "category",
+      display: "Payer Category",
+      description: "Healthcare payer categories",
+      type: "parameter",
+      values: [
+        {
+          value: "insurance",
+          display: "Insurance",
+          description: "Third-party health insurance payer",
+          status: "Active"
+        },
+        {
+          value: "government",
+          display: "Government",
+          description: "Government-sponsored health program",
+          status: "Active"
+        },
+        {
+          value: "corporate",
+          display: "Corporate",
+          description: "Company-sponsored health benefit",
+          status: "Active"
+        },
+        {
+          value: "self",
+          display: "Self",
+          description: "Patient pay out of pocket",
+          status: "Active"
+        }
+      ]
+    },
+    {
+      system: "crn:queue:stage",
+      domain: "queue",
+      variant: "stage",
+      display: "Queue Stage",
+      description: "Queue processing stages",
+      type: "parameter",
+      values: [
+        {
+          value: "waiting",
+          display: "Waiting",
+          description: "Waiting stage",
+          status: "Active"
+        },
+        {
+          value: "processing",
+          display: "Processing",
+          description: "Processing stage",
+          status: "Active"
+        }
+      ]
+    },
+    {
+      system: "crn:queue:priority",
+      domain: "queue",
+      variant: "priority",
+      display: "Queue Priority",
+      description: "Queue sort and call priority",
+      type: "parameter",
+      values: [
+        {
+          value: "sequence",
+          display: "Sequence",
+          description: "Based on queue sequence number",
+          status: "Active"
+        },
+        {
+          value: "arrival",
+          display: "Arrival",
+          description: "Based on queue arrival",
+          status: "Active"
+        }
+      ]
+    },
+    {
+      system: "crn:relationship:family",
+      domain: "relationship",
+      variant: "family",
+      display: "Family Relationship",
+      description: "Family relationship types",
+      type: "parameter",
+      values: [
+        {
+          value: "spouse",
+          display: "Spouse",
+          description: "Partner in a marriage or legal union",
+          status: "Active"
+        },
+        {
+          value: "father",
+          display: "Father",
+          description: "Male parent",
+          status: "Active"
+        },
+        {
+          value: "mother",
+          display: "Mother",
+          description: "Female parent",
+          status: "Active"
+        },
+        {
+          value: "grandfather",
+          display: "Grandfather",
+          description: "Father of a person's father or mother",
+          status: "Active"
+        },
+        {
+          value: "grandmother",
+          display: "Grandmother",
+          description: "Mother of a person's father or mother",
+          status: "Active"
+        },
+        {
+          value: "grandchildren",
+          display: "Grandchildren",
+          description: "Child or children of a person's son or daughter",
+          status: "Active"
+        },
+        {
+          value: "children",
+          display: "Children",
+          description: "Person's offspring or child",
+          status: "Active"
+        }
+      ]
+    },
+    {
+      system: "crn:schedule",
+      domain: "schedule",
+      variant: null,
+      display: "Schedule Type",
+      description: "Practitioner schedule types",
+      type: "parameter",
+      values: [
+        {
+          value: "recurring",
+          display: "Recurring",
+          description: "A recurring schedule",
+          status: "Active"
+        },
+        {
+          value: "one-time",
+          display: "One-Time",
+          description: "A one-time schedule",
+          status: "Active"
+        }
+      ]
+    },
+    {
+      system: "crn:taxonomy:department",
+      domain: "taxonomy",
+      variant: "department",
+      display: "Department",
+      description: "Department classifications",
+      type: "parameter",
+      values: [
+        {
+          value: "medical",
+          display: "Medical",
+          description: "Department for medical affair",
+          status: "Active"
+        },
+        {
+          value: "administrative",
+          display: "Administrative",
+          description: "Department for administrative affair",
+          status: "Active"
+        },
+        {
+          value: "operational",
+          display: "Operational",
+          description: "Department for operational affair",
+          status: "Active"
+        }
+      ]
+    },
+    {
+      system: "crn:taxonomy:unit",
+      domain: "taxonomy",
+      variant: "unit",
+      display: "Unit Types",
+      description: "Unit classifications",
+      type: "parameter",
+      values: [
+        {
+          value: "medical-service",
+          display: "Medical Service",
+          description: "Unit that provide medical service",
+          status: "Active"
+        },
+        {
+          value: "pharmacy",
+          display: "Pharmacy",
+          description: "Unit for pharmacy",
+          status: "Active"
+        },
+        {
+          value: "ancillary",
+          display: "Ancillary",
+          description: "Unit for ancillary services",
+          status: "Active"
+        },
+        {
+          value: "service-counter",
+          display: "Service Counter",
+          description: "Unit that act as counter for various purposes",
+          status: "Active"
+        },
+        {
+          value: "cashier",
+          display: "Cashier",
+          description: "Unit that act as counter for cashier",
+          status: "Active"
+        }
+      ]
+    },
+    {
+      system: "crn:taxonomy:location",
+      domain: "taxonomy",
+      variant: "location",
+      display: "Location Types",
+      description: "Location classifications",
+      type: "parameter",
+      values: [
+        {
+          value: "building",
+          display: "Building",
+          description: "A building",
+          status: "Active"
+        },
+        {
+          value: "level",
+          display: "Level",
+          description: "A floor level",
+          status: "Active"
+        },
+        {
+          value: "bed",
+          display: "Bed",
+          description: "A bed",
+          status: "Active"
+        },
+        {
+          value: "cabinet",
+          display: "Cabinet",
+          description: "A cabinet",
+          status: "Active"
+        }
+      ]
+    },
+    {
+      system: "crn:taxonomy:staff",
+      domain: "taxonomy",
+      variant: "staff",
+      display: "Staff Types",
+      description: "Staff classifications",
+      type: "parameter",
+      values: [
+        {
+          value: "practitioner",
+          display: "Practitioner",
+          description: "Healthcare practitioner (i.e. Doctor)",
+          status: "Active"
+        },
+        {
+          value: "medical",
+          display: "Medical",
+          description: "Medical staff (i.e. Nurse, Therapist)",
+          status: "Active"
+        },
+        {
+          value: "non-medical",
+          display: "Non Medical",
+          description: "Non medical staff (i.e. Administrator staff)",
+          status: "Active"
+        }
+      ]
+    },
+    {
+      system: "crn:assignment:type",
+      domain: "assignment",
+      variant: "type",
+      display: "Assignment Type",
+      description: "Resource assignment types",
+      type: "parameter",
+      values: [
+        {
+          value: "staff-to-unit",
+          display: "Staff to Unit",
+          description: "Assignment of staff to a unit",
+          status: "Active"
+        },
+        {
+          value: "location-to-unit",
+          display: "Location to Unit",
+          description: "Assignment of location to a unit",
+          status: "Active"
+        }
+      ]
+    },
+    {
+      system: "crn:identifier",
+      domain: "identifier",
+      variant: null,
+      display: "Identifier Types",
+      description: "Person identifier types",
+      type: "parameter",
+      values: [
+        {
+          value: "nik",
+          display: "NIK",
+          description: "Nomor Induk Kependudukan",
+          status: "Active"
+        },
+        {
+          value: "mrn",
+          display: "MRN",
+          description: "Medical Record Number",
+          status: "Active"
+        },
+        {
+          value: "passport",
+          display: "Passport Number",
+          description: "Passport Number",
+          status: "Active"
+        },
+        {
+          value: "str",
+          display: "STR",
+          description: "Surat Tanda Registrasi by Konsil Kedokteran Indonesia",
+          status: "Active"
+        },
+        {
+          value: "sip",
+          display: "SIP",
+          description: "Surat Izin Praktik by Dinas Kesehatan",
+          status: "Active"
+        },
+        {
+          value: "npa",
+          display: "NPA",
+          description: "Nomor Pokok Anggota by Ikatan Dokter Indonesia",
+          status: "Active"
+        }
+      ]
+    },
+    {
+      system: "crn:contact",
+      domain: "contact",
+      variant: null,
+      display: "Contact Method",
+      description: "Method of contacting a person",
+      type: "label",
+      values: [
+        {
+          value: "mobile",
+          display: "Mobile",
+          description: "Cellular or mobile phone contact number",
+          status: "Active"
+        },
+        {
+          value: "phone",
+          display: "Phone",
+          description: "Landline or primary telephone contact number",
+          status: "Active"
+        },
+        {
+          value: "email",
+          display: "Email",
+          description: "Electronic mail address for digital communication",
+          status: "Active"
+        },
+        {
+          value: "fax",
+          display: "Fax",
+          description: "Facsimile machine contact number",
+          status: "Active"
+        }
+      ]
+    },
+    {
+      system: "crn:event:system",
+      domain: "event",
+      variant: "system",
+      display: "System Event",
+      description: "System event types",
+      type: "parameter",
+      values: [
+        {
+          value: "create",
+          display: "Create",
+          description: "Event triggered when creating a resource",
+          status: "Active"
+        },
+        {
+          value: "update",
+          display: "Update",
+          description: "Event triggered when updating a resource",
+          status: "Active"
+        },
+        {
+          value: "delete",
+          display: "Delete",
+          description: "Event triggered when deleting a resource",
+          status: "Active"
+        }
+      ]
+    },
+    {
+      system: "crn:event:queue",
+      domain: "event",
+      variant: "queue",
+      display: "Queue Event",
+      description: "Queue event types",
+      type: "parameter",
+      values: [
+        {
+          value: "called",
+          display: "Called",
+          description: "Event triggered when calling a queue number",
+          status: "Active"
+        },
+        {
+          value: "skipped",
+          display: "Skipped",
+          description: "Event triggered when skipping a queue number",
+          status: "Active"
+        },
+        {
+          value: "noshow",
+          display: "No Show",
+          description: "Event triggered when patient fails to show up",
+          status: "Active"
+        },
+        {
+          value: "arrived",
+          display: "Arrived",
+          description: "Event triggered when patient arrives at the location",
+          status: "Active"
+        }
+      ]
+    }
+  ]
+};
+
+// src/registry/registry.ts
+var registry = registry_default;
+function validateCode(system, value) {
+  const sys = registry.systems.find((s) => s.system === system);
+  if (!sys) return false;
+  if (sys.type === "parameter") {
+    return sys.values.some((v) => v.value === value);
+  }
+  return value.length > 0;
+}
+
+// src/commons/coded-concept.ts
+var isoDatetimeRegex2 = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[+-]\d{2}:?\d{2})$/;
+var codedConceptSchema = z.object({
+  system: z.string().min(1, { message: "system is required" }),
+  value: z.string().min(1, { message: "value is required" }),
+  display: z.string().optional(),
+  valid: z.string().optional().refine(
+    (val) => !val || isoDatetimeRegex2.test(val),
+    { message: "valid must be a valid ISO 8601 datetime if provided" }
+  ),
+  tags: z.array(z.string()).optional()
+}).refine((data) => validateCode(data.system, data.value), {
+  message: "Invalid CodedConcept: system/value combination not found in registry"
+});
+var demographicSchema = z5.object({
+  sex: codedConceptSchema,
+  religion: codedConceptSchema,
+  ethnicity: z5.string().optional(),
+  marital_status: codedConceptSchema,
+  date_of_birth: z5.string(),
+  place_of_birth: z5.string().optional()
+});
+var addressSchema = z.object({
+  street: z.string().min(1, { message: "street is required" }),
+  subdistrict: codedConceptSchema,
+  district: codedConceptSchema,
+  city: codedConceptSchema,
+  province: codedConceptSchema,
+  postal_code: z.string().optional()
+});
+var objectIdSchema = z.string().length(24, {
+  message: "ObjectId must be a 24-character hexadecimal string"
+}).regex(/^[0-9a-fA-F]{24}$/, {
+  message: "ObjectId must be a valid MongoDB ObjectId (24-character hex string)"
+});
+var USER_SCHEMA_VERSION = 1;
+var userSchema = z.object({
+  id: z.string(),
+  full_name: z.string().min(1, { message: "full_name is required" }),
+  first_name: z.string().min(1, { message: "first_name is required" }),
+  middle_name: z.string().optional(),
+  last_name: z.string().min(1, { message: "last_name is required" }),
+  salutation: z.string().optional(),
+  title: z.string().optional(),
+  email: z.string().email({ message: "Invalid email address" }),
+  email_verified: z.boolean(),
+  image: z.string().optional(),
+  statuses: z.array(codedConceptSchema).nonempty({
+    message: "statuses must contain at least one CodedConcept"
+  }),
+  identifiers: z.array(codedConceptSchema).nonempty({
+    message: "identifiers must contain at least one CodedConcept"
+  }),
+  demographic: demographicSchema,
+  contacts: z.array(codedConceptSchema).optional(),
+  settings_id: objectIdSchema,
+  created_at: z.string(),
+  updated_at: z.string()
+});
+var UserMongooseSchema = toMongooseSchema(userSchema);
+var UserModelName = "users";
+var UserModel = model(UserModelName, UserMongooseSchema);
+var USER_SETTING_FIELDS = [
+  "lock_screen",
+  "lock_screen_pin",
+  "language"
+];
+var USER_SETTINGS_SCHEMA_VERSION = 1;
+var userSettingsSchema = z.object({
+  _id: objectIdSchema,
+  scope: z.string().min(1),
+  options: z.array(
+    settingOptionSchema.refine(
+      (opt) => USER_SETTING_FIELDS.includes(opt.field),
+      { message: "Invalid field for user settings" }
+    )
+  ),
+  updated_at: timestampSchema,
+  updated_by: z.string(),
+  schema_version: z.number().int().positive().default(USER_SETTINGS_SCHEMA_VERSION)
+});
+var userSettingsKVSchema = z.object({
+  lock_screen: z.boolean().default(false),
+  lock_screen_pin: z.string().optional(),
+  language: z.string().default("id-ID")
+});
+
+// src/models/user/user-minimal.schema.ts
+var userMinimalSchema = userSchema.omit({
+  id: true,
+  created_at: true,
+  updated_at: true
+});
+
+// src/models/user/user-partial.schema.ts
+var userPartialSchema = userMinimalSchema.partial();
+var nonEmpty = z.string().min(1, { message: "assigned_to is required" });
+var ASSIGNMENT_SCHEMA_VERSION = 1;
+var assignmentSchema = z.object({
+  _id: objectIdSchema,
+  facility_id: objectIdSchema,
+  type: codedConceptSchema,
+  for: z.string().min(1, { message: "for is required" }),
+  assigned_to: z.union([nonEmpty, z.array(nonEmpty)]).transform((val) => Array.isArray(val) ? val : [val]).refine((arr) => arr.length >= 1, {
+    message: "assigned_to is required"
+  }),
+  created_at: z.string(),
+  created_by: z.string(),
+  updated_at: z.string(),
+  updated_by: z.string(),
+  schema_version: z.number().int().positive().default(ASSIGNMENT_SCHEMA_VERSION)
+});
+var AssignmentMongooseSchema = toMongooseSchema(assignmentSchema);
+var AssignmentModelName = "assignments";
+var AssignmentModel = model(AssignmentModelName, AssignmentMongooseSchema);
+
+// src/models/assignment/assignment-minimal.schema.ts
+var assignmentMinimalSchema = assignmentSchema.omit({
+  _id: true,
+  created_at: true,
+  created_by: true,
+  updated_at: true,
+  updated_by: true,
+  schema_version: true
+});
+
+// src/models/assignment/assignment-partial.schema.ts
+var assignmentPartialSchema = assignmentMinimalSchema.partial();
+var DEPARTMENT_SCHEMA_VERSION = 1;
+var departmentSchema = z.object({
+  _id: objectIdSchema,
+  facility_id: objectIdSchema,
+  name: z.string().min(1, { message: "name is required" }),
+  type: codedConceptSchema,
+  created_at: z.string(),
+  created_by: z.string(),
+  updated_at: z.string(),
+  updated_by: z.string(),
+  schema_version: z.number().int().positive().default(DEPARTMENT_SCHEMA_VERSION)
+});
+var DepartmentMongooseSchema = toMongooseSchema(departmentSchema);
+var DepartmentModelName = "departments";
+var DepartmentModel = model(DepartmentModelName, DepartmentMongooseSchema);
+
+// src/models/department/department-minimal.schema.ts
+var departmentMinimalSchema = departmentSchema.omit({
+  _id: true,
+  created_at: true,
+  created_by: true,
+  updated_at: true,
+  updated_by: true,
+  schema_version: true
+});
+
+// src/models/department/department-partial.schema.ts
+var departmentPartialSchema = departmentMinimalSchema.partial();
+var FACILITY_SCHEMA_VERSION = 1;
+var facilitySchema = z.object({
+  id: z.string().uuid({ message: "id must be a valid UUID" }),
+  name: z.string().min(1, { message: "name is required" }),
+  member_count: z.number().int().positive({ message: "member_count must be a positive integer" }),
+  organization_id: objectIdSchema,
+  status: codedConceptSchema,
+  settings_id: objectIdSchema,
+  createdAt: timestampSchema,
+  updatedAt: timestampSchema
+});
+var FacilityMongooseSchema = toMongooseSchema(facilitySchema);
+var FacilityModelName = "facilities";
+var FacilityModel = model(FacilityModelName, FacilityMongooseSchema);
+var FACILITY_SETTING_FIELDS = [
+  "branding_logo",
+  "satusehat_org_id",
+  "satusehat_client_id",
+  "satusehat_client_secret",
+  "queue_number_separator",
+  "queue_number_prefix",
+  "queue_no_response_count",
+  "queue_skip_no_response"
+];
+var FACILITY_SETTINGS_SCHEMA_VERSION = 1;
+var facilitySettingsSchema = z.object({
+  _id: objectIdSchema,
+  scope: z.string().min(1),
+  options: z.array(
+    settingOptionSchema.refine(
+      (opt) => FACILITY_SETTING_FIELDS.includes(opt.field),
+      { message: "Invalid field for facility settings" }
+    )
+  ),
+  updated_at: timestampSchema,
+  updated_by: z.string(),
+  schema_version: z.number().int().positive().default(FACILITY_SETTINGS_SCHEMA_VERSION)
+});
+var facilitySettingsKVSchema = z.object({
+  branding_logo: z.string().optional(),
+  satusehat_org_id: z.string().optional(),
+  satusehat_client_id: z.string().optional(),
+  satusehat_client_secret: z.string().optional(),
+  queue_number_separator: z.string().optional(),
+  queue_number_prefix: z.enum(["none", "payer"]).default("payer"),
+  queue_no_response_count: z.number().default(3),
+  queue_skip_no_response: z.boolean().default(true)
+});
+
+// src/models/facility/facility-minimal.schema.ts
+var facilityMinimalSchema = facilitySchema.omit({
+  id: true,
+  createdAt: true,
+  updatedAt: true
+});
+
+// src/models/facility/facility-partial.schema.ts
+var facilityPartialSchema = facilityMinimalSchema.partial();
+var LOCATION_SCHEMA_VERSION = 1;
+var locationSchema = z.object({
+  _id: objectIdSchema,
+  parent_id: objectIdSchema,
+  identifiers: z.array(codedConceptSchema).nonempty({
+    message: "identifiers must contain at least one CodedConcept"
+  }),
+  name: z.string().min(1, { message: "name is required" }),
+  types: z.array(codedConceptSchema).nonempty({
+    message: "types must contain at least one CodedConcept"
+  }),
+  statuses: z.array(codedConceptSchema).nonempty({
+    message: "statuses must contain at least one CodedConcept"
+  }),
+  settings_id: objectIdSchema,
+  created_at: timestampSchema,
+  created_by: z.string(),
+  updated_at: timestampSchema,
+  updated_by: z.string(),
+  schema_version: z.number().int().positive().default(LOCATION_SCHEMA_VERSION)
+});
+var LocationMongooseSchema = toMongooseSchema(locationSchema);
+var LocationModelName = "locations";
+var LocationModel = model(LocationModelName, LocationMongooseSchema);
+var LOCATION_SETTING_FIELDS = [
+  "sex_restriction",
+  "is_inventory_location",
+  "room_has_ventilator"
+];
+var LOCATION_SETTINGS_SCHEMA_VERSION = 1;
+var locationSettingsSchema = z.object({
+  _id: objectIdSchema,
+  scope: z.string().min(1),
+  options: z.array(
+    settingOptionSchema.refine(
+      (opt) => LOCATION_SETTING_FIELDS.includes(opt.field),
+      { message: "Invalid field for location settings" }
+    )
+  ),
+  updated_at: timestampSchema,
+  updated_by: z.string(),
+  schema_version: z.number().int().positive().default(LOCATION_SETTINGS_SCHEMA_VERSION)
+});
+var locationSettingsKVSchema = z.object({
+  sex_restriction: z.string().optional(),
+  is_inventory_location: z.boolean().default(false),
+  room_has_ventilator: z.boolean().default(false)
+});
+
+// src/models/location/location-minimal.schema.ts
+var locationMinimalSchema = locationSchema.omit({
+  _id: true,
+  created_at: true,
+  created_by: true,
+  updated_at: true,
+  updated_by: true
+});
+
+// src/models/location/location-partial.schema.ts
+var locationPartialSchema = locationMinimalSchema.partial();
+var MEMBER_SCHEMA_VERSION = 1;
+var memberSchema = z.object({
+  id: z.string().uuid({ message: "id must be a valid UUID" }),
+  user_id: objectIdSchema,
+  organization_id: objectIdSchema,
+  role: z.string().min(1, { message: "role is required" }),
+  created_at: timestampSchema
+});
+var MemberMongooseSchema = toMongooseSchema(memberSchema);
+var MemberModelName = "members";
+var MemberModel = model(MemberModelName, MemberMongooseSchema);
+
+// src/models/member/member-minimal.schema.ts
+var memberMinimalSchema = memberSchema.omit({
+  id: true,
+  created_at: true
+});
+
+// src/models/member/member-partial.schema.ts
+var memberPartialSchema = memberMinimalSchema.partial();
+var ORGANIZATION_SCHEMA_VERSION = 1;
+var organizationSchema = z.object({
+  id: z.string().uuid({ message: "id must be a valid UUID" }),
+  name: z.string().min(1, { message: "name is required" }),
+  slug: z.string().min(1, { message: "slug is required" }),
+  logo: z.string().optional(),
+  status: codedConceptSchema,
+  metadata: z.object({
+    description: z.string().optional()
+  }).optional(),
+  settings_id: objectIdSchema,
+  created_at: timestampSchema
+});
+var OrganizationMongooseSchema = toMongooseSchema(organizationSchema);
+var OrganizationModelName = "organizations";
+var OrganizationModel = model(OrganizationModelName, OrganizationMongooseSchema);
+var ORGANIZATION_SETTING_FIELDS = [
+  "patient_mrn_length",
+  "patient_mrn_separator",
+  "member_invite_duration"
+];
+var ORGANIZATION_SETTINGS_SCHEMA_VERSION = 1;
+var organizationSettingsSchema = z.object({
+  _id: objectIdSchema,
+  scope: z.string().min(1),
+  options: z.array(
+    settingOptionSchema.refine(
+      (opt) => ORGANIZATION_SETTING_FIELDS.includes(opt.field),
+      { message: "Invalid field for organization settings" }
+    )
+  ),
+  updated_at: timestampSchema,
+  updated_by: z.string(),
+  schema_version: z.number().int().positive().default(ORGANIZATION_SETTINGS_SCHEMA_VERSION)
+});
+var organizationSettingsKVSchema = z.object({
+  patient_mrn_length: z.number().default(6),
+  patient_mrn_separator: z.string().default("crn:mrn:separator:dash"),
+  member_invite_duration: z.number().default(7)
+});
+
+// src/models/organization/organization-minimal.schema.ts
+var organizationMinimalSchema = organizationSchema.omit({
+  id: true,
+  created_at: true
+});
+
+// src/models/organization/organization-partial.schema.ts
+var organizationPartialSchema = organizationMinimalSchema.partial();
+var PATIENT_SCHEMA_VERSION = 1;
+var patientSchema = z.object({
+  _id: objectIdSchema,
+  organization_id: objectIdSchema,
+  registering_facility_id: objectIdSchema,
+  identifiers: z.array(codedConceptSchema),
+  salutation: z.string().min(1, { message: "salutation is required" }),
+  first_name: z.string().min(1, { message: "first_name is required" }),
+  middle_name: z.string().optional(),
+  last_name: z.string().min(1, { message: "last_name is required" }),
+  title: z.string().optional(),
+  image: z.string().optional(),
+  demographic: demographicSchema,
+  statuses: z.array(codedConceptSchema).nonempty({
+    message: "statuses must contain at least one CodedConcept"
+  }),
+  contacts: z.array(codedConceptSchema).optional(),
+  address: addressSchema,
+  created_at: timestampSchema,
+  created_by: z.string(),
+  updated_at: timestampSchema,
+  updated_by: z.string(),
+  schema_version: z.number().int().positive().default(PATIENT_SCHEMA_VERSION)
+});
+var PatientMongooseSchema = toMongooseSchema(patientSchema);
+var PatientModelName = "patients";
+var PatientModel = model(PatientModelName, PatientMongooseSchema);
+
+// src/models/patient/patient-minimal.schema.ts
+var patientMinimalSchema = patientSchema.omit({
+  _id: true,
+  created_at: true,
+  created_by: true,
+  updated_at: true,
+  updated_by: true,
+  schema_version: true
+});
+
+// src/models/patient/patient-partial.schema.ts
+var patientPartialSchema = patientMinimalSchema.partial();
+var PATIENT_ADDITIONAL_SCHEMA_VERSION = 1;
+var patientAdditionalSchema = z.object({
+  id: z.string().uuid({ message: "id must be a valid UUID" }),
+  patient_id: objectIdSchema,
+  type: codedConceptSchema,
+  data: z.union([z.object({}), z.array(z.any())]),
+  created_at: timestampSchema,
+  created_by: z.string(),
+  updated_at: timestampSchema,
+  updated_by: z.string(),
+  schema_version: z.number().int().positive().default(PATIENT_ADDITIONAL_SCHEMA_VERSION)
+});
+var PatientAdditionalMongooseSchema = toMongooseSchema(patientAdditionalSchema);
+var PatientAdditionalModelName = "patient_additionals";
+var PatientAdditionalModel = model(PatientAdditionalModelName, PatientAdditionalMongooseSchema);
+
+// src/models/patient-additional/patient-additional-minimal.schema.ts
+var patientAdditionalMinimalSchema = patientAdditionalSchema.omit({
+  id: true,
+  created_at: true,
+  created_by: true,
+  updated_at: true,
+  updated_by: true,
+  schema_version: true
+});
+
+// src/models/patient-additional/patient-additional-partial.schema.ts
+var patientAdditionalPartialSchema = patientAdditionalMinimalSchema.partial();
+var STAFF_SCHEMA_VERSION = 1;
+var staffSchema = z.object({
+  id: z.string().uuid({ message: "id must be a valid UUID" }),
+  team_id: objectIdSchema,
+  user_id: objectIdSchema,
+  type: codedConceptSchema,
+  status: codedConceptSchema,
+  membership_key: z.string().optional(),
+  group: z.string().optional(),
+  subspecialist: z.string().optional(),
+  created_at: timestampSchema,
+  created_by: z.string(),
+  updated_at: timestampSchema,
+  updated_by: z.string(),
+  schema_version: z.number().int().positive().default(STAFF_SCHEMA_VERSION)
+});
+var StaffMongooseSchema = toMongooseSchema(staffSchema);
+var StaffModelName = "staffs";
+var StaffModel = model(StaffModelName, StaffMongooseSchema);
+
+// src/models/staff/staff-minimal.schema.ts
+var staffMinimalSchema = staffSchema.omit({
+  id: true,
+  created_at: true,
+  created_by: true,
+  updated_at: true,
+  updated_by: true,
+  schema_version: true
+});
+
+// src/models/staff/staff-partial.schema.ts
+var staffPartialSchema = staffMinimalSchema.partial();
+var UNIT_SCHEMA_VERSION = 1;
+var unitSchema = z.object({
+  _id: objectIdSchema,
+  facility_id: objectIdSchema,
+  department_id: objectIdSchema,
+  name: z.string().min(1, { message: "name is required" }),
+  code: z.string().min(1, { message: "code is required" }),
+  type: codedConceptSchema,
+  statuses: z.array(codedConceptSchema).nonempty({
+    message: "statuses must contain at least one CodedConcept"
+  }),
+  settings_id: objectIdSchema,
+  created_at: timestampSchema,
+  created_by: z.string(),
+  updated_at: timestampSchema,
+  updated_by: z.string(),
+  schema_version: z.number().int().positive().default(UNIT_SCHEMA_VERSION)
+});
+var UnitMongooseSchema = toMongooseSchema(unitSchema);
+var UnitModelName = "units";
+var UnitModel = model(UnitModelName, UnitMongooseSchema);
+
+// src/models/unit/unit-minimal.schema.ts
+var unitMinimalSchema = unitSchema.omit({
+  _id: true,
+  created_at: true,
+  created_by: true,
+  updated_at: true,
+  updated_by: true,
+  schema_version: true
+});
+
+// src/models/unit/unit-partial.schema.ts
+var unitPartialSchema = unitMinimalSchema.partial();
+var PRACTITIONER_SCHEDULE_SCHEMA_VERSION = 1;
+var practitionerScheduleSchema = z.object({
+  organization_id: objectIdSchema,
+  facility_id: objectIdSchema,
+  staff_id: objectIdSchema,
+  unit_id: objectIdSchema,
+  type: codedConceptSchema,
+  day: z.union([z.number(), z.string()]).refine((val) => val != null, { message: "day is required" }),
+  _id: objectIdSchema,
+  created_at: timestampSchema.optional(),
+  created_by: z.string().optional(),
+  updated_at: timestampSchema.optional(),
+  updated_by: z.string().optional(),
+  schema_version: z.number().int().positive().default(PRACTITIONER_SCHEDULE_SCHEMA_VERSION)
+});
+var PractitionerScheduleMongooseSchema = toMongooseSchema(practitionerScheduleSchema);
+var PractitionerScheduleModelName = "practitioner_schedules";
+var PractitionerScheduleModel = model(PractitionerScheduleModelName, PractitionerScheduleMongooseSchema);
+
+// src/models/practitioner-schedule/practitioner-schedule-minimal.schema.ts
+var practitionerScheduleMinimalSchema = practitionerScheduleSchema.omit({
+  _id: true,
+  created_at: true,
+  created_by: true,
+  updated_at: true,
+  updated_by: true,
+  schema_version: true
+});
+
+// src/models/practitioner-schedule/practitioner-schedule-partial.schema.ts
+var practitionerSchedulePartialSchema = practitionerScheduleMinimalSchema.partial();
+var PRACTITIONER_SESSION_SCHEMA_VERSION = 1;
+var practitionerSessionSchema = z.object({
+  schedule_id: objectIdSchema,
+  staff_id: objectIdSchema,
+  unit_id: objectIdSchema,
+  start: z.string().min(1, { message: "start is required" }),
+  end: z.string().min(1, { message: "end is required" }),
+  max_quota: z.number().int().positive({ message: "max_quota must be a positive integer" }),
+  _id: objectIdSchema,
+  created_at: timestampSchema.optional(),
+  created_by: z.string().optional(),
+  updated_at: timestampSchema.optional(),
+  updated_by: z.string().optional(),
+  schema_version: z.number().int().positive().default(PRACTITIONER_SESSION_SCHEMA_VERSION)
+});
+var PractitionerSessionMongooseSchema = toMongooseSchema(practitionerSessionSchema);
+var PractitionerSessionModelName = "practitioner_sessions";
+var PractitionerSessionModel = model(PractitionerSessionModelName, PractitionerSessionMongooseSchema);
+
+// src/models/practitioner-session/practitioner-session-minimal.schema.ts
+var practitionerSessionMinimalSchema = practitionerSessionSchema.omit({
+  _id: true,
+  created_at: true,
+  created_by: true,
+  updated_at: true,
+  updated_by: true,
+  schema_version: true
+});
+
+// src/models/practitioner-session/practitioner-session-partial.schema.ts
+var practitionerSessionPartialSchema = practitionerSessionMinimalSchema.partial();
+var KSM_SCHEMA_VERSION = 1;
+var ksmSchema = z.object({
+  id: z.string().uuid({ message: "id must be a valid UUID" }),
+  organization_id: objectIdSchema,
+  facility_id: objectIdSchema,
+  name: z.string().min(1, { message: "name is required" }),
+  subspecialist: z.array(z.string()).min(1, { message: "subspecialist is required" }),
+  created_at: timestampSchema,
+  created_by: z.string().min(1, { message: "created_by is required" }),
+  updated_at: timestampSchema.nullable(),
+  updated_by: z.string().nullable(),
+  schema_version: z.number().int().positive().default(KSM_SCHEMA_VERSION)
+});
+var KsmMongooseSchema = toMongooseSchema(ksmSchema);
+var KsmModelName = "medical_staff_groups";
+var KsmModel = model(KsmModelName, KsmMongooseSchema);
+
+// src/models/ksm/ksm-minimal.schema.ts
+var ksmMinimalSchema = ksmSchema.omit({
+  id: true,
+  created_at: true,
+  created_by: true,
+  updated_at: true,
+  updated_by: true,
+  schema_version: true
+});
+
+// src/models/ksm/ksm-partial.schema.ts
+var ksmPartialSchema = ksmMinimalSchema.partial();
+var isoDatetimeRegex3 = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[+-]\d{2}:?\d{2})$/;
+var PAYER_SCHEMA_VERSION = 1;
+var payerSchema = z.object({
+  id: z.string().uuid({ message: "id must be a valid UUID" }),
+  organization_id: objectIdSchema,
+  facility_id: objectIdSchema,
+  code: z.string().min(1, { message: "code is required" }),
+  name: z.string().min(1, { message: "name is required" }),
+  category: codedConceptSchema,
+  type: z.string().min(1, { message: "type is required" }),
+  contacts: z.array(codedConceptSchema),
+  statuses: z.array(codedConceptSchema),
+  banks: z.array(
+    z.object({
+      name: z.string().min(1, { message: "bank name is required" }),
+      account: z.string().min(1, { message: "bank account is required" }),
+      number: z.string().min(1, { message: "bank number is required" })
+    })
+  ),
+  variations: z.array(
+    z.object({
+      code: z.string().min(1, { message: "variation code is required" }),
+      name: z.string().min(1, { message: "variation name is required" }),
+      description: z.string().optional(),
+      start: z.string().refine((val) => isoDatetimeRegex3.test(val), { message: "variation start must be a valid ISO 8601 datetime" }),
+      end: z.string().optional().refine((val) => !val || isoDatetimeRegex3.test(val), { message: "variation end must be a valid ISO 8601 datetime" }),
+      contacts: z.array(codedConceptSchema).optional(),
+      documents: z.array(z.string()).optional(),
+      statuses: z.array(codedConceptSchema),
+      banks: z.array(
+        z.object({
+          name: z.string().min(1, { message: "bank name is required" }),
+          account: z.string().min(1, { message: "bank account is required" }),
+          number: z.string().min(1, { message: "bank number is required" })
+        })
+      ),
+      settings_id: objectIdSchema
+    })
+  ),
+  created_at: timestampSchema,
+  created_by: z.string().min(1, { message: "created_by is required" }),
+  updated_at: timestampSchema,
+  updated_by: z.string().min(1, { message: "updated_by is required" }),
+  schema_version: z.number().int().positive().default(PAYER_SCHEMA_VERSION)
+});
+var PayerMongooseSchema = toMongooseSchema(payerSchema);
+var PayerModelName = "payers";
+var PayerModel = model(PayerModelName, PayerMongooseSchema);
+var PAYER_SETTING_FIELDS = [
+  "use_header_contact_info",
+  "use_header_bank_info",
+  "use_header_status_info",
+  "rules_drug_formulary",
+  "rules_method",
+  "rules_global_cover_outpatient",
+  "rules_global_cover_emergency",
+  "rules_global_tariff_calculation_date",
+  "rules_global_margin_id",
+  "rules_global_rule_type",
+  "rules_admin_calculate",
+  "rules_admin_min_fee",
+  "rules_admin_max_fee",
+  "rules_admin_before_discount",
+  "rules_admin_covered",
+  "rules_item_restriction_id"
+];
+var PAYER_SETTINGS_SCHEMA_VERSION = 1;
+var payerSettingsSchema = z.object({
+  _id: objectIdSchema,
+  scope: z.string().min(1),
+  options: z.array(
+    settingOptionSchema.refine(
+      (opt) => PAYER_SETTING_FIELDS.includes(opt.field),
+      { message: "Invalid field for payer settings" }
+    )
+  ),
+  updated_at: timestampSchema,
+  updated_by: z.string(),
+  schema_version: z.number().int().positive().default(PAYER_SETTINGS_SCHEMA_VERSION)
+});
+var payerSettingsKVSchema = z.object({
+  use_header_contact_info: z.boolean().default(false),
+  use_header_bank_info: z.boolean().default(false),
+  use_header_status_info: z.boolean().default(true),
+  rules_drug_formulary: z.string().optional(),
+  rules_method: z.string().optional(),
+  rules_global_cover_outpatient: z.boolean().default(true),
+  rules_global_cover_emergency: z.boolean().default(true),
+  rules_global_tariff_calculation_date: z.enum(["transaction-date", "billing-date"]).default("transaction-date"),
+  rules_global_margin_id: z.string().optional(),
+  rules_global_rule_type: z.enum(["margin", "plafond"]).default("margin"),
+  rules_admin_calculate: z.boolean().default(false),
+  rules_admin_min_fee: z.number().default(0),
+  rules_admin_max_fee: z.number().default(0),
+  rules_admin_before_discount: z.boolean().default(false),
+  rules_admin_covered: z.boolean().default(true),
+  rules_item_restriction_id: z.string().optional()
+});
+
+// src/models/payer/payer-minimal.schema.ts
+var payerMinimalSchema = payerSchema.omit({
+  id: true,
+  created_at: true,
+  created_by: true,
+  updated_at: true,
+  updated_by: true,
+  schema_version: true
+});
+
+// src/models/payer/payer-partial.schema.ts
+var payerPartialSchema = payerMinimalSchema.partial();
+var QUEUE_SCHEMA_VERSION = 1;
+var queueSchema = z.object({
+  id: z.string().uuid({ message: "id must be a valid UUID" }),
+  organization_id: objectIdSchema,
+  facility_id: objectIdSchema,
+  unit_id: objectIdSchema,
+  payer_type: z.string().min(1, { message: "payer_type is required" }),
+  line: z.array(
+    z.object({
+      queue_number_id: objectIdSchema,
+      queue_number: z.string().min(1, { message: "queue_number is required" }),
+      stage: codedConceptSchema,
+      status: codedConceptSchema,
+      call_count: z.number().int().positive({ message: "call_count must be a positive integer" })
+    })
+  ),
+  created_at: timestampSchema,
+  created_by: z.string().min(1, { message: "created_by is required" }),
+  updated_at: timestampSchema,
+  updated_by: z.string().min(1, { message: "updated_by is required" }),
+  schema_version: z.number().int().positive().default(QUEUE_SCHEMA_VERSION)
+});
+var QueueMongooseSchema = toMongooseSchema(queueSchema);
+var QueueModelName = "queues";
+var QueueModel = model(QueueModelName, QueueMongooseSchema);
+var QUEUE_SETTING_FIELDS = [
+  "number_length",
+  "call_priority",
+  "call_threshold"
+];
+var QUEUE_SETTINGS_SCHEMA_VERSION = 1;
+var queueSettingsSchema = z.object({
+  _id: objectIdSchema,
+  scope: z.string().min(1),
+  options: z.array(
+    settingOptionSchema.refine(
+      (opt) => QUEUE_SETTING_FIELDS.includes(opt.field),
+      { message: "Invalid field for queue settings" }
+    )
+  ),
+  updated_at: timestampSchema,
+  updated_by: z.string(),
+  schema_version: z.number().int().positive().default(QUEUE_SETTINGS_SCHEMA_VERSION)
+});
+var queueSettingsKVSchema = z.object({
+  number_length: z.number().int().positive().nullable().default(null),
+  call_priority: z.string().default("sequence"),
+  call_threshold: z.number().int().positive().default(3)
+}).refine((data) => validateCode("crn:queue:priority", data.call_priority), {
+  message: "Invalid CodedConcept: system/value combination not found in registry"
+});
+
+// src/models/queue/queue-minimal.schema.ts
+var queueMinimalSchema = queueSchema.omit({
+  id: true,
+  created_at: true,
+  created_by: true,
+  updated_at: true,
+  updated_by: true,
+  schema_version: true
+});
+
+// src/models/queue/queue-partial.schema.ts
+var queuePartialSchema = queueMinimalSchema.partial();
+var QUEUE_EVENT_LOG_SCHEMA_VERSION = 1;
+var queueEventLogSchema = z.object({
+  id: z.string().uuid({ message: "id must be a valid UUID" }),
+  queue_number_id: objectIdSchema,
+  queue_number: z.string().min(1, { message: "queue_number is required" }),
+  events: z.array(codedConceptSchema),
+  count: z.number().int().positive({ message: "count must be a positive integer" }),
+  created_at: timestampSchema,
+  created_by: z.string().min(1, { message: "created_by is required" }),
+  updated_at: timestampSchema,
+  updated_by: z.string().min(1, { message: "updated_by is required" }),
+  schema_version: z.number().int().positive().default(QUEUE_EVENT_LOG_SCHEMA_VERSION)
+});
+var QueueEventLogMongooseSchema = toMongooseSchema(queueEventLogSchema);
+var QueueEventLogModelName = "queue_event_logs";
+var QueueEventLogModel = model(QueueEventLogModelName, QueueEventLogMongooseSchema);
+
+// src/models/queue-event-log/queue-event-log-minimal.schema.ts
+var queueEventLogMinimalSchema = queueEventLogSchema.omit({
+  id: true,
+  created_at: true,
+  created_by: true,
+  updated_at: true,
+  updated_by: true,
+  schema_version: true
+});
+
+// src/models/queue-event-log/queue-event-log-partial.schema.ts
+var queueEventLogPartialSchema = queueEventLogMinimalSchema.partial();
+var isoDatetimeRegex4 = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[+-]\d{2}:?\d{2})$/;
+var QUEUE_NUMBER_SCHEMA_VERSION = 1;
+var queueNumberSchema = z.object({
+  id: z.string().uuid({ message: "id must be a valid UUID" }),
+  organization_id: objectIdSchema,
+  facility_id: objectIdSchema,
+  patient_id: objectIdSchema,
+  metadata: z.object({
+    payer_type: z.string().min(1, { message: "payer_type is required" }),
+    unit_id: objectIdSchema,
+    practitioner_id: objectIdSchema,
+    date: z.string().refine((val) => isoDatetimeRegex4.test(val), {
+      message: "date must be a valid ISO 8601 datetime"
+    }),
+    session: z.string().min(1, { message: "session is required" })
+  }),
+  sequence: z.number().int().positive({ message: "sequence must be a positive integer" }),
+  prefix: z.string().min(1, { message: "prefix is required" }),
+  number: z.string().min(1, { message: "number is required" }),
+  created_at: timestampSchema,
+  created_by: z.string().min(1, { message: "created_by is required" }),
+  updated_at: timestampSchema,
+  updated_by: z.string().min(1, { message: "updated_by is required" }),
+  expired_at: z.string().refine((val) => isoDatetimeRegex4.test(val), {
+    message: "expired_at must be a valid ISO 8601 datetime"
+  }),
+  schema_version: z.number().int().positive().default(QUEUE_NUMBER_SCHEMA_VERSION)
+});
+var QueueNumberMongooseSchema = toMongooseSchema(queueNumberSchema);
+var QueueNumberModelName = "queue_numbers";
+var QueueNumberModel = model(
+  QueueNumberModelName,
+  QueueNumberMongooseSchema
+);
+var QUEUE_NUMBER_SETTING_FIELDS = [
+  "use_header_contact_info",
+  "use_header_bank_info",
+  "use_header_status_info",
+  "rules_drug_formulary",
+  "rules_method",
+  "rules_global_cover_outpatient",
+  "rules_global_cover_emergency",
+  "rules_global_tariff_calculation_date",
+  "rules_global_margin_id",
+  "rules_global_rule_type",
+  "rules_admin_calculate",
+  "rules_admin_min_fee",
+  "rules_admin_max_fee",
+  "rules_admin_before_discount",
+  "rules_admin_covered",
+  "rules_item_restriction_id"
+];
+var QUEUE_NUMBER_SETTINGS_SCHEMA_VERSION = 1;
+var queueNumberSettingsSchema = z.object({
+  _id: objectIdSchema,
+  scope: z.string().min(1),
+  options: z.array(
+    settingOptionSchema.refine(
+      (opt) => QUEUE_NUMBER_SETTING_FIELDS.includes(opt.field),
+      { message: "Invalid field for queue number settings" }
+    )
+  ),
+  updated_at: timestampSchema,
+  updated_by: z.string(),
+  schema_version: z.number().int().positive().default(QUEUE_NUMBER_SETTINGS_SCHEMA_VERSION)
+});
+var queueNumberSettingsKVSchema = z.object({
+  use_header_contact_info: z.boolean().default(false),
+  use_header_bank_info: z.boolean().default(false),
+  use_header_status_info: z.boolean().default(true),
+  rules_drug_formulary: z.string().optional(),
+  rules_method: z.string().optional(),
+  rules_global_cover_outpatient: z.boolean().default(true),
+  rules_global_cover_emergency: z.boolean().default(true),
+  rules_global_tariff_calculation_date: z.enum(["transaction-date", "billing-date"]).default("transaction-date"),
+  rules_global_margin_id: z.string().optional(),
+  rules_global_rule_type: z.enum(["margin", "plafond"]).default("margin"),
+  rules_admin_calculate: z.boolean().default(false),
+  rules_admin_min_fee: z.number().default(0),
+  rules_admin_max_fee: z.number().default(0),
+  rules_admin_before_discount: z.boolean().default(false),
+  rules_admin_covered: z.boolean().default(true),
+  rules_item_restriction_id: z.string().optional()
+});
+
+// src/models/queue-number/queue-number-minimal.schema.ts
+var queueNumberMinimalSchema = queueNumberSchema.omit({
+  id: true,
+  created_at: true,
+  created_by: true,
+  updated_at: true,
+  updated_by: true,
+  expired_at: true,
+  schema_version: true
+});
+
+// src/models/queue-number/queue-number-partial.schema.ts
+var queueNumberPartialSchema = queueNumberMinimalSchema.partial();
+
+export { ASSIGNMENT_SCHEMA_VERSION, AssignmentModel, AssignmentMongooseSchema, DEPARTMENT_SCHEMA_VERSION, DepartmentModel, DepartmentMongooseSchema, FACILITY_SCHEMA_VERSION, FACILITY_SETTINGS_SCHEMA_VERSION, FacilityModel, FacilityMongooseSchema, KSM_SCHEMA_VERSION, KsmModel, KsmMongooseSchema, LOCATION_SCHEMA_VERSION, LOCATION_SETTINGS_SCHEMA_VERSION, LocationModel, LocationMongooseSchema, MEMBER_SCHEMA_VERSION, MemberModel, MemberMongooseSchema, ORGANIZATION_SCHEMA_VERSION, ORGANIZATION_SETTINGS_SCHEMA_VERSION, OrganizationModel, OrganizationMongooseSchema, PATIENT_ADDITIONAL_SCHEMA_VERSION, PATIENT_SCHEMA_VERSION, PAYER_SCHEMA_VERSION, PAYER_SETTINGS_SCHEMA_VERSION, PRACTITIONER_SCHEDULE_SCHEMA_VERSION, PRACTITIONER_SESSION_SCHEMA_VERSION, PatientAdditionalModel, PatientAdditionalMongooseSchema, PatientModel, PatientMongooseSchema, PayerModel, PayerMongooseSchema, PractitionerScheduleModel, PractitionerScheduleMongooseSchema, PractitionerSessionModel, PractitionerSessionMongooseSchema, QUEUE_EVENT_LOG_SCHEMA_VERSION, QUEUE_NUMBER_SCHEMA_VERSION, QUEUE_NUMBER_SETTINGS_SCHEMA_VERSION, QUEUE_SCHEMA_VERSION, QUEUE_SETTINGS_SCHEMA_VERSION, QueueEventLogModel, QueueEventLogMongooseSchema, QueueModel, QueueMongooseSchema, QueueNumberModel, QueueNumberMongooseSchema, STAFF_SCHEMA_VERSION, StaffModel, StaffMongooseSchema, UNIT_SCHEMA_VERSION, USER_SCHEMA_VERSION, USER_SETTINGS_SCHEMA_VERSION, UnitModel, UnitMongooseSchema, UserModel, UserMongooseSchema, addressSchema, apiResponseSchema, assignmentMinimalSchema, assignmentPartialSchema, assignmentSchema, codedConceptSchema, demographicSchema, departmentMinimalSchema, departmentPartialSchema, departmentSchema, facilityMinimalSchema, facilityPartialSchema, facilitySchema, facilitySettingsKVSchema, facilitySettingsSchema, ksmMinimalSchema, ksmPartialSchema, ksmSchema, locationMinimalSchema, locationPartialSchema, locationSchema, locationSettingsKVSchema, locationSettingsSchema, memberMinimalSchema, memberPartialSchema, memberSchema, metadataSchema, objectIdSchema, organizationMinimalSchema, organizationPartialSchema, organizationSchema, organizationSettingsKVSchema, organizationSettingsSchema, patientAdditionalMinimalSchema, patientAdditionalPartialSchema, patientAdditionalSchema, patientMinimalSchema, patientPartialSchema, patientSchema, payerMinimalSchema, payerPartialSchema, payerSchema, payerSettingsKVSchema, payerSettingsSchema, practitionerScheduleMinimalSchema, practitionerSchedulePartialSchema, practitionerScheduleSchema, practitionerSessionMinimalSchema, practitionerSessionPartialSchema, practitionerSessionSchema, queueEventLogMinimalSchema, queueEventLogPartialSchema, queueEventLogSchema, queueMinimalSchema, queueNumberMinimalSchema, queueNumberPartialSchema, queueNumberSchema, queueNumberSettingsKVSchema, queueNumberSettingsSchema, queuePartialSchema, queueSchema, queueSettingsKVSchema, queueSettingsSchema, settingOptionSchema, settingOptionTypeSchema, singleResourceResponseSchema, staffMinimalSchema, staffPartialSchema, staffSchema, timestampSchema, unitMinimalSchema, unitPartialSchema, unitSchema, userMinimalSchema, userPartialSchema, userSchema, userSettingsKVSchema, userSettingsSchema };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map