Merge branch 'dev' of github.com:dikstub-rssa/simrs-fe into feat/education-assessment-79

app/schemas/_generate-file.ts

@@ -0,0 +1,5 @@
+export interface GenerateFile {
+  entityType_code: string
+  ref_id: number
+  type_code: string
+}

app/schemas/chemotherapy.schema.ts

@@ -0,0 +1,73 @@
+import { z } from 'zod'
+
+const dateStringSchema = z.string().min(1)
+
+export const chemotherapySchema = z.object({
+  // Data Pasien
+  namaPasien: z.string({
+    required_error: 'Nama pasien harus diisi',
+  }).min(1, 'Nama pasien harus diisi'),
+  
+  tanggalLahir: z.string({
+    required_error: 'Tanggal lahir harus diisi',
+  }).min(1, 'Tanggal lahir harus diisi'),
+  
+  noRM: z.string({
+    required_error: 'Nomor RM harus diisi',
+  }).min(1, 'Nomor RM harus diisi'),
+  
+  alamat: z.string({
+    required_error: 'Alamat harus diisi',
+  }).min(1, 'Alamat harus diisi'),
+  
+  beratBadan: z.union([
+    z.string(),
+    z.number()
+  ]).transform(val => val === '' ? null : Number(val))
+    .refine(val => val === null || (val >= 0 && val <= 500), {
+      message: 'Berat badan harus di antara 0-500 kg',
+    }),
+  
+  tinggiBadan: z.union([
+    z.string(),
+    z.number()
+  ]).transform(val => val === '' ? null : Number(val))
+    .refine(val => val === null || (val >= 0 && val <= 300), {
+      message: 'Tinggi badan harus di antara 0-300 cm',
+    }),
+  
+  diagnosa: z.string({
+    required_error: 'Diagnosa harus dipilih',
+  }).min(1, 'Diagnosa harus dipilih'),
+
+  // Protokol Kemoterapi
+  siklus: z.string({
+    required_error: 'Siklus harus diisi',
+  }).min(1, 'Siklus harus diisi'),
+  
+  periodeAwal: z.string({
+    required_error: 'Periode awal harus diisi',
+  }).min(1, 'Periode awal harus diisi'),
+  
+  periodeAkhir: dateStringSchema.refine((val) => {
+    if (!val) return false
+    const date = new Date(val)
+    return !isNaN(date.getTime())
+  }, {
+    message: 'Format tanggal tidak valid'
+  }),
+
+  tanggalKemoterapi: dateStringSchema.refine((val) => {
+    if (!val) return false
+    const date = new Date(val)
+    return !isNaN(date.getTime())
+  }, {
+    message: 'Format tanggal tidak valid'
+  }),
+  
+  dokterKRJ: z.string({
+    required_error: 'Dokter harus dipilih',
+  }).refine(val => val !== '', {
+    message: 'Dokter harus dipilih',
+  }),
+})

app/schemas/consultation.schema.ts

@@ -3,7 +3,7 @@ import type { CreateDto } from '~/models/consultation'
 
 const ConsultationSchema = z.object({
   date: z.string({ required_error: 'Tanggal harus diisi' }),
-  dstUnit_id: z.number({ required_error: 'Unit harus diisi' }),
+  dstUnit_code: z.string({ required_error: 'Unit harus diisi' }),
   problem: z.string({ required_error: 'Uraian harus diisi' }).min(20, 'Uraian minimum 20 karakter'),
 })
 

app/schemas/control-letter.schema.ts

@@ -0,0 +1,47 @@
+import { z } from 'zod'
+
+const ControlLetterSchema = z.object({
+  sepStatus: z.string({
+    required_error: 'Mohon isi status SEP',
+  }).default('SEP Internal'),
+  unit_code: z.string({
+    required_error: 'Mohon isi Unit',
+  }),
+  specialist_code: z.string({
+    required_error: 'Mohon isi Spesialis',
+  }),
+  subspecialist_code: z.string({
+    required_error: 'Mohon isi Sub Spesialis',
+  }),
+  doctor_code: z.string({
+    required_error: 'Mohon isi DPJP',
+  }),
+  encounter_code: z.string().optional(),
+  date: z.string({
+    required_error: 'Mohon lengkapi Tanggal Kontrol',
+  })
+    .refine(
+      (date) => {
+        // Jika kosong, return false untuk required validation
+        if (!date || date.trim() === '') return false
+
+        // Jika ada isi, validasi format tanggal
+        try {
+          const dateObj = new Date(date)
+          // Cek apakah tanggal valid dan tahun >= 1900
+          return !isNaN(dateObj.getTime()) && dateObj.getFullYear() >= 1900
+        } catch {
+          return false
+        }
+      },
+      {
+        message: 'Mohon lengkapi Tanggal Kontrol dengan format yang valid',
+      },
+    )
+    .transform((dateStr) => new Date(dateStr).toISOString()),
+})
+
+type ControlLetterFormData = z.infer<typeof ControlLetterSchema>
+
+export { ControlLetterSchema }
+export type { ControlLetterFormData }

app/schemas/device-order.schema.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod'
+import type { DeviceOrder } from '~/models/device-order'
+
+const DeviceOrderSchema = z.object({
+  encounter_id: z.number({ required_error: 'Kode harus diisi' }),
+  doctor_id: z.number({ required_error: 'Kode harus diisi' }),
+})
+
+type DeviceOrderFormData = z.infer<typeof DeviceOrderSchema> & Partial<DeviceOrder>
+
+export { DeviceOrderSchema }
+export type { DeviceOrderFormData }

app/schemas/division-position.schema.ts

@@ -5,7 +5,7 @@ const DivisionPositionSchema = z.object({
   code: z.string({ required_error: 'Kode harus diisi' }).min(1, 'Kode minimum 1 karakter'),
   name: z.string({ required_error: 'Nama harus diisi' }).min(1, 'Nama minimum 1 karakter'),
   headStatus: z.boolean().optional().nullable(),
-  division_id: z.union([
+  division_code: z.union([
     z.string({ required_error: 'Divisi Induk harus diisi' }),
     z.number({ required_error: 'Divisi Induk harus diisi' })
   ]).optional().nullable(),

app/schemas/division.schema.ts

@@ -4,7 +4,7 @@ import type { Division } from '~/models/division'
 const DivisionSchema = z.object({
   code: z.string({ required_error: 'Kode harus diisi' }).min(1, 'Kode minimum 1 karakter'),
   name: z.string({ required_error: 'Nama harus diisi' }).min(1, 'Nama minimum 1 karakter'),
-  parent_id: z.union([
+  parent_code: z.union([
     z.string({ required_error: 'Divisi Induk harus diisi' }),
     z.number({ required_error: 'Divisi Induk harus diisi' })
   ]).optional().nullable(),

app/schemas/document-upload.schema.ts

@@ -0,0 +1,25 @@
+import { z } from 'zod'
+
+const ACCEPTED_UPLOAD_TYPES = ['image/jpeg', 'image/png', 'application/pdf']
+const MAX_SIZE_BYTES = 1 * 1024 * 1024 // 1MB
+
+const DocumentUploadSchema = z.object({
+  entityType_code: z.string().default('encounter'),
+  ref_id: z.number(),
+  upload_employee_id: z.number().optional(),
+  // upload_employee_id: z.number(),
+  name: z.string({    required_error: 'Mohon isi',  }),
+  type_code: z.string({    required_error: 'Mohon isi',  }),
+  content: z.custom<File>()
+          .refine((f) => f, { message: 'File tidak boleh kosong' })
+          .refine((f) => !f || f instanceof File, { message: 'Harus berupa file yang valid' })
+          .refine((f) => !f || ACCEPTED_UPLOAD_TYPES.includes(f.type), {
+            message: 'Format file harus JPG, PNG, atau PDF',
+          })
+          .refine((f) => !f || f.size <= MAX_SIZE_BYTES, { message: 'Maksimal 1MB' }),
+})
+
+type DocumentUploadFormData = z.infer<typeof DocumentUploadSchema>
+
+export { DocumentUploadSchema }
+export type { DocumentUploadFormData }

app/schemas/encounter.schema.ts

@@ -0,0 +1,49 @@
+import { z } from 'zod'
+import { InternalReferenceSchema } from './internal-reference.schema'
+
+// Check In
+const CheckInSchema = z.object({
+  // registeredAt: z.string({ required_error: 'Tanggal masuk harus diisi' }),
+  responsible_doctor_code: z.string({ required_error: 'Dokter harus diisi' }),
+  // adm_employee_id: z.number({ required_error: 'PJA harus diisi' }).gt(0, 'PJA harus diisi'),
+  registeredAt: z.string({ required_error: 'waktu harus diisi' }),
+})
+type CheckInFormData = z.infer<typeof CheckInSchema>
+
+// Checkout
+const CheckOutSchema = z.object({
+  discharge_method_code: z.string({ required_error: 'Metode pulang harus diisi' }),
+  discharge_date: z.string({ required_error: 'Tanggal pulang harus diisi' }),
+})
+type CheckOutFormData = z.infer<typeof CheckOutSchema>
+
+// CheckoutDeath
+const CheckOutDeathSchema = z.object({
+  discharge_method_code: z.string({ required_error: 'Metode pulang harus diisi' }),
+  discharge_date: z.string({ required_error: 'Tanggal pulang harus diisi' }),
+  death_cause: z.array(z.string()).nonempty(),
+})
+type CheckOutDeathFormData = z.infer<typeof CheckOutDeathSchema>
+
+// CheckoutDeath
+const CheckOutInternalReferenceSchema = z.object({
+  discharge_method_code: z.string({ required_error: 'Metode pulang harus diisi' }),
+  discharge_date: z.string({ required_error: 'Tanggal pulang harus diisi' }),
+  internalReferences: z.array(InternalReferenceSchema).nonempty(),
+})
+type CheckOutInternalReferenceFormData = z.infer<typeof CheckOutInternalReferenceSchema>
+
+
+// Exports
+export {
+  CheckInSchema,
+  CheckOutSchema,
+  CheckOutDeathSchema,
+  CheckOutInternalReferenceSchema
+}
+export type {
+  CheckInFormData,
+  CheckOutFormData,
+  CheckOutDeathFormData,
+  CheckOutInternalReferenceFormData
+}

app/schemas/general-consent.schema.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod'
+import type { CreateDto } from '~/models/general-consent'
+
+const GeneralConsentSchema = z.object({
+  relatives: z.array(z.object({ name: z.string(), phone: z.string() })),
+  responsibleName: z.string().optional(),
+  responsiblePhone: z.string().optional(),
+  informant: z.string().optional(),
+  witness1: z.string().optional(),
+  witness2: z.string().optional(),
+})
+
+type GeneralConsentFormData = z.infer<typeof GeneralConsentSchema> & CreateDto
+
+export { GeneralConsentSchema }
+export type { GeneralConsentFormData }

app/schemas/installation-position.schema.ts

@@ -0,0 +1,20 @@
+import { z } from 'zod'
+import type { InstallationPosition } from '~/models/installation-position'
+
+const InstallationPositionSchema = z.object({
+  code: z.string({ required_error: 'Kode harus diisi' }).min(1, 'Kode minimum 1 karakter'),
+  name: z.string({ required_error: 'Nama harus diisi' }).min(1, 'Nama minimum 1 karakter'),
+  headStatus: z.boolean().optional().nullable(),
+  installation_code: z.union([
+    z.string({ required_error: 'Instalasi Induk harus diisi' }),
+    z.number({ required_error: 'Instalasi Induk harus diisi' }),
+  ]),
+  employee_id: z
+    .union([z.string({ required_error: 'Karyawan harus diisi' }), z.number({ required_error: 'Karyawan harus diisi' })])
+    .optional()
+    .nullable(),
+})
+type InstallationPositionFormData = z.infer<typeof InstallationPositionSchema> & Partial<InstallationPosition>
+
+export { InstallationPositionSchema }
+export type { InstallationPositionFormData }

app/schemas/integration-bpjs.schema.ts

@@ -0,0 +1,255 @@
+import { z } from 'zod'
+
+const ERROR_MESSAGES = {
+  required: {
+    sepDate: 'Tanggal wajib diisi',
+    serviceType: 'Jenis Pelayanan wajib diisi',
+    admissionType: 'Jenis Pendaftaran wajib diisi',
+    cardNumber: 'No. Kartu BPJS wajib diisi',
+    nationalId: 'Nomor ID wajib diisi',
+    medicalRecordNumber: 'Nomor Rekam Medis wajib diisi',
+    patientName: 'Nama wajib diisi',
+    phoneNumber: 'Nomor Telepon wajib diisi',
+    referralLetterNumber: 'Nomor Surat Kontrol wajib diisi',
+    referralLetterDate: 'Tanggal Surat Kontrol wajib diisi',
+    fromClinic: 'Faskes Asal wajib diisi',
+    destinationClinic: 'Klinik Tujuan wajib diisi',
+    attendingDoctor: 'Dokter wajib diisi',
+    initialDiagnosis: 'Diagnosa Awal wajib diisi',
+    cob: 'COB wajib diisi',
+    cataract: 'Katarak wajib diisi',
+    clinicExcecutive: 'Klinkik eksekutif wajib diisi',
+    subSpecialistId: 'Subspesialis wajib diisi',
+    procedureType: 'Jenis Prosedur wajib diisi',
+    supportCode: 'Kode Penunjang wajib diisi',
+    note: 'Catatan wajib diisi',
+    trafficAccident: 'Kejadian lalu lintas wajib diisi',
+    purposeOfVisit: 'Tujuan Kunjungan wajib diisi',
+    serviceAssessment: 'Assemen Pelayanan wajib diisi',
+    lpNumber: 'Nomor LP wajib diisi',
+    accidentDate: 'Tanggal Kejadian lalu lintas wajib diisi',
+    accidentNote: 'Keterangan Kejadian lalu lintas wajib diisi',
+    accidentProvince: 'Provinsi Kejadian lalu lintas wajib diisi',
+    accidentCity: 'Kota Kejadian lalu lintas wajib diisi',
+    accidentDistrict: 'Kecamatan Kejadian lalu lintas wajib diisi',
+    suplesi: 'Suplesi wajib diisi',
+    suplesiNumber: 'Nomor Suplesi wajib diisi',
+    classLevel: 'Kelas Rawat wajib diisi',
+    classLevelUpgrade: 'Kelas Rawat Naik wajib diisi',
+    classPaySource: 'Pembiayaan wajib diisi',
+    responsiblePerson: 'Penanggung Jawab wajib diisi',
+  },
+}
+
+const IntegrationBpjsSchema = z
+  .object({
+    sepDate: z.string({ required_error: ERROR_MESSAGES.required.sepDate }).min(1, ERROR_MESSAGES.required.sepDate),
+    serviceType: z
+      .string({ required_error: ERROR_MESSAGES.required.serviceType })
+      .min(1, ERROR_MESSAGES.required.serviceType)
+      .optional(),
+    admissionType: z
+      .string({ required_error: ERROR_MESSAGES.required.admissionType })
+      .min(1, ERROR_MESSAGES.required.admissionType),
+    cardNumber: z
+      .string({ required_error: ERROR_MESSAGES.required.cardNumber })
+      .min(1, ERROR_MESSAGES.required.cardNumber),
+    nationalId: z
+      .string({ required_error: ERROR_MESSAGES.required.nationalId })
+      .min(1, ERROR_MESSAGES.required.nationalId),
+    medicalRecordNumber: z
+      .string({ required_error: ERROR_MESSAGES.required.medicalRecordNumber })
+      .min(1, ERROR_MESSAGES.required.medicalRecordNumber),
+    patientName: z
+      .string({ required_error: ERROR_MESSAGES.required.patientName })
+      .min(1, ERROR_MESSAGES.required.patientName),
+    phoneNumber: z
+      .string({ required_error: ERROR_MESSAGES.required.phoneNumber })
+      .min(1, ERROR_MESSAGES.required.phoneNumber),
+    referralLetterNumber: z
+      .string({ required_error: ERROR_MESSAGES.required.referralLetterNumber })
+      .min(1, ERROR_MESSAGES.required.referralLetterNumber).optional(),
+    referralLetterDate: z
+      .string({ required_error: ERROR_MESSAGES.required.referralLetterDate })
+      .min(1, ERROR_MESSAGES.required.referralLetterDate).optional(),
+    fromClinic: z
+      .string({ required_error: ERROR_MESSAGES.required.fromClinic })
+      .min(1, ERROR_MESSAGES.required.fromClinic)
+      .optional(),
+    destinationClinic: z
+      .string({ required_error: ERROR_MESSAGES.required.destinationClinic })
+      .min(1, ERROR_MESSAGES.required.destinationClinic).optional(),
+    attendingDoctor: z
+      .string({ required_error: ERROR_MESSAGES.required.attendingDoctor })
+      .min(1, ERROR_MESSAGES.required.attendingDoctor),
+    initialDiagnosis: z
+      .string({ required_error: ERROR_MESSAGES.required.initialDiagnosis })
+      .min(1, ERROR_MESSAGES.required.initialDiagnosis),
+    cob: z.string({ required_error: ERROR_MESSAGES.required.cob }).min(1, ERROR_MESSAGES.required.cob),
+    cataract: z.string({ required_error: ERROR_MESSAGES.required.cataract }).min(1, ERROR_MESSAGES.required.cataract),
+    clinicExcecutive: z
+      .string({ required_error: ERROR_MESSAGES.required.clinicExcecutive })
+      .min(1, ERROR_MESSAGES.required.clinicExcecutive).optional(),
+    subSpecialistId: z
+      .string({ required_error: ERROR_MESSAGES.required.subSpecialistId })
+      .min(1, ERROR_MESSAGES.required.subSpecialistId)
+      .optional(),
+    procedureType: z
+      .string({ required_error: ERROR_MESSAGES.required.procedureType })
+      .min(1, ERROR_MESSAGES.required.procedureType)
+      .optional(),
+    supportCode: z
+      .string({ required_error: ERROR_MESSAGES.required.supportCode })
+      .min(1, ERROR_MESSAGES.required.supportCode)
+      .optional(),
+    note: z.string({ required_error: ERROR_MESSAGES.required.note }).min(1, ERROR_MESSAGES.required.note).optional(),
+    trafficAccident: z
+      .string({ required_error: ERROR_MESSAGES.required.trafficAccident })
+      .min(1, ERROR_MESSAGES.required.trafficAccident)
+      .optional(),
+    purposeOfVisit: z
+      .string({ required_error: ERROR_MESSAGES.required.purposeOfVisit })
+      .min(1, ERROR_MESSAGES.required.purposeOfVisit)
+      .optional(),
+    serviceAssessment: z
+      .string({ required_error: ERROR_MESSAGES.required.serviceAssessment })
+      .min(1, ERROR_MESSAGES.required.serviceAssessment)
+      .optional(),
+    lpNumber: z.string({ required_error: ERROR_MESSAGES.required.lpNumber }).optional(),
+    accidentDate: z.string({ required_error: ERROR_MESSAGES.required.accidentDate }).optional(),
+    accidentNote: z.string({ required_error: ERROR_MESSAGES.required.accidentNote }).optional(),
+    accidentProvince: z.string({ required_error: ERROR_MESSAGES.required.accidentProvince }).optional(),
+    accidentCity: z.string({ required_error: ERROR_MESSAGES.required.accidentCity }).optional(),
+    accidentDistrict: z.string({ required_error: ERROR_MESSAGES.required.accidentDistrict }).optional(),
+    suplesi: z.string({ required_error: ERROR_MESSAGES.required.suplesi }).optional(),
+    suplesiNumber: z.string({ required_error: ERROR_MESSAGES.required.suplesiNumber }).optional(),
+    classLevel: z.string({ required_error: ERROR_MESSAGES.required.classLevel }).optional(),
+    classLevelUpgrade: z.string({ required_error: ERROR_MESSAGES.required.classLevelUpgrade }).optional(),
+    classPaySource: z.string({ required_error: ERROR_MESSAGES.required.classPaySource }).optional(),
+    responsiblePerson: z.string({ required_error: ERROR_MESSAGES.required.responsiblePerson }).optional(),
+  })
+  .refine(
+    (data) => {
+      if (data.trafficAccident && data.trafficAccident.trim() !== '') {
+        return data.accidentDate && data.accidentDate.trim() !== ''
+      }
+      return true
+    },
+    {
+      message: ERROR_MESSAGES.required.accidentDate,
+      path: ['accidentDate'],
+    },
+  )
+  .refine(
+    (data) => {
+      if (data.trafficAccident && data.trafficAccident.trim() !== '') {
+        return data.accidentProvince && data.accidentProvince.trim() !== ''
+      }
+      return true
+    },
+    {
+      message: ERROR_MESSAGES.required.accidentProvince,
+      path: ['accidentProvince'],
+    },
+  )
+  .refine(
+    (data) => {
+      if (data.trafficAccident && data.trafficAccident.trim() !== '') {
+        return data.accidentCity && data.accidentCity.trim() !== ''
+      }
+      return true
+    },
+    {
+      message: ERROR_MESSAGES.required.accidentCity,
+      path: ['accidentCity'],
+    },
+  )
+  .refine(
+    (data) => {
+      if (data.trafficAccident && data.trafficAccident.trim() !== '') {
+        return data.accidentDistrict && data.accidentDistrict.trim() !== ''
+      }
+      return true
+    },
+    {
+      message: ERROR_MESSAGES.required.accidentDistrict,
+      path: ['accidentDistrict'],
+    },
+  )
+  .refine(
+    (data) => {
+      if (data.trafficAccident && data.trafficAccident.trim() !== '') {
+        return data.suplesi && data.suplesi.trim() !== ''
+      }
+      return true
+    },
+    {
+      message: ERROR_MESSAGES.required.suplesi,
+      path: ['suplesi'],
+    },
+  )
+  .refine(
+    (data) => {
+      if (data.trafficAccident && data.trafficAccident.trim() !== '' && data.suplesi?.trim() === 'yes') {
+        return data.suplesiNumber && data.suplesiNumber.trim() !== ''
+      }
+      return true
+    },
+    {
+      message: ERROR_MESSAGES.required.suplesiNumber,
+      path: ['suplesiNumber'],
+    },
+  )
+  .refine(
+    (data) => {
+      if (data.serviceType === '1') {
+        return data.classLevel && data.classLevel.trim() !== ''
+      }
+      return true
+    },
+    {
+      message: ERROR_MESSAGES.required.classLevel,
+      path: ['classLevel'],
+    },
+  )
+  .refine(
+    (data) => {
+      if (data.serviceType === '1') {
+        return data.classLevelUpgrade && data.classLevelUpgrade.trim() !== ''
+      }
+      return true
+    },
+    {
+      message: ERROR_MESSAGES.required.classLevelUpgrade,
+      path: ['classLevelUpgrade'],
+    },
+  )
+  .refine(
+    (data) => {
+      if (data.serviceType === '1' && data.classLevelUpgrade?.trim() !== '') {
+        return data.classPaySource && data.classPaySource.trim() !== ''
+      }
+      return true
+    },
+    {
+      message: ERROR_MESSAGES.required.classPaySource,
+      path: ['classPaySource'],
+    },
+  )
+  .refine(
+    (data) => {
+      if (data.serviceType === '1' && data.classPaySource?.trim() !== '') {
+        return data.responsiblePerson && data.responsiblePerson.trim() !== ''
+      }
+      return true
+    },
+    {
+      message: ERROR_MESSAGES.required.responsiblePerson,
+      path: ['responsiblePerson'],
+    },
+  )
+
+type IntegrationBpjsFormData = z.infer<typeof IntegrationBpjsSchema>
+
+export { IntegrationBpjsSchema }
+export type { IntegrationBpjsFormData }

app/schemas/integration-encounter.schema.ts

@@ -0,0 +1,134 @@
+import { z } from 'zod'
+
+const ERROR_MESSAGES = {
+  required: {
+    doctor_code: 'Dokter wajib diisi',
+    registerDate: 'Tanggal Daftar wajib diisi',
+    paymentMethod_code: 'Jenis Pembayaran wajib diisi',
+    unit_code: 'Spesialis wajib diisi',
+    // specialist_code: 'Spesialis wajib diisi',
+    // subSpecialist_code: 'Subspesialis wajib diisi',
+    patientCategory: 'Kelompok Peserta wajib diisi',
+    cardNumber: 'No. Kartu BPJS wajib diisi',
+    sepType: 'Jenis SEP wajib diisi',
+    sepNumber: 'No. SEP wajib diisi',
+  },
+}
+
+const ACCEPTED_UPLOAD_TYPES = ['image/jpeg', 'image/png', 'application/pdf']
+
+const IntegrationEncounterSchema = z
+  .object({
+    // Patient data (readonly, populated from selected patient)
+    patientName: z.string().optional(),
+    nationalIdentity: z.string().optional(),
+    medicalRecordNumber: z.string().optional(),
+
+    // Visit data
+    doctor_code: z
+      .string({ required_error: ERROR_MESSAGES.required.doctor_code })
+      .min(1, ERROR_MESSAGES.required.doctor_code),
+    unit_code: z
+      .string({ required_error: ERROR_MESSAGES.required.unit_code })
+      .min(1, ERROR_MESSAGES.required.unit_code)
+      .optional(),
+    registerDate: z
+      .string({ required_error: ERROR_MESSAGES.required.registerDate })
+      .min(1, ERROR_MESSAGES.required.registerDate),
+    paymentMethod_code: z
+      .string({ required_error: ERROR_MESSAGES.required.paymentMethod_code })
+      .min(1, ERROR_MESSAGES.required.paymentMethod_code),
+
+    // BPJS related fields
+    patientCategory: z
+      .string()
+      .min(1, ERROR_MESSAGES.required.patientCategory)
+      .optional(),
+    cardNumber: z
+      .string()
+      .min(1, ERROR_MESSAGES.required.cardNumber)
+      .optional(),
+    sepType: z
+      .string()
+      .min(1, ERROR_MESSAGES.required.sepType)
+      .optional(),
+    sepNumber: z
+      .string({ required_error: ERROR_MESSAGES.required.sepNumber })
+      .optional(),
+
+    // File uploads
+    sepFile: z
+      .any()
+      .optional()
+      .refine((f) => !f || f instanceof File, { message: 'Harus berupa file yang valid' })
+      .refine((f) => !f || ACCEPTED_UPLOAD_TYPES.includes(f.type), {
+        message: 'Format file harus JPG, PNG, atau PDF',
+      })
+      .refine((f) => !f || f.size <= 1 * 1024 * 1024, { message: 'Maksimal 1MB' }),
+    sippFile: z
+      .any()
+      .optional()
+      .refine((f) => !f || f instanceof File, { message: 'Harus berupa file yang valid' })
+      .refine((f) => !f || ACCEPTED_UPLOAD_TYPES.includes(f.type), {
+        message: 'Format file harus JPG, PNG, atau PDF',
+      })
+      .refine((f) => !f || f.size <= 1 * 1024 * 1024, { message: 'Maksimal 1MB' }),
+  })
+  .refine(
+    (data) => {
+      // If payment type is jkn, then patient category is required
+      if (data.paymentMethod_code === 'jkn') {
+        return data.patientCategory && data.patientCategory.trim() !== ''
+      }
+      return true
+    },
+    {
+      message: ERROR_MESSAGES.required.patientCategory,
+      path: ['patientCategory'],
+    },
+  )
+  .refine(
+    (data) => {
+      // If payment type is jkn, then card number is required
+      if (data.paymentMethod_code === 'jkn') {
+        return data.cardNumber && data.cardNumber.trim() !== ''
+      }
+      return true
+    },
+    {
+      message: ERROR_MESSAGES.required.cardNumber,
+      path: ['cardNumber'],
+    },
+  )
+  .refine(
+    (data) => {
+      // If payment type is jkn, then SEP type is required
+      if (data.paymentMethod_code === 'jkn') {
+        return data.sepType && data.sepType.trim() !== ''
+      }
+      return true
+    },
+    {
+      message: ERROR_MESSAGES.required.sepType,
+      path: ['sepType'],
+    },
+  )
+  .refine(
+    (data) => {
+      // If payment type is jkn and SEP type is selected, then SEP number is required
+      if (data.paymentMethod_code === 'jkn' && data.sepType && data.sepType.trim() !== '') {
+        return data.sepNumber && data.sepNumber.trim() !== ''
+      }
+      return true
+    },
+    {
+      message: ERROR_MESSAGES.required.sepNumber,
+      path: ['sepNumber'],
+    },
+  )
+
+type IntegrationEncounterFormData = z.infer<typeof IntegrationEncounterSchema>
+
+export { IntegrationEncounterSchema }
+export type { IntegrationEncounterFormData }
+

app/schemas/internal-reference.schema.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod'
+import type { InternalReference } from '~/models/internal-reference'
+
+const InternalReferenceSchema = z.object({
+  'unit_id': z.number({ required_error: 'Kode harus diisi' }).min(1, 'Kode minimum 1 karakter'),
+  'doctor_id': z.number({ required_error: 'Kode harus diisi' }).min(1, 'Kode minimum 1 karakter'),
+})
+
+type InternalReferenceFormData = z.infer<typeof InternalReferenceSchema> & Partial<InternalReference>
+
+export { InternalReferenceSchema }
+export type { InternalReferenceFormData }

app/schemas/kfr.schema.ts

@@ -0,0 +1,17 @@
+import { z } from 'zod'
+
+type KfrFormData = z.infer<typeof KfrSchema>
+const KfrSchema = z.object({
+  subjective: z.string({required_error: 'Mohon lengkapi Form',}),
+  objective: z.string({required_error: 'Mohon lengkapi Form',}),
+  assesment: z.string({required_error: 'Mohon lengkapi Form',}),
+  planningGoal: z.string({required_error: 'Mohon lengkapi Form',}),
+  planningAction: z.string({required_error: 'Mohon lengkapi Form',}),
+  planningEducation: z.string({required_error: 'Mohon lengkapi Form',}),
+  planningFrequency: z.number({required_error: 'Mohon lengkapi Form',}),
+  followUpPlan: z.enum(['EVALUASI', 'RUJUK', "SELESAI"], {required_error: 'Mohon lengkapi status pasien', }),
+  followUpPlanDesc: z.string({required_error: 'Mohon lengkapi Form',}),
+})
+
+export { KfrSchema,  }
+export type { KfrFormData,  }

app/schemas/material-package-item.schema.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod'
+import type { MaterialPackageItem } from '~/models/material-package-item'
+
+const MaterialSchema = z.object({
+  materialPackage_code: z.string({ required_error: 'Kode harus diisi' }).min(1, 'Kode minimum 1 karakter'),
+  material_code: z.string({ required_error: 'Nama harus diisi' }).min(1, 'Nama minimum 1 karakter'),
+})
+
+type MaterialFormData = z.infer<typeof MaterialSchema> & Partial<MaterialPackageItem>
+
+export { MaterialSchema }
+export type { MaterialFormData }

app/schemas/material-package.schema.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod'
+import type { MaterialPackage } from '~/models/material-package'
+
+const MaterialSchema = z.object({
+  code: z.string({ required_error: 'Kode harus diisi' }).min(1, 'Kode minimum 1 karakter'),
+  name: z.string({ required_error: 'Nama harus diisi' }).min(1, 'Nama minimum 1 karakter'),
+})
+
+type MaterialFormData = z.infer<typeof MaterialSchema> & Partial<MaterialPackage>
+
+export { MaterialSchema }
+export type { MaterialFormData }

app/schemas/medicine.schema.ts

@@ -5,6 +5,7 @@ export const MedicineSchema = z.object({
   name: z.string({ required_error: 'Nama harus diisi' }).min(1, 'Nama minimal 1 karakter'),
   medicineGroup_code: z.string({ required_error: 'Kelompok obat harus diisi' }).min(1, 'Kelompok obat harus diisi'),
   medicineMethod_code: z.string({ required_error: 'Metode pemberian harus diisi' }).min(1, 'Metode pemberian harus diisi'),
+  medicineForm_code: z.string({ required_error: 'Sediaan Obat harus diisi' }).min(1, 'Sediaan Obat harus diisi'),
   uom_code: z.string({ required_error: 'Satuan harus diisi' }).min(1, 'Satuan harus diisi'),
   infra_id: z.number().nullable().optional(),
   stock: z.preprocess((val) => Number(val), z.number({ invalid_type_error: 'Stok harus berupa angka' }).min(1, 'Stok harus lebih besar dari 0')),

app/schemas/prb-medicine.schema.ts

@@ -0,0 +1,27 @@
+import { z } from 'zod'
+
+const PrbMedicineSchema = z.object({
+  a1: z.string({
+    required_error: 'Mohon isi',
+  }).optional(),
+  a2: z.string({
+    required_error: 'Mohon isi',
+  }),
+  a3: z.string({
+    required_error: 'Mohon isi',
+  }),
+  a4: z.string({
+    required_error: 'Mohon isi',
+  }).optional(),
+  a5: z.string({
+    required_error: 'Mohon isi',
+  }),
+  a6: z.string({
+    required_error: 'Mohon isi',
+  }),
+})
+
+type PrbMedicineFormData = z.infer<typeof PrbMedicineSchema>
+
+export { PrbMedicineSchema }
+export type { PrbMedicineFormData }

app/schemas/prb.schema.ts

@@ -0,0 +1,47 @@
+import { z } from 'zod'
+
+const PrbSchema = z.object({
+  sepStatus: z.string({
+    required_error: 'Mohon isi status SEP',
+  }).default('SEP Internal'),
+  unit_code: z.string({
+    required_error: 'Mohon isi Unit',
+  }),
+  specialist_code: z.string({
+    required_error: 'Mohon isi Spesialis',
+  }),
+  subspecialist_code: z.string({
+    required_error: 'Mohon isi Sub Spesialis',
+  }),
+  doctor_code: z.string({
+    required_error: 'Mohon isi DPJP',
+  }),
+  encounter_code: z.string().optional(),
+  date: z.string({
+    required_error: 'Mohon lengkapi Tanggal Kontrol',
+  })
+    .refine(
+      (date) => {
+        // Jika kosong, return false untuk required validation
+        if (!date || date.trim() === '') return false
+
+        // Jika ada isi, validasi format tanggal
+        try {
+          const dateObj = new Date(date)
+          // Cek apakah tanggal valid dan tahun >= 1900
+          return !isNaN(dateObj.getTime()) && dateObj.getFullYear() >= 1900
+        } catch {
+          return false
+        }
+      },
+      {
+        message: 'Mohon lengkapi Tanggal Kontrol dengan format yang valid',
+      },
+    )
+    .transform((dateStr) => new Date(dateStr).toISOString()),
+})
+
+type PrbFormData = z.infer<typeof PrbSchema>
+
+export { PrbSchema }
+export type { PrbFormData }

app/schemas/prescription-item.schema.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod'
+import type { PrescriptionItem } from '~/models/prescription-item'
+
+const PrescriptionItemSchema = z.object({
+})
+
+type PrescriptionItemFormData = z.infer<typeof PrescriptionItemSchema> & PrescriptionItem
+
+export { PrescriptionItemSchema }
+export type { PrescriptionItemFormData }

app/schemas/prescription.schema.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod'
+import type { Prescription } from '~/models/prescription'
+
+const PrescriptionSchema = z.object({
+    'encounter-id': z.number().nullable().optional(),
+})
+
+type PrescriptionFormData = z.infer<typeof PrescriptionSchema> & Prescription
+
+export { PrescriptionSchema }
+export type { PrescriptionFormData }

app/schemas/resume.schema.ts

@@ -0,0 +1,76 @@
+import { z } from 'zod'
+import type { CreateDto } from '~/models/consultation'
+
+export type ResumeArrangementType = "krs" | "mrs" | "rujukInternal" | "rujukExternal" | "meninggal" | "other"
+
+const SecondaryDiagnosisSchema = z.object({  
+  diagnosis: z.string({ required_error: 'Diagnosis harus diisi' }),
+  icd10: z.string({ required_error: 'ICD 10 harus diisi' }),
+  diagnosisBasis: z.string({ required_error: 'Dasar Diagnosis harus diisi' })
+    .min(1, 'Uraian minimum 1 karakter')
+    .max(2048, 'Uraian maksimum 2048 karakter'),
+})
+
+const SecondaryActionSchema = z.object({
+  action: z.string({ required_error: 'Action harus diisi' }),
+  icd9: z.string({ required_error: 'ICD 10 harus diisi' }),
+  actionBasis: z.string({ required_error: 'Dasar Action harus diisi' })
+    .min(1, 'Uraian minimum 1 karakter')
+    .max(2048, 'Uraian maksimum 2048 karakter'),
+})
+
+const ConsultationSchema = z.object({
+  consultation: z.string({ required_error: 'Consultation harus diisi' })
+    .min(1, 'Uraian minimum 1 karakter')
+    .max(2048, 'Uraian maksimum 2048 karakter'),
+  consultationReply: z.string({ required_error: 'Jawaban Consultation harus diisi' })
+    .min(1, 'Uraian minimum 1 karakter')
+    .max(2048, 'Uraian maksimum 2048 karakter'),
+})
+
+const ResumeSchema = z.object({
+  inDate: z.string({ required_error: 'Tanggal harus diisi' }),
+  outDate: z.string({ required_error: 'Tanggal harus diisi' }),
+  anamnesis: z.number({ required_error: 'Anamnesis harus diisi' })
+    .min(1, 'Anamnesis minimum 1 karakter')
+    .max(2048, 'Anamnesis maksimum 2048 karakter'),
+  physicalCheckup: z.string({ required_error: 'Uraian harus diisi' })
+    .min(1, 'Uraian minimum 1 karakter')
+    .max(2048, 'Uraian maksimum 2048 karakter'),
+  supplementCheckup: z.string({ required_error: 'Uraian harus diisi' })
+    .min(1, 'Uraian minimum 1 karakter')
+    .max(2048, 'Uraian maksimum 2048 karakter'),
+
+  primaryDiagnosis: z.string({ required_error: 'Diagnosis harus diisi' }),
+  secondaryDiagnosis: z.array(SecondaryDiagnosisSchema).optional(),
+
+  primaryOperativeNonOperativeAct: z.string({ required_error: 'Diagnosis harus diisi' }),
+  secondaryOperativeNonOperativeAct: z.array(SecondaryActionSchema).optional(),
+  medikamentosa: z.string({ required_error: 'Uraian harus diisi' })
+    .min(1, 'Uraian minimum 1 karakter')
+    .max(2048, 'Uraian maksimum 2048 karakter'),
+
+  consultation: z.array(ConsultationSchema).optional(),
+
+  arrangement: z.custom<ResumeArrangementType>().default("krs"),
+  inpatientIndication: z.string({ required_error: 'Uraian harus diisi' })
+    .min(1, 'Uraian minimum 1 karakter')
+    .max(2048, 'Uraian maksimum 2048 karakter'),
+  faskes: z.string({ required_error: 'Faskes harus diisi' }).optional(),
+  clinic: z.string({ required_error: 'Klinik harus diisi' }).optional(),
+  deathDate: z.string({ required_error: 'Tanggal harus diisi' }).optional(),
+  deathCause: z.array(z.string()).optional().default([]),
+  deathCauseDescription: z.string({ required_error: 'Uraian harus diisi' })
+    .min(1, 'Uraian minimum 1 karakter')
+    .max(2048, 'Uraian maksimum 2048 karakter')
+    .optional(),
+  keterangan: z.string({ required_error: 'Uraian harus diisi' })
+    .min(1, 'Uraian minimum 1 karakter')
+    .max(2048, 'Uraian maksimum 2048 karakter')
+    .optional(),
+})
+
+type ResumeFormData = z.infer<typeof ResumeSchema> & (CreateDto)
+
+export { ResumeSchema }
+export type { ResumeFormData }

app/schemas/soapi.schema.ts

@@ -0,0 +1,233 @@
+import { z } from 'zod'
+import type { Soap } from '~/models/soapi'
+
+const DiagnosisCodeSchema = z.object({
+  code: z.string().default(''),
+  name: z.string().default(''),
+})
+
+const AssessmentSectionSchema = z.object({
+  note: z.string().default(''),
+  codes: z.array(DiagnosisCodeSchema).default([]),
+})
+
+export const EarlySchema = z.object({
+  'prim-compl': z.string({ required_error: 'Keluhan utama harus diisi' }).min(1, 'Keluhan utama harus diisi'),
+  'cur-disea-hist': z.string().default(''),
+  'syst-bp': z.string().default(''),
+  'diast-bp': z.string().default(''),
+  pulse: z.string().default(''),
+  'resp-rate': z.string().default(''),
+  temp: z.string().default(''),
+  weight: z.string().default(''),
+  height: z.string().default(''),
+  'reflect-fisio': z.string().default(''),
+  'reflect-pato': z.string().default(''),
+  'autonom-neuron': z.string().default(''),
+  'medical-act': z.string().default(''),
+  therapy: z.string().default(''),
+})
+
+export const EarlyRehabSchema = z.object({
+  'prim-compl': z.string({ required_error: 'Keluhan utama harus diisi' }).min(1, 'Keluhan utama harus diisi'),
+  'medical-plan': z.string().default(''),
+  'diagnosis-medical': z.string().default(''),
+  'rehab-trouble': z.string().default(''),
+  'medical-trouble': z.string().default(''),
+  'physic-modal': z.string().default(''),
+  exercise: z.string().default(''),
+  'ortho-pesa': z.string().default(''),
+  education: z.string().default(''),
+  other: z.string().default(''),
+  cranialis: z.string().default(''),
+  sensoris: z.string().default(''),
+  'reflect-fisio': z.string().default(''),
+  'reflect-pato': z.string().default(''),
+  otonom: z.string().default(''),
+  localis: z.string().default(''),
+  'medical-trial': z.string().default(''),
+  therapy: z.string().default(''),
+  'syst-bp': z.string().default(''),
+  'diast-bp': z.string().default(''),
+  pulse: z.string().default(''),
+  gcs: z.string().default(''),
+  'respiratory-rate': z.string().default(''),
+  temp: z.string().default(''),
+  weight: z.string().default(''),
+  height: z.string().default(''),
+  ambulance: z.string().default(''),
+  gait: z.string().default(''),
+  'neck-rom': z.string().default(''),
+  'body-rom': z.string().default(''),
+  'aga-rom': z.string().default(''),
+  'agb-rom': z.string().default(''),
+  'neck-mmt': z.string().default(''),
+  'body-mmt': z.string().default(''),
+  'aga-mmt': z.string().default(''),
+  'agb-mmt': z.string().default(''),
+})
+
+export const FunctionSoapiSchema = z.object({
+  'prim-compl': z.string({ required_error: 'Keluhan utama harus diisi' }).min(1, 'Keluhan utama harus diisi'),
+  'past-disease': z.string().default(''),
+  'current-disease': z.string().default(''),
+  gcs: z.string().default(''),
+  'respiratory-rate': z.string().default(''),
+  'respiratory-rate-type': z.string().default(''),
+  pulse: z.string().default(''),
+  'pulse-type': z.string().default(''),
+  'right-arm-bp': z.string().default(''),
+  'left-arm-bp': z.string().default(''),
+  'axillary-temp': z.string().default(''),
+  'rektal-temp': z.string().default(''),
+  skin: z.string().default(''),
+  head: z.string().default(''),
+  ear: z.string().default(''),
+  nose: z.string().default(''),
+  'oral-cavity': z.string().default(''),
+  eye: z.string().default(''),
+  'other-body-part': z.string().default(''),
+  neck: z.string().default(''),
+  thyroid: z.string().default(''),
+  thorax: z.string().default(''),
+  heart: z.string().default(''),
+  lung: z.string().default(''),
+  abdomen: z.string().default(''),
+  heart2: z.string().default(''),
+  lien: z.string().default(''),
+  back: z.string().default(''),
+  extremity: z.string().default(''),
+  gender: z.string().default(''),
+  rectum: z.string().default(''),
+  'system-syaraf': z.string().default(''),
+  'nervous-system': z.string().default(''),
+  'cardio-respiratory': z.string().default(''),
+  imaging: z.string().default(''),
+  laboratory: z.string().default(''),
+})
+
+export const SubjectSchema = z.object({
+  note: z.string().default(''),
+  'prim-compl': z.string({ required_error: 'Keluhan utama harus diisi' }).min(1, 'Keluhan utama harus diisi'),
+  'sec-compl': z.string().default(''),
+  'pri-complain': z.string().default(''),
+  'sec-complain': z.string().default(''),
+  'cur-disea-hist': z.string().default(''),
+  'pas-disea-hist': z.string().default(''),
+  'fam-disea-hist': z.string().default(''),
+  'alg-hist': z.string().default(''),
+  'alg-react': z.string().default(''),
+  'med-hist': z.string().default(''),
+  'blood-type': z.string().default(''),
+})
+
+export const ObjectSchema = z.object({
+  note: z.string().default(''),
+  'consc-level': z.string().default(''),
+  'consc-level-det': z.string().default(''),
+  'syst-bp': z.string().default(''),
+  'diast-bp': z.string().default(''),
+  pulse: z.string().default(''),
+  'resp-rate': z.string().default(''),
+  'hear-rt': z.string().default(''),
+  'neuro-cranialis': z.string().default(''),
+  sensoris: z.string().default(''),
+  'reflect-fisio': z.string().default(''),
+  'reflect-pato': z.string().default(''),
+  'autonom-neuron': z.string().default(''),
+  'neck-rom': z.string().default(''),
+  'body-rom': z.string().default(''),
+  'aga-rom': z.string().default(''),
+  'agb-rom': z.string().default(''),
+  'neck-mmt': z.string().default(''),
+  'body-mmt': z.string().default(''),
+  'aga-mmt': z.string().default(''),
+  'agb-mmt': z.string().default(''),
+  localis: z.string().default(''),
+  'medical-trouble': z.string().default(''),
+  'rehab-medic-trouble': z.string().default(''),
+  temp: z.string().default(''),
+  spo2: z.string().default(''),
+  weight: z.string().default(''),
+  height: z.string().default(''),
+  'head-to-toe': z.record(z.string()).default({}),
+})
+
+export const SummaryMedicSchema = z.object({
+  date: z.string().default(''),
+  doctor: z.string().default(''),
+  diagnosis: z.string().default(''),
+  essay: z.string().default(''),
+  plan: z.string().default(''),
+  note: z.string().default(''),
+})
+
+export const InitialNursingSchema = z.object({
+  'pri-complain': z.string().default(''),
+  'med-type': z.string().default(''),
+  'med-name': z.string().default(''),
+  'med-reaction': z.string().default(''),
+  'food-type': z.string().default(''),
+  'food-name': z.string().default(''),
+  'food-reaction': z.string().default(''),
+  'other-type': z.string().default(''),
+  'other-name': z.string().default(''),
+  'other-reaction': z.string().default(''),
+  'pain-asst': z.string().default(''),
+  'pain-scale': z.string().default(''),
+  'pain-time': z.string().default(''),
+  'pain-duration': z.string().default(''),
+  'pain-freq': z.string().default(''),
+  'pain-loc': z.string().default(''),
+  'nut-screening': z.string().default(''),
+  'spiritual-asst': z.string().default(''),
+  'general-condition': z.string().default(''),
+  'support-exam': z.string().default(''),
+  'risk-fall': z.string().default(''),
+  bracelet: z.string().default(''),
+  'bracelet-alg': z.string().default(''),
+})
+
+const AssessmentSchema = z.object({
+  'early-diag': AssessmentSectionSchema,
+  'late-diag': AssessmentSectionSchema,
+  'sec-diag': AssessmentSectionSchema,
+})
+
+const InstructionCodeGroupSchema = z.object({
+  note: z.string().default(''),
+  codes: z.array(DiagnosisCodeSchema).default([]),
+})
+
+const InstructionSchema = z.object({
+  detail: z.string().default(''),
+  'medical-act': InstructionCodeGroupSchema,
+  'supporting-exam': z.array(DiagnosisCodeSchema).default([]),
+  therapy: z.string().default(''),
+  medication: z.array(DiagnosisCodeSchema).default([]),
+  material: z.array(DiagnosisCodeSchema).default([]),
+  'rehab-program': z.string().default(''),
+  'physic-modal': z.string().default(''),
+  exercise: z.string().default(''),
+  'ortes-protesa': z.string().default(''),
+  education: z.string().default(''),
+  other: z.string().default(''),
+})
+
+export const CprjSoapiSchema = z.object({
+  subjective: z.string().default(''),
+  objective: z.string().default(''),
+  assesment: z.string().default(''),
+  plan: z.string().default(''),
+  review: z.string().default(''),
+})
+
+export const SoapSchema = z.object({
+  subject: SubjectSchema,
+  object: ObjectSchema,
+  assessment: AssessmentSchema,
+  plan: z.string().default(''),
+  instruction: InstructionSchema,
+})
+
+export type SoapiFormData = z.infer<typeof SoapSchema> & Partial<Soap>

app/schemas/specialist-position.schema.ts

@@ -0,0 +1,24 @@
+import { z } from 'zod'
+import type { SpecialistPosition } from '~/models/specialist-position'
+
+const SpecialistPositionSchema = z.object({
+  code: z.string({ required_error: 'Kode harus diisi' }).min(1, 'Kode minimum 1 karakter'),
+  name: z.string({ required_error: 'Nama harus diisi' }).min(1, 'Nama minimum 1 karakter'),
+  headStatus: z.boolean().optional().nullable(),
+  specialist_code: z
+    .union([
+      z.string({ required_error: 'Spesialis harus diisi' }),
+      z.number({ required_error: 'Spesialis harus diisi' }),
+    ])
+    .optional()
+    .nullable(),
+  employee_id: z
+    .union([z.string({ required_error: 'Karyawan harus diisi' }), z.number({ required_error: 'Karyawan harus diisi' })])
+    .optional()
+    .nullable(),
+})
+
+type SpecialistPositionFormData = z.infer<typeof SpecialistPositionSchema> & Partial<SpecialistPosition>
+
+export { SpecialistPositionSchema }
+export type { SpecialistPositionFormData }

app/schemas/specialist.schema.ts

@@ -4,7 +4,7 @@ import type { Specialist } from '~/models/specialist'
 const SpecialistSchema = z.object({
   code: z.string({ required_error: 'Kode harus diisi' }).min(1, 'Kode minimum 1 karakter'),
   name: z.string({ required_error: 'Nama harus diisi' }).min(1, 'Nama minimum 1 karakter'),
-  unit_id: z
+  unit_code: z
     .union([z.string({ required_error: 'Unit harus diisi' }), z.number({ required_error: 'Unit harus diisi' })])
     .optional()
     .nullable(),

app/schemas/subspecialist-position.schema.ts

@@ -0,0 +1,24 @@
+import { z } from 'zod'
+import type { SubSpecialistPosition } from '~/models/subspecialist-position'
+
+const SubSpecialistPositionSchema = z.object({
+  code: z.string({ required_error: 'Kode harus diisi' }).min(1, 'Kode minimum 1 karakter'),
+  name: z.string({ required_error: 'Nama harus diisi' }).min(1, 'Nama minimum 1 karakter'),
+  headStatus: z.boolean().optional().nullable(),
+  subspecialist_code: z
+    .union([
+      z.string({ required_error: 'Spesialis harus diisi' }),
+      z.number({ required_error: 'Spesialis harus diisi' }),
+    ])
+    .optional()
+    .nullable(),
+  employee_id: z
+    .union([z.string({ required_error: 'Karyawan harus diisi' }), z.number({ required_error: 'Karyawan harus diisi' })])
+    .optional()
+    .nullable(),
+})
+
+type SubSpecialistPositionFormData = z.infer<typeof SubSpecialistPositionSchema> & Partial<SubSpecialistPosition>
+
+export { SubSpecialistPositionSchema }
+export type { SubSpecialistPositionFormData }

app/schemas/subspecialist.schema.ts

@@ -4,7 +4,7 @@ import type { Subspecialist } from '~/models/subspecialist'
 const SubspecialistSchema = z.object({
   code: z.string({ required_error: 'Kode harus diisi' }).min(1, 'Kode minimum 1 karakter'),
   name: z.string({ required_error: 'Nama harus diisi' }).min(1, 'Nama minimum 1 karakter'),
-  specialist_id: z
+  specialist_code: z
     .union([
       z.string({ required_error: 'Spesialis harus diisi' }),
       z.number({ required_error: 'Spesialis harus diisi' }),

app/schemas/surgery-report.schema.ts

@@ -0,0 +1,47 @@
+import { z } from 'zod'
+
+const SurgeryReportSchema = z.object({
+  sepStatus: z.string({
+    required_error: 'Mohon isi status SEP',
+  }).default('SEP Internal'),
+  unit_code: z.string({
+    required_error: 'Mohon isi Unit',
+  }),
+  specialist_code: z.string({
+    required_error: 'Mohon isi Spesialis',
+  }),
+  subspecialist_code: z.string({
+    required_error: 'Mohon isi Sub Spesialis',
+  }),
+  doctor_code: z.string({
+    required_error: 'Mohon isi DPJP',
+  }),
+  encounter_code: z.string().optional(),
+  date: z.string({
+    required_error: 'Mohon lengkapi Tanggal Kontrol',
+  })
+    .refine(
+      (date) => {
+        // Jika kosong, return false untuk required validation
+        if (!date || date.trim() === '') return false
+
+        // Jika ada isi, validasi format tanggal
+        try {
+          const dateObj = new Date(date)
+          // Cek apakah tanggal valid dan tahun >= 1900
+          return !isNaN(dateObj.getTime()) && dateObj.getFullYear() >= 1900
+        } catch {
+          return false
+        }
+      },
+      {
+        message: 'Mohon lengkapi Tanggal Kontrol dengan format yang valid',
+      },
+    )
+    .transform((dateStr) => new Date(dateStr).toISOString()),
+})
+
+type SurgeryReportFormData = z.infer<typeof SurgeryReportSchema>
+
+export { SurgeryReportSchema }
+export type { SurgeryReportFormData }

app/schemas/therapy-protocol.schema.ts

@@ -0,0 +1,159 @@
+import { z } from 'zod'
+
+const TherapyProtocolSchema = z.object({
+  examinationDate: z.string({
+    required_error: 'Pilih tanggal pemeriksaan',
+  }),
+  relationshipToInsured: z.enum(['spouse', 'child'], {
+    required_error: 'Pilih hubungan',
+  }),
+  anamnesis: z.string({
+    required_error: 'Mohon lengkapi catatan anamnesa',
+  }),
+  medicalHistory: z.string({
+    required_error: 'Mohon lengkapi catatan riwayat penyakit',
+  }),
+  medicationHistory: z.string({
+    required_error: 'Mohon lengkapi catatan riwayat obat',
+  }),
+
+  supportDiagnosis: z.array(
+    z.object({
+      diagnosis: z.string({
+        required_error: 'Isi diagnosis',
+      }),
+    }),
+    {
+      required_error: 'Isi diagnosis',
+    },
+  ),
+  functionalDiagnosis: z.array(
+    z
+      .object({
+        diagnosis: z.string({}),
+      })
+      .optional(),
+    {
+      required_error: 'Isi diagnosis',
+    },
+  ),
+  treatmentDiagnosis: z.array(
+    z.object({
+      diagnosis: z.string({
+        required_error: 'Isi diagnosis',
+      }),
+    }),
+    {
+      required_error: 'Isi diagnosis',
+    },
+  ),
+  supportExamination: z.string({
+    required_error: 'Mohon lengkapi catatan pemeriksaan penunjang',
+  }),
+
+  recommendation: z.string({
+    required_error: 'Mohon lengkapi catatan anjuran',
+  }),
+  evaluation: z.string({
+    required_error: 'Mohon lengkapi catatan evaluasi',
+  }),
+  isWorkRelatedDisease: z.string({
+    required_error: 'Pilih apakah penyakit berkaitan dengan pekerjaan',
+  }),
+})
+
+
+
+const PickerItemSchema = z.object({
+  id: z.number().optional(),
+  code: z.string(),
+  name: z.string()
+})
+
+const TherapyProtocolMedicRehabilitationSchema = z.object({
+  form1ExaminationDate: z.string({
+    required_error: 'Pilih tanggal pemeriksaan',
+  }),
+  form1Diagnose: z.string({
+    required_error: 'Mohon lengkapi catatan diagnosa',
+  }),
+  form1TherapyRequest: z.string({
+    required_error: 'Mohon lengkapi catatan terapi',
+  }),
+  form1TargetPeriod: z.number({
+    required_error: 'Mohon lengkapi catatan terapi',
+  }),
+  form1TherapyTarget: z.string({
+    required_error: 'Mohon lengkapi catatan terapi',
+  }),
+
+  form2RelationshipToInsured: z.enum(['spouse', 'child'], {
+    required_error: 'Pilih hubungan',
+  }),
+  anamnesis: z.string({
+    required_error: 'Mohon lengkapi catatan anamnesa',
+  }),
+  form2PhysicalExamination: z.string({
+    required_error: 'Mohon lengkapi catatan pemeriksaan fisik',
+  }),
+
+  medicalDiagnoses: z.array(PickerItemSchema).default([]),
+  functionDiagnoses: z.array(PickerItemSchema).default([]),
+  procedures: z.array(PickerItemSchema).default([]),
+
+  supportingExams: z.string({
+    required_error: 'Mohon lengkapi catatan pemeriksaan penunjang',
+  }),
+  evaluation: z.string({
+    required_error: 'Mohon lengkapi catatan evaluasi',
+  }),
+  instruction: z.string({
+    required_error: 'Mohon lengkapi catatan anjuran',
+  }),
+  workCauseStatus: z.enum(['YA', 'TIDAK'], {
+    required_error: 'Pilih apakah penyakit berkaitan dengan pekerjaan',
+  }),
+
+  form3ExaminationDate: z.string({
+    required_error: 'Pilih tanggal pemeriksaan',
+  }),
+  form3Diagnose: z.string({
+    required_error: 'Mohon lengkapi catatan diagnosa',
+  }),
+  form3TherapyRequest: z.string({
+    required_error: 'Mohon lengkapi catatan terapi',
+  }),
+  form3ProgramActivities: z.array(
+    z.string({
+      required_error: 'Mohon lengkapi Program/Kegiatan',
+    }),
+    {
+      required_error: 'Isi Program/Kegiatan',
+    },
+  ).default(['']),
+})
+
+
+// {
+//     "encounter_id": 4,
+//     "doctor_code": "doc-3",
+//     "anamnesis": "",
+//     "medicalDiagnoses": "", //json
+//     "functionDiagnoses": "", //json
+//     "procedures":"", 
+//     "supportingExams":"",
+//     "instruction":"",
+//     "evaluation":"",
+//     "workCauseStatus":"YA",
+//     "frequency":1,
+//     "intervalUnit_code":"day",
+//     "duration":30,
+//     "durationUnit_code":"min"
+// }
+
+
+type TherapyProtocolFormData = z.infer<typeof TherapyProtocolSchema>
+type TherapyProtocolMedicRehabilitationFormData = z.infer<typeof TherapyProtocolMedicRehabilitationSchema>
+
+export { TherapyProtocolSchema, TherapyProtocolMedicRehabilitationSchema }
+export type { TherapyProtocolFormData, TherapyProtocolMedicRehabilitationFormData }

app/schemas/unit-position.schema.ts

@@ -0,0 +1,24 @@
+import { z } from 'zod'
+import type { UnitPosition } from '~/models/unit-position'
+
+const UnitPositionSchema = z.object({
+  code: z.string({ required_error: 'Kode harus diisi' }).min(1, 'Kode minimum 1 karakter'),
+  name: z.string({ required_error: 'Nama harus diisi' }).min(1, 'Nama minimum 1 karakter'),
+  headStatus: z.boolean().optional().nullable(),
+  unit_code: z
+    .union([
+      z.string({ required_error: 'Unit Induk harus diisi' }),
+      z.number({ required_error: 'Unit Induk harus diisi' }),
+    ])
+    .optional()
+    .nullable(),
+  employee_id: z
+    .union([z.string({ required_error: 'Karyawan harus diisi' }), z.number({ required_error: 'Karyawan harus diisi' })])
+    .optional()
+    .nullable(),
+})
+
+type UnitPositionFormData = z.infer<typeof UnitPositionSchema> & Partial<UnitPosition>
+
+export { UnitPositionSchema }
+export type { UnitPositionFormData }

app/schemas/unit.schema.ts

@@ -4,7 +4,7 @@ import type { Unit } from '~/models/unit'
 const UnitSchema = z.object({
   code: z.string({ required_error: 'Kode harus diisi' }).min(1, 'Kode minimum 1 karakter'),
   name: z.string({ required_error: 'Nama harus diisi' }).min(1, 'Nama minimum 1 karakter'),
-  installation_id: z
+  installation_code: z
     .union([
       z.string({ required_error: 'Instalasi harus diisi' }),
       z.number({ required_error: 'Instalasi harus diisi' }),

app/schemas/vaccine-data.schema.ts

@@ -0,0 +1,47 @@
+import { z } from 'zod'
+
+const VaccineDataSchema = z.object({
+  sepStatus: z.string({
+    required_error: 'Mohon isi status SEP',
+  }).default('SEP Internal'),
+  unit_code: z.string({
+    required_error: 'Mohon isi Unit',
+  }),
+  specialist_code: z.string({
+    required_error: 'Mohon isi Spesialis',
+  }),
+  subspecialist_code: z.string({
+    required_error: 'Mohon isi Sub Spesialis',
+  }),
+  doctor_code: z.string({
+    required_error: 'Mohon isi DPJP',
+  }),
+  encounter_code: z.string().optional(),
+  date: z.string({
+    required_error: 'Mohon lengkapi Tanggal Kontrol',
+  })
+    .refine(
+      (date) => {
+        // Jika kosong, return false untuk required validation
+        if (!date || date.trim() === '') return false
+
+        // Jika ada isi, validasi format tanggal
+        try {
+          const dateObj = new Date(date)
+          // Cek apakah tanggal valid dan tahun >= 1900
+          return !isNaN(dateObj.getTime()) && dateObj.getFullYear() >= 1900
+        } catch {
+          return false
+        }
+      },
+      {
+        message: 'Mohon lengkapi Tanggal Kontrol dengan format yang valid',
+      },
+    )
+    .transform((dateStr) => new Date(dateStr).toISOString()),
+})
+
+type VaccineDataFormData = z.infer<typeof VaccineDataSchema>
+
+export { VaccineDataSchema }
+export type { VaccineDataFormData }

app/schemas/verification.schema.ts

@@ -0,0 +1,19 @@
+import { z } from 'zod'
+
+const VerificationSchema = z.object({
+  name: z.string({
+    required_error: 'Mohon lengkapi Nama Anda',
+  }),
+  email: z.string({
+    required_error: 'Mohon lengkapi email',
+  }),
+  password: z.string({
+    required_error: 'Mohon lengkapi password',
+  }),
+})
+
+
+type VerificationFormData = z.infer<typeof VerificationSchema>
+
+export { VerificationSchema, }
+export type { VerificationFormData, }