@centricare/contract 0.2.1 → 0.3.2

package/dist/index.cjs

@@ -34,17 +34,50 @@ var singleResourceResponseSchema = (dataSchema) => apiResponseSchema(dataSchema)
     message: "Single resource response metadata must have total=1, offset=0, limit=0, next=null, previous=null"
   }
 );
+var SETTING_OPTIONS_TYPE = [
+  // Single input
+  "string",
+  // Mapped to text input in client
+  "number",
+  // Mapped to number input in client
+  "boolean",
+  // Mapped to checkbox/switch in client
+  "date",
+  // Mapped date picker in client
+  "datetime",
+  // Mapped datetime picker in client
+  "daterange",
+  // Mapped date range picker in client
+  "image",
+  // Mapped to file input (single image only) in client
+  // Multiple input
+  "strings",
+  // Mapped to nested array text input in client
+  "numbers",
+  // Mapped to nested array number input in client
+  "images",
+  // Mapped to file input (multiple image) in client
+  "keyvals"
+  // Mapped to nested array text input pair in client
+];
 var settingOptionTypeSchema = z5.z.union([
-  z5.z.enum(["string", "number", "boolean", "date"]),
-  z5.z.array(z5.z.enum(["string", "number", "boolean", "date"])),
-  z5.z.string()
+  z5.z.enum(SETTING_OPTIONS_TYPE),
+  z5.z.string(),
+  z5.z.string().array()
 ]);
 var settingOptionSchema = z5.z.object({
   field: z5.z.string().min(1, { message: "field is required" }),
   label: z5.z.string().optional(),
   type: settingOptionTypeSchema,
   default: z5.z.string().nullable(),
-  value: z5.z.union([z5.z.string(), z5.z.boolean(), z5.z.number()]).nullable()
+  value: z5.z.union([
+    z5.z.string(),
+    z5.z.boolean(),
+    z5.z.number(),
+    z5.z.string().array(),
+    z5.z.number().array(),
+    z5.z.object({ key: z5.z.string(), value: z5.z.string() })
+  ]).nullable()
 });
 
 // src/registry/registry.json
@@ -966,11 +999,11 @@ var codedConceptSchema = z5.z.object({
 });
 var demographicSchema = z5__default.default.object({
   sex: codedConceptSchema,
-  religion: codedConceptSchema,
-  ethnicity: z5__default.default.string().optional(),
-  marital_status: codedConceptSchema,
-  date_of_birth: z5__default.default.string(),
-  place_of_birth: z5__default.default.string().optional()
+  religion: codedConceptSchema.nullable(),
+  ethnicity: z5__default.default.string().nullable(),
+  marital_status: codedConceptSchema.nullable(),
+  date_of_birth: z5__default.default.string().nullable(),
+  place_of_birth: z5__default.default.string().nullable()
 });
 var addressSchema = z5.z.object({
   street: z5.z.string().min(1, { message: "street is required" }),
@@ -985,6 +1018,23 @@ var objectIdSchema = z5.z.string().length(24, {
 }).regex(/^[0-9a-fA-F]{24}$/, {
   message: "ObjectId must be a valid MongoDB ObjectId (24-character hex string)"
 });
+var baseSchema = (version) => z5.z.object({
+  _id: objectIdSchema,
+  created_at: timestampSchema,
+  created_by: z5.z.string().min(1, { message: "created_by is required" }),
+  updated_at: timestampSchema,
+  updated_by: z5.z.string().min(1, { message: "updated_by is required" }),
+  schema_version: z5.z.number().int().positive().default(version)
+});
+var baseSchemaWithExpiredAt = (version) => z5.z.object({
+  _id: objectIdSchema,
+  created_at: timestampSchema,
+  created_by: z5.z.string().min(1, { message: "created_by is required" }),
+  updated_at: timestampSchema,
+  updated_by: z5.z.string().min(1, { message: "updated_by is required" }),
+  expired_at: timestampSchema,
+  schema_version: z5.z.number().int().positive().default(version)
+});
 var USER_SCHEMA_VERSION = 1;
 var userSchema = z5.z.object({
   id: z5.z.string(),
@@ -1046,25 +1096,23 @@ var userMinimalSchema = userSchema.omit({
 
 // src/models/user/user-partial.schema.ts
 var userPartialSchema = userMinimalSchema.partial();
-var nonEmpty = z5.z.string().min(1, { message: "assigned_to is required" });
 var ASSIGNMENT_SCHEMA_VERSION = 1;
-var assignmentSchema = z5.z.object({
-  _id: objectIdSchema,
+var assignmentSchema = baseSchema(ASSIGNMENT_SCHEMA_VERSION).extend({
   facility_id: objectIdSchema,
   type: codedConceptSchema,
   for: z5.z.string().min(1, { message: "for is required" }),
-  assigned_to: z5.z.union([nonEmpty, z5.z.array(nonEmpty)]).transform((val) => Array.isArray(val) ? val : [val]).refine((arr) => arr.length >= 1, {
-    message: "assigned_to is required"
-  }),
-  created_at: z5.z.string(),
-  created_by: z5.z.string(),
-  updated_at: z5.z.string(),
-  updated_by: z5.z.string(),
-  schema_version: z5.z.number().int().positive().default(ASSIGNMENT_SCHEMA_VERSION)
+  assigned_to: z5.z.array(
+    z5.z.string().min(1, {
+      message: "assigned_to is required"
+    })
+  ).min(1)
 });
 var AssignmentMongooseSchema = zodMongoose.toMongooseSchema(assignmentSchema);
 var AssignmentModelName = "assignments";
-var AssignmentModel = mongoose.model(AssignmentModelName, AssignmentMongooseSchema);
+var AssignmentModel = mongoose.model(
+  AssignmentModelName,
+  AssignmentMongooseSchema
+);
 
 // src/models/assignment/assignment-minimal.schema.ts
 var assignmentMinimalSchema = assignmentSchema.omit({
@@ -1079,16 +1127,10 @@ var assignmentMinimalSchema = assignmentSchema.omit({
 // src/models/assignment/assignment-partial.schema.ts
 var assignmentPartialSchema = assignmentMinimalSchema.partial();
 var DEPARTMENT_SCHEMA_VERSION = 1;
-var departmentSchema = z5.z.object({
-  _id: objectIdSchema,
+var departmentSchema = baseSchema(DEPARTMENT_SCHEMA_VERSION).extend({
   facility_id: objectIdSchema,
   name: z5.z.string().min(1, { message: "name is required" }),
-  type: codedConceptSchema,
-  created_at: z5.z.string(),
-  created_by: z5.z.string(),
-  updated_at: z5.z.string(),
-  updated_by: z5.z.string(),
-  schema_version: z5.z.number().int().positive().default(DEPARTMENT_SCHEMA_VERSION)
+  type: codedConceptSchema
 });
 var DepartmentMongooseSchema = zodMongoose.toMongooseSchema(departmentSchema);
 var DepartmentModelName = "departments";
@@ -1125,10 +1167,15 @@ var FACILITY_SETTING_FIELDS = [
   "satusehat_org_id",
   "satusehat_client_id",
   "satusehat_client_secret",
+  "queue_number_length",
   "queue_number_separator",
-  "queue_number_prefix",
-  "queue_no_response_count",
-  "queue_skip_no_response"
+  "queue_call_threshold",
+  "queue_call_priority",
+  "kiosk_announcements",
+  "kiosk_gallery",
+  "kiosk_faq",
+  "kiosk_services",
+  "payer_types"
 ];
 var FACILITY_SETTINGS_SCHEMA_VERSION = 1;
 var facilitySettingsSchema = z5.z.object({
@@ -1145,14 +1192,21 @@ var facilitySettingsSchema = z5.z.object({
   schema_version: z5.z.number().int().positive().default(FACILITY_SETTINGS_SCHEMA_VERSION)
 });
 var facilitySettingsKVSchema = z5.z.object({
-  branding_logo: z5.z.string().optional(),
-  satusehat_org_id: z5.z.string().optional(),
-  satusehat_client_id: z5.z.string().optional(),
-  satusehat_client_secret: z5.z.string().optional(),
-  queue_number_separator: z5.z.string().optional(),
-  queue_number_prefix: z5.z.enum(["none", "payer"]).default("payer"),
-  queue_no_response_count: z5.z.number().default(3),
-  queue_skip_no_response: z5.z.boolean().default(true)
+  branding_logo: z5.z.string().nullable(),
+  satusehat_org_id: z5.z.string().nullable(),
+  satusehat_client_id: z5.z.string().nullable(),
+  satusehat_client_secret: z5.z.string().nullable(),
+  queue_number_length: z5.z.number().int().positive().nullable().default(3),
+  queue_number_separator: z5.z.string().nullable(),
+  queue_call_priority: z5.z.string().default("sequence").refine((data) => validateCode("crn:queue:priority", data), {
+    message: "Invalid CodedConcept: system/value combination not found in registry"
+  }),
+  queue_call_threshold: z5.z.number().int().positive().default(3),
+  kiosk_announcements: z5.z.string().array(),
+  kiosk_gallery: z5.z.url().array(),
+  kiosk_faq: z5.z.object({ key: z5.z.string(), value: z5.z.string() }).array(),
+  kiosk_services: z5.z.object({ key: z5.z.string(), value: z5.z.string() }).array(),
+  payer_types: z5.z.string().array()
 });
 
 // src/models/facility/facility-minimal.schema.ts
@@ -1165,8 +1219,7 @@ var facilityMinimalSchema = facilitySchema.omit({
 // src/models/facility/facility-partial.schema.ts
 var facilityPartialSchema = facilityMinimalSchema.partial();
 var LOCATION_SCHEMA_VERSION = 1;
-var locationSchema = z5.z.object({
-  _id: objectIdSchema,
+var locationSchema = baseSchema(LOCATION_SCHEMA_VERSION).extend({
   parent_id: objectIdSchema,
   identifiers: z5.z.array(codedConceptSchema).nonempty({
     message: "identifiers must contain at least one CodedConcept"
@@ -1178,12 +1231,7 @@ var locationSchema = z5.z.object({
   statuses: z5.z.array(codedConceptSchema).nonempty({
     message: "statuses must contain at least one CodedConcept"
   }),
-  settings_id: objectIdSchema,
-  created_at: timestampSchema,
-  created_by: z5.z.string(),
-  updated_at: timestampSchema,
-  updated_by: z5.z.string(),
-  schema_version: z5.z.number().int().positive().default(LOCATION_SCHEMA_VERSION)
+  settings_id: objectIdSchema
 });
 var LocationMongooseSchema = zodMongoose.toMongooseSchema(locationSchema);
 var LocationModelName = "locations";
@@ -1219,7 +1267,8 @@ var locationMinimalSchema = locationSchema.omit({
   created_at: true,
   created_by: true,
   updated_at: true,
-  updated_by: true
+  updated_by: true,
+  schema_version: true
 });
 
 // src/models/location/location-partial.schema.ts
@@ -1294,28 +1343,26 @@ var organizationMinimalSchema = organizationSchema.omit({
 // src/models/organization/organization-partial.schema.ts
 var organizationPartialSchema = organizationMinimalSchema.partial();
 var PATIENT_SCHEMA_VERSION = 1;
-var patientSchema = z5.z.object({
-  _id: objectIdSchema,
+var patientSchema = baseSchema(PATIENT_SCHEMA_VERSION).extend({
   organization_id: objectIdSchema,
   registering_facility_id: objectIdSchema,
   identifiers: z5.z.array(codedConceptSchema),
-  salutation: z5.z.string().min(1, { message: "salutation is required" }),
+  salutation: codedConceptSchema,
   first_name: z5.z.string().min(1, { message: "first_name is required" }),
   middle_name: z5.z.string().optional(),
   last_name: z5.z.string().min(1, { message: "last_name is required" }),
   title: z5.z.string().optional(),
   image: z5.z.string().optional(),
-  demographic: demographicSchema,
+  demographic: demographicSchema.extend({
+    place_of_birth: demographicSchema.shape.place_of_birth.unwrap(),
+    date_of_birth: demographicSchema.shape.date_of_birth.unwrap(),
+    marital_status: demographicSchema.shape.marital_status.unwrap()
+  }),
   statuses: z5.z.array(codedConceptSchema).nonempty({
     message: "statuses must contain at least one CodedConcept"
   }),
   contacts: z5.z.array(codedConceptSchema).optional(),
-  address: addressSchema,
-  created_at: timestampSchema,
-  created_by: z5.z.string(),
-  updated_at: timestampSchema,
-  updated_by: z5.z.string(),
-  schema_version: z5.z.number().int().positive().default(PATIENT_SCHEMA_VERSION)
+  address: addressSchema
 });
 var PatientMongooseSchema = zodMongoose.toMongooseSchema(patientSchema);
 var PatientModelName = "patients";
@@ -1334,16 +1381,10 @@ var patientMinimalSchema = patientSchema.omit({
 // src/models/patient/patient-partial.schema.ts
 var patientPartialSchema = patientMinimalSchema.partial();
 var PATIENT_ADDITIONAL_SCHEMA_VERSION = 1;
-var patientAdditionalSchema = z5.z.object({
-  id: z5.z.string().uuid({ message: "id must be a valid UUID" }),
+var patientAdditionalSchema = baseSchema(PATIENT_ADDITIONAL_SCHEMA_VERSION).extend({
   patient_id: objectIdSchema,
   type: codedConceptSchema,
-  data: z5.z.union([z5.z.object({}), z5.z.array(z5.z.any())]),
-  created_at: timestampSchema,
-  created_by: z5.z.string(),
-  updated_at: timestampSchema,
-  updated_by: z5.z.string(),
-  schema_version: z5.z.number().int().positive().default(PATIENT_ADDITIONAL_SCHEMA_VERSION)
+  data: z5.z.union([z5.z.object({}), z5.z.array(z5.z.any())])
 });
 var PatientAdditionalMongooseSchema = zodMongoose.toMongooseSchema(patientAdditionalSchema);
 var PatientAdditionalModelName = "patient_additionals";
@@ -1351,7 +1392,7 @@ var PatientAdditionalModel = mongoose.model(PatientAdditionalModelName, PatientA
 
 // src/models/patient-additional/patient-additional-minimal.schema.ts
 var patientAdditionalMinimalSchema = patientAdditionalSchema.omit({
-  id: true,
+  _id: true,
   created_at: true,
   created_by: true,
   updated_at: true,
@@ -1362,20 +1403,14 @@ var patientAdditionalMinimalSchema = patientAdditionalSchema.omit({
 // src/models/patient-additional/patient-additional-partial.schema.ts
 var patientAdditionalPartialSchema = patientAdditionalMinimalSchema.partial();
 var STAFF_SCHEMA_VERSION = 1;
-var staffSchema = z5.z.object({
-  id: z5.z.string().uuid({ message: "id must be a valid UUID" }),
+var staffSchema = baseSchema(STAFF_SCHEMA_VERSION).extend({
   team_id: objectIdSchema,
   user_id: objectIdSchema,
   type: codedConceptSchema,
   status: codedConceptSchema,
   membership_key: z5.z.string().optional(),
   group: z5.z.string().optional(),
-  subspecialist: z5.z.string().optional(),
-  created_at: timestampSchema,
-  created_by: z5.z.string(),
-  updated_at: timestampSchema,
-  updated_by: z5.z.string(),
-  schema_version: z5.z.number().int().positive().default(STAFF_SCHEMA_VERSION)
+  subspecialist: z5.z.string().optional()
 });
 var StaffMongooseSchema = zodMongoose.toMongooseSchema(staffSchema);
 var StaffModelName = "staffs";
@@ -1383,7 +1418,7 @@ var StaffModel = mongoose.model(StaffModelName, StaffMongooseSchema);
 
 // src/models/staff/staff-minimal.schema.ts
 var staffMinimalSchema = staffSchema.omit({
-  id: true,
+  _id: true,
   created_at: true,
   created_by: true,
   updated_at: true,
@@ -1394,8 +1429,7 @@ var staffMinimalSchema = staffSchema.omit({
 // src/models/staff/staff-partial.schema.ts
 var staffPartialSchema = staffMinimalSchema.partial();
 var UNIT_SCHEMA_VERSION = 1;
-var unitSchema = z5.z.object({
-  _id: objectIdSchema,
+var unitSchema = baseSchema(UNIT_SCHEMA_VERSION).extend({
   facility_id: objectIdSchema,
   department_id: objectIdSchema,
   name: z5.z.string().min(1, { message: "name is required" }),
@@ -1404,12 +1438,7 @@ var unitSchema = z5.z.object({
   statuses: z5.z.array(codedConceptSchema).nonempty({
     message: "statuses must contain at least one CodedConcept"
   }),
-  settings_id: objectIdSchema,
-  created_at: timestampSchema,
-  created_by: z5.z.string(),
-  updated_at: timestampSchema,
-  updated_by: z5.z.string(),
-  schema_version: z5.z.number().int().positive().default(UNIT_SCHEMA_VERSION)
+  settings_id: objectIdSchema
 });
 var UnitMongooseSchema = zodMongoose.toMongooseSchema(unitSchema);
 var UnitModelName = "units";
@@ -1428,19 +1457,15 @@ var unitMinimalSchema = unitSchema.omit({
 // src/models/unit/unit-partial.schema.ts
 var unitPartialSchema = unitMinimalSchema.partial();
 var PRACTITIONER_SCHEDULE_SCHEMA_VERSION = 1;
-var practitionerScheduleSchema = z5.z.object({
+var practitionerScheduleSchema = baseSchema(
+  PRACTITIONER_SCHEDULE_SCHEMA_VERSION
+).extend({
   organization_id: objectIdSchema,
   facility_id: objectIdSchema,
   staff_id: objectIdSchema,
   unit_id: objectIdSchema,
   type: codedConceptSchema,
-  day: z5.z.union([z5.z.number(), z5.z.string()]).refine((val) => val != null, { message: "day is required" }),
-  _id: objectIdSchema,
-  created_at: timestampSchema.optional(),
-  created_by: z5.z.string().optional(),
-  updated_at: timestampSchema.optional(),
-  updated_by: z5.z.string().optional(),
-  schema_version: z5.z.number().int().positive().default(PRACTITIONER_SCHEDULE_SCHEMA_VERSION)
+  day: z5.z.union([z5.z.number(), z5.z.string()]).refine((val) => val != null, { message: "day is required" })
 });
 var PractitionerScheduleMongooseSchema = zodMongoose.toMongooseSchema(practitionerScheduleSchema);
 var PractitionerScheduleModelName = "practitioner_schedules";
@@ -1459,19 +1484,15 @@ var practitionerScheduleMinimalSchema = practitionerScheduleSchema.omit({
 // src/models/practitioner-schedule/practitioner-schedule-partial.schema.ts
 var practitionerSchedulePartialSchema = practitionerScheduleMinimalSchema.partial();
 var PRACTITIONER_SESSION_SCHEMA_VERSION = 1;
-var practitionerSessionSchema = z5.z.object({
+var practitionerSessionSchema = baseSchema(
+  PRACTITIONER_SESSION_SCHEMA_VERSION
+).extend({
   schedule_id: objectIdSchema,
   staff_id: objectIdSchema,
   unit_id: objectIdSchema,
   start: z5.z.string().min(1, { message: "start is required" }),
   end: z5.z.string().min(1, { message: "end is required" }),
-  max_quota: z5.z.number().int().positive({ message: "max_quota must be a positive integer" }),
-  _id: objectIdSchema,
-  created_at: timestampSchema.optional(),
-  created_by: z5.z.string().optional(),
-  updated_at: timestampSchema.optional(),
-  updated_by: z5.z.string().optional(),
-  schema_version: z5.z.number().int().positive().default(PRACTITIONER_SESSION_SCHEMA_VERSION)
+  max_quota: z5.z.number().int().positive({ message: "max_quota must be a positive integer" })
 });
 var PractitionerSessionMongooseSchema = zodMongoose.toMongooseSchema(practitionerSessionSchema);
 var PractitionerSessionModelName = "practitioner_sessions";
@@ -1490,17 +1511,11 @@ var practitionerSessionMinimalSchema = practitionerSessionSchema.omit({
 // src/models/practitioner-session/practitioner-session-partial.schema.ts
 var practitionerSessionPartialSchema = practitionerSessionMinimalSchema.partial();
 var KSM_SCHEMA_VERSION = 1;
-var ksmSchema = z5.z.object({
-  id: z5.z.string().uuid({ message: "id must be a valid UUID" }),
+var ksmSchema = baseSchema(KSM_SCHEMA_VERSION).extend({
   organization_id: objectIdSchema,
   facility_id: objectIdSchema,
   name: z5.z.string().min(1, { message: "name is required" }),
-  subspecialist: z5.z.array(z5.z.string()).min(1, { message: "subspecialist is required" }),
-  created_at: timestampSchema,
-  created_by: z5.z.string().min(1, { message: "created_by is required" }),
-  updated_at: timestampSchema.nullable(),
-  updated_by: z5.z.string().nullable(),
-  schema_version: z5.z.number().int().positive().default(KSM_SCHEMA_VERSION)
+  subspecialist: z5.z.array(z5.z.string()).min(1, { message: "subspecialist is required" })
 });
 var KsmMongooseSchema = zodMongoose.toMongooseSchema(ksmSchema);
 var KsmModelName = "medical_staff_groups";
@@ -1508,7 +1523,7 @@ var KsmModel = mongoose.model(KsmModelName, KsmMongooseSchema);
 
 // src/models/ksm/ksm-minimal.schema.ts
 var ksmMinimalSchema = ksmSchema.omit({
-  id: true,
+  _id: true,
   created_at: true,
   created_by: true,
   updated_at: true,
@@ -1520,8 +1535,7 @@ var ksmMinimalSchema = ksmSchema.omit({
 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 = z5.z.object({
-  id: z5.z.string().uuid({ message: "id must be a valid UUID" }),
+var payerSchema = baseSchema(PAYER_SCHEMA_VERSION).extend({
   organization_id: objectIdSchema,
   facility_id: objectIdSchema,
   code: z5.z.string().min(1, { message: "code is required" }),
@@ -1556,12 +1570,7 @@ var payerSchema = z5.z.object({
       ),
       settings_id: objectIdSchema
     })
-  ),
-  created_at: timestampSchema,
-  created_by: z5.z.string().min(1, { message: "created_by is required" }),
-  updated_at: timestampSchema,
-  updated_by: z5.z.string().min(1, { message: "updated_by is required" }),
-  schema_version: z5.z.number().int().positive().default(PAYER_SCHEMA_VERSION)
+  )
 });
 var PayerMongooseSchema = zodMongoose.toMongooseSchema(payerSchema);
 var PayerModelName = "payers";
@@ -1619,7 +1628,7 @@ var payerSettingsKVSchema = z5.z.object({
 
 // src/models/payer/payer-minimal.schema.ts
 var payerMinimalSchema = payerSchema.omit({
-  id: true,
+  _id: true,
   created_at: true,
   created_by: true,
   updated_at: true,
@@ -1630,8 +1639,7 @@ var payerMinimalSchema = payerSchema.omit({
 // src/models/payer/payer-partial.schema.ts
 var payerPartialSchema = payerMinimalSchema.partial();
 var QUEUE_SCHEMA_VERSION = 1;
-var queueSchema = z5.z.object({
-  id: z5.z.string().uuid({ message: "id must be a valid UUID" }),
+var queueSchema = baseSchema(QUEUE_SCHEMA_VERSION).extend({
   organization_id: objectIdSchema,
   facility_id: objectIdSchema,
   unit_id: objectIdSchema,
@@ -1644,46 +1652,15 @@ var queueSchema = z5.z.object({
       status: codedConceptSchema,
       call_count: z5.z.number().int().positive({ message: "call_count must be a positive integer" })
     })
-  ),
-  created_at: timestampSchema,
-  created_by: z5.z.string().min(1, { message: "created_by is required" }),
-  updated_at: timestampSchema,
-  updated_by: z5.z.string().min(1, { message: "updated_by is required" }),
-  schema_version: z5.z.number().int().positive().default(QUEUE_SCHEMA_VERSION)
+  )
 });
 var QueueMongooseSchema = zodMongoose.toMongooseSchema(queueSchema);
 var QueueModelName = "queues";
 var QueueModel = mongoose.model(QueueModelName, QueueMongooseSchema);
-var QUEUE_SETTING_FIELDS = [
-  "number_length",
-  "call_priority",
-  "call_threshold"
-];
-var QUEUE_SETTINGS_SCHEMA_VERSION = 1;
-var queueSettingsSchema = z5.z.object({
-  _id: objectIdSchema,
-  scope: z5.z.string().min(1),
-  options: z5.z.array(
-    settingOptionSchema.refine(
-      (opt) => QUEUE_SETTING_FIELDS.includes(opt.field),
-      { message: "Invalid field for queue settings" }
-    )
-  ),
-  updated_at: timestampSchema,
-  updated_by: z5.z.string(),
-  schema_version: z5.z.number().int().positive().default(QUEUE_SETTINGS_SCHEMA_VERSION)
-});
-var queueSettingsKVSchema = z5.z.object({
-  number_length: z5.z.number().int().positive().nullable().default(null),
-  call_priority: z5.z.string().default("sequence"),
-  call_threshold: z5.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,
+  _id: true,
   created_at: true,
   created_by: true,
   updated_at: true,
@@ -1694,17 +1671,11 @@ var queueMinimalSchema = queueSchema.omit({
 // src/models/queue/queue-partial.schema.ts
 var queuePartialSchema = queueMinimalSchema.partial();
 var QUEUE_EVENT_LOG_SCHEMA_VERSION = 1;
-var queueEventLogSchema = z5.z.object({
-  id: z5.z.string().uuid({ message: "id must be a valid UUID" }),
+var queueEventLogSchema = baseSchema(QUEUE_EVENT_LOG_SCHEMA_VERSION).extend({
   queue_number_id: objectIdSchema,
   queue_number: z5.z.string().min(1, { message: "queue_number is required" }),
   events: z5.z.array(codedConceptSchema),
-  count: z5.z.number().int().positive({ message: "count must be a positive integer" }),
-  created_at: timestampSchema,
-  created_by: z5.z.string().min(1, { message: "created_by is required" }),
-  updated_at: timestampSchema,
-  updated_by: z5.z.string().min(1, { message: "updated_by is required" }),
-  schema_version: z5.z.number().int().positive().default(QUEUE_EVENT_LOG_SCHEMA_VERSION)
+  count: z5.z.number().int().positive({ message: "count must be a positive integer" })
 });
 var QueueEventLogMongooseSchema = zodMongoose.toMongooseSchema(queueEventLogSchema);
 var QueueEventLogModelName = "queue_event_logs";
@@ -1712,7 +1683,7 @@ var QueueEventLogModel = mongoose.model(QueueEventLogModelName, QueueEventLogMon
 
 // src/models/queue-event-log/queue-event-log-minimal.schema.ts
 var queueEventLogMinimalSchema = queueEventLogSchema.omit({
-  id: true,
+  _id: true,
   created_at: true,
   created_by: true,
   updated_at: true,
@@ -1724,8 +1695,9 @@ var queueEventLogMinimalSchema = queueEventLogSchema.omit({
 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 = z5.z.object({
-  id: z5.z.string().uuid({ message: "id must be a valid UUID" }),
+var queueNumberSchema = baseSchemaWithExpiredAt(
+  QUEUE_NUMBER_SCHEMA_VERSION
+).extend({
   organization_id: objectIdSchema,
   facility_id: objectIdSchema,
   patient_id: objectIdSchema,
@@ -1740,15 +1712,7 @@ var queueNumberSchema = z5.z.object({
   }),
   sequence: z5.z.number().int().positive({ message: "sequence must be a positive integer" }),
   prefix: z5.z.string().min(1, { message: "prefix is required" }),
-  number: z5.z.string().min(1, { message: "number is required" }),
-  created_at: timestampSchema,
-  created_by: z5.z.string().min(1, { message: "created_by is required" }),
-  updated_at: timestampSchema,
-  updated_by: z5.z.string().min(1, { message: "updated_by is required" }),
-  expired_at: z5.z.string().refine((val) => isoDatetimeRegex4.test(val), {
-    message: "expired_at must be a valid ISO 8601 datetime"
-  }),
-  schema_version: z5.z.number().int().positive().default(QUEUE_NUMBER_SCHEMA_VERSION)
+  number: z5.z.string().min(1, { message: "number is required" })
 });
 var QueueNumberMongooseSchema = zodMongoose.toMongooseSchema(queueNumberSchema);
 var QueueNumberModelName = "queue_numbers";
@@ -1809,7 +1773,7 @@ var queueNumberSettingsKVSchema = z5.z.object({
 
 // src/models/queue-number/queue-number-minimal.schema.ts
 var queueNumberMinimalSchema = queueNumberSchema.omit({
-  id: true,
+  _id: true,
   created_at: true,
   created_by: true,
   updated_at: true,
@@ -1820,8 +1784,35 @@ var queueNumberMinimalSchema = queueNumberSchema.omit({
 
 // src/models/queue-number/queue-number-partial.schema.ts
 var queueNumberPartialSchema = queueNumberMinimalSchema.partial();
+var ARTICLE_SCHEMA_VERSION = 1;
+var articleSchema = baseSchema(ARTICLE_SCHEMA_VERSION).extend({
+  facility_id: objectIdSchema,
+  title: z5.z.string().min(1, { message: "for is required" }),
+  banner: z5.z.url(),
+  body: z5.z.string(),
+  status: codedConceptSchema
+});
+var ArticleMongooseSchema = zodMongoose.toMongooseSchema(articleSchema);
+var ArticleModelName = "articles";
+var ArticleModel = mongoose.model(ArticleModelName, ArticleMongooseSchema);
+
+// src/models/article/article-minimal.schema.ts
+var articleMinimalSchema = articleSchema.omit({
+  _id: true,
+  created_at: true,
+  created_by: true,
+  updated_at: true,
+  updated_by: true,
+  schema_version: true
+});
+
+// src/models/article/article-partial.schema.ts
+var articlePartialSchema = articleMinimalSchema.partial();
 
+exports.ARTICLE_SCHEMA_VERSION = ARTICLE_SCHEMA_VERSION;
 exports.ASSIGNMENT_SCHEMA_VERSION = ASSIGNMENT_SCHEMA_VERSION;
+exports.ArticleModel = ArticleModel;
+exports.ArticleMongooseSchema = ArticleMongooseSchema;
 exports.AssignmentModel = AssignmentModel;
 exports.AssignmentMongooseSchema = AssignmentMongooseSchema;
 exports.DEPARTMENT_SCHEMA_VERSION = DEPARTMENT_SCHEMA_VERSION;
@@ -1865,7 +1856,6 @@ exports.QUEUE_EVENT_LOG_SCHEMA_VERSION = QUEUE_EVENT_LOG_SCHEMA_VERSION;
 exports.QUEUE_NUMBER_SCHEMA_VERSION = QUEUE_NUMBER_SCHEMA_VERSION;
 exports.QUEUE_NUMBER_SETTINGS_SCHEMA_VERSION = QUEUE_NUMBER_SETTINGS_SCHEMA_VERSION;
 exports.QUEUE_SCHEMA_VERSION = QUEUE_SCHEMA_VERSION;
-exports.QUEUE_SETTINGS_SCHEMA_VERSION = QUEUE_SETTINGS_SCHEMA_VERSION;
 exports.QueueEventLogModel = QueueEventLogModel;
 exports.QueueEventLogMongooseSchema = QueueEventLogMongooseSchema;
 exports.QueueModel = QueueModel;
@@ -1884,9 +1874,14 @@ exports.UserModel = UserModel;
 exports.UserMongooseSchema = UserMongooseSchema;
 exports.addressSchema = addressSchema;
 exports.apiResponseSchema = apiResponseSchema;
+exports.articleMinimalSchema = articleMinimalSchema;
+exports.articlePartialSchema = articlePartialSchema;
+exports.articleSchema = articleSchema;
 exports.assignmentMinimalSchema = assignmentMinimalSchema;
 exports.assignmentPartialSchema = assignmentPartialSchema;
 exports.assignmentSchema = assignmentSchema;
+exports.baseSchema = baseSchema;
+exports.baseSchemaWithExpiredAt = baseSchemaWithExpiredAt;
 exports.codedConceptSchema = codedConceptSchema;
 exports.demographicSchema = demographicSchema;
 exports.departmentMinimalSchema = departmentMinimalSchema;
@@ -1943,8 +1938,6 @@ exports.queueNumberSettingsKVSchema = queueNumberSettingsKVSchema;
 exports.queueNumberSettingsSchema = queueNumberSettingsSchema;
 exports.queuePartialSchema = queuePartialSchema;
 exports.queueSchema = queueSchema;
-exports.queueSettingsKVSchema = queueSettingsKVSchema;
-exports.queueSettingsSchema = queueSettingsSchema;
 exports.settingOptionSchema = settingOptionSchema;
 exports.settingOptionTypeSchema = settingOptionTypeSchema;
 exports.singleResourceResponseSchema = singleResourceResponseSchema;