initial commit

packages/db/shared/schemas/variants/index.ts

@@ -0,0 +1,8 @@
+/**
+ * Schema Variants Index
+ * Auto-generated - do not edit manually
+ */
+
+export * from './pure';
+export * from './input';
+export * from './result';

packages/db/shared/schemas/variants/input/Appointment.input.ts

@@ -0,0 +1,26 @@
+import * as z from 'zod';
+import { PatientStatusSchema } from '../../enums/PatientStatus.schema';
+// prettier-ignore
+export const AppointmentInputSchema = z.object({
+    id: z.number().int(),
+    patientId: z.number().int(),
+    userId: z.number().int(),
+    staffId: z.number().int(),
+    title: z.string(),
+    date: z.date(),
+    startTime: z.string(),
+    endTime: z.string(),
+    type: z.string(),
+    notes: z.string().optional().nullable(),
+    procedureCodeNotes: z.string().optional().nullable(),
+    status: z.string(),
+    createdAt: z.date(),
+    eligibilityStatus: PatientStatusSchema,
+    patient: z.unknown(),
+    user: z.unknown(),
+    staff: z.unknown().optional().nullable(),
+    procedures: z.array(z.unknown()),
+    claims: z.array(z.unknown())
+}).strict();
+
+export type AppointmentInputType = z.infer<typeof AppointmentInputSchema>;

packages/db/shared/schemas/variants/input/AppointmentProcedure.input.ts

@@ -0,0 +1,22 @@
+import * as z from 'zod';
+import { ProcedureSourceSchema } from '../../enums/ProcedureSource.schema';
+// prettier-ignore
+export const AppointmentProcedureInputSchema = z.object({
+    id: z.number().int(),
+    appointmentId: z.number().int(),
+    patientId: z.number().int(),
+    procedureCode: z.string(),
+    procedureLabel: z.string().optional().nullable(),
+    fee: z.number().optional().nullable(),
+    category: z.string().optional().nullable(),
+    toothNumber: z.string().optional().nullable(),
+    toothSurface: z.string().optional().nullable(),
+    oralCavityArea: z.string().optional().nullable(),
+    source: ProcedureSourceSchema,
+    comboKey: z.string().optional().nullable(),
+    createdAt: z.date(),
+    appointment: z.unknown(),
+    patient: z.unknown()
+}).strict();
+
+export type AppointmentProcedureInputType = z.infer<typeof AppointmentProcedureInputSchema>;

packages/db/shared/schemas/variants/input/BackupDestination.input.ts

@@ -0,0 +1,12 @@
+import * as z from 'zod';
+// prettier-ignore
+export const BackupDestinationInputSchema = z.object({
+    id: z.number().int(),
+    userId: z.number().int(),
+    path: z.string(),
+    isActive: z.boolean(),
+    createdAt: z.date(),
+    user: z.unknown()
+}).strict();
+
+export type BackupDestinationInputType = z.infer<typeof BackupDestinationInputSchema>;

packages/db/shared/schemas/variants/input/Claim.input.ts

@@ -0,0 +1,32 @@
+import * as z from 'zod';
+import { MissingTeethStatusSchema } from '../../enums/MissingTeethStatus.schema';
+import { ClaimStatusSchema } from '../../enums/ClaimStatus.schema';
+// prettier-ignore
+export const ClaimInputSchema = z.object({
+    id: z.number().int(),
+    patientId: z.number().int(),
+    appointmentId: z.number().int(),
+    userId: z.number().int(),
+    staffId: z.number().int(),
+    patientName: z.string(),
+    memberId: z.string(),
+    dateOfBirth: z.date(),
+    remarks: z.string(),
+    missingTeethStatus: MissingTeethStatusSchema,
+    missingTeeth: z.unknown().optional().nullable(),
+    serviceDate: z.date(),
+    insuranceProvider: z.string(),
+    createdAt: z.date(),
+    updatedAt: z.date(),
+    status: ClaimStatusSchema,
+    claimNumber: z.string().optional().nullable(),
+    patient: z.unknown(),
+    appointment: z.unknown(),
+    user: z.unknown().optional().nullable(),
+    staff: z.unknown().optional().nullable(),
+    serviceLines: z.array(z.unknown()),
+    claimFiles: z.array(z.unknown()),
+    payment: z.unknown().optional().nullable()
+}).strict();
+
+export type ClaimInputType = z.infer<typeof ClaimInputSchema>;

packages/db/shared/schemas/variants/input/ClaimFile.input.ts

@@ -0,0 +1,11 @@
+import * as z from 'zod';
+// prettier-ignore
+export const ClaimFileInputSchema = z.object({
+    id: z.number().int(),
+    claimId: z.number().int(),
+    filename: z.string(),
+    mimeType: z.string(),
+    claim: z.unknown()
+}).strict();
+
+export type ClaimFileInputType = z.infer<typeof ClaimFileInputSchema>;

packages/db/shared/schemas/variants/input/CloudFile.input.ts

@@ -0,0 +1,19 @@
+import * as z from 'zod';
+// prettier-ignore
+export const CloudFileInputSchema = z.object({
+    id: z.number().int(),
+    userId: z.number().int(),
+    name: z.string(),
+    mimeType: z.string().optional().nullable(),
+    fileSize: z.bigint(),
+    folderId: z.number().int().optional().nullable(),
+    isComplete: z.boolean(),
+    totalChunks: z.number().int().optional().nullable(),
+    createdAt: z.date(),
+    updatedAt: z.date(),
+    user: z.unknown(),
+    folder: z.unknown().optional().nullable(),
+    chunks: z.array(z.unknown())
+}).strict();
+
+export type CloudFileInputType = z.infer<typeof CloudFileInputSchema>;

packages/db/shared/schemas/variants/input/CloudFileChunk.input.ts

@@ -0,0 +1,12 @@
+import * as z from 'zod';
+// prettier-ignore
+export const CloudFileChunkInputSchema = z.object({
+    id: z.number().int(),
+    fileId: z.number().int(),
+    seq: z.number().int(),
+    data: z.instanceof(Uint8Array),
+    createdAt: z.date(),
+    file: z.unknown()
+}).strict();
+
+export type CloudFileChunkInputType = z.infer<typeof CloudFileChunkInputSchema>;

packages/db/shared/schemas/variants/input/CloudFolder.input.ts

@@ -0,0 +1,16 @@
+import * as z from 'zod';
+// prettier-ignore
+export const CloudFolderInputSchema = z.object({
+    id: z.number().int(),
+    userId: z.number().int(),
+    name: z.string(),
+    parentId: z.number().int().optional().nullable(),
+    parent: z.unknown().optional().nullable(),
+    children: z.array(z.unknown()),
+    user: z.unknown(),
+    files: z.array(z.unknown()),
+    createdAt: z.date(),
+    updatedAt: z.date()
+}).strict();
+
+export type CloudFolderInputType = z.infer<typeof CloudFolderInputSchema>;

packages/db/shared/schemas/variants/input/Communication.input.ts

@@ -0,0 +1,21 @@
+import * as z from 'zod';
+import { CommunicationChannelSchema } from '../../enums/CommunicationChannel.schema';
+import { CommunicationDirectionSchema } from '../../enums/CommunicationDirection.schema';
+import { CommunicationStatusSchema } from '../../enums/CommunicationStatus.schema';
+// prettier-ignore
+export const CommunicationInputSchema = z.object({
+    id: z.number().int(),
+    patientId: z.number().int(),
+    userId: z.number().int().optional().nullable(),
+    channel: CommunicationChannelSchema,
+    direction: CommunicationDirectionSchema,
+    status: CommunicationStatusSchema,
+    body: z.string().optional().nullable(),
+    callDuration: z.number().int().optional().nullable(),
+    twilioSid: z.string().optional().nullable(),
+    createdAt: z.date(),
+    patient: z.unknown(),
+    user: z.unknown().optional().nullable()
+}).strict();
+
+export type CommunicationInputType = z.infer<typeof CommunicationInputSchema>;

packages/db/shared/schemas/variants/input/DatabaseBackup.input.ts

@@ -0,0 +1,10 @@
+import * as z from 'zod';
+// prettier-ignore
+export const DatabaseBackupInputSchema = z.object({
+    id: z.number().int(),
+    userId: z.number().int(),
+    createdAt: z.date(),
+    user: z.unknown()
+}).strict();
+
+export type DatabaseBackupInputType = z.infer<typeof DatabaseBackupInputSchema>;

packages/db/shared/schemas/variants/input/InsuranceCredential.input.ts

@@ -0,0 +1,12 @@
+import * as z from 'zod';
+// prettier-ignore
+export const InsuranceCredentialInputSchema = z.object({
+    id: z.number().int(),
+    userId: z.number().int(),
+    siteKey: z.string(),
+    username: z.string(),
+    password: z.string(),
+    user: z.unknown()
+}).strict();
+
+export type InsuranceCredentialInputType = z.infer<typeof InsuranceCredentialInputSchema>;

packages/db/shared/schemas/variants/input/Notification.input.ts

@@ -0,0 +1,14 @@
+import * as z from 'zod';
+import { NotificationTypesSchema } from '../../enums/NotificationTypes.schema';
+// prettier-ignore
+export const NotificationInputSchema = z.object({
+    id: z.number().int(),
+    userId: z.number().int(),
+    type: NotificationTypesSchema,
+    message: z.string(),
+    createdAt: z.date(),
+    read: z.boolean(),
+    user: z.unknown()
+}).strict();
+
+export type NotificationInputType = z.infer<typeof NotificationInputSchema>;

packages/db/shared/schemas/variants/input/NpiProvider.input.ts

@@ -0,0 +1,12 @@
+import * as z from 'zod';
+// prettier-ignore
+export const NpiProviderInputSchema = z.object({
+    id: z.number().int(),
+    userId: z.number().int(),
+    npiNumber: z.string(),
+    providerName: z.string(),
+    createdAt: z.date(),
+    user: z.unknown()
+}).strict();
+
+export type NpiProviderInputType = z.infer<typeof NpiProviderInputSchema>;

packages/db/shared/schemas/variants/input/Patient.input.ts

@@ -0,0 +1,34 @@
+import * as z from 'zod';
+import { PatientStatusSchema } from '../../enums/PatientStatus.schema';
+// prettier-ignore
+export const PatientInputSchema = z.object({
+    id: z.number().int(),
+    firstName: z.string(),
+    lastName: z.string(),
+    dateOfBirth: z.date(),
+    gender: z.string(),
+    phone: z.string(),
+    email: z.string().optional().nullable(),
+    address: z.string().optional().nullable(),
+    city: z.string().optional().nullable(),
+    zipCode: z.string().optional().nullable(),
+    insuranceProvider: z.string().optional().nullable(),
+    insuranceId: z.string().optional().nullable(),
+    groupNumber: z.string().optional().nullable(),
+    policyHolder: z.string().optional().nullable(),
+    allergies: z.string().optional().nullable(),
+    medicalConditions: z.string().optional().nullable(),
+    status: PatientStatusSchema,
+    userId: z.number().int(),
+    createdAt: z.date(),
+    user: z.unknown(),
+    appointments: z.array(z.unknown()),
+    procedures: z.array(z.unknown()),
+    claims: z.array(z.unknown()),
+    groups: z.array(z.unknown()),
+    payment: z.array(z.unknown()),
+    communications: z.array(z.unknown()),
+    documents: z.array(z.unknown())
+}).strict();
+
+export type PatientInputType = z.infer<typeof PatientInputSchema>;

packages/db/shared/schemas/variants/input/PatientDocument.input.ts

@@ -0,0 +1,16 @@
+import * as z from 'zod';
+// prettier-ignore
+export const PatientDocumentInputSchema = z.object({
+    id: z.number().int(),
+    patientId: z.number().int(),
+    filename: z.string(),
+    originalName: z.string(),
+    mimeType: z.string(),
+    fileSize: z.bigint(),
+    filePath: z.string(),
+    uploadedAt: z.date(),
+    updatedAt: z.date(),
+    patient: z.unknown()
+}).strict();
+
+export type PatientDocumentInputType = z.infer<typeof PatientDocumentInputSchema>;

packages/db/shared/schemas/variants/input/Payment.input.ts

@@ -0,0 +1,26 @@
+import * as z from 'zod';
+import { PaymentStatusSchema } from '../../enums/PaymentStatus.schema';
+// prettier-ignore
+export const PaymentInputSchema = z.object({
+    id: z.number().int(),
+    claimId: z.number().int().optional().nullable(),
+    patientId: z.number().int(),
+    userId: z.number().int(),
+    updatedById: z.number().int().optional().nullable(),
+    totalBilled: z.number(),
+    totalPaid: z.number(),
+    totalAdjusted: z.number(),
+    totalDue: z.number(),
+    status: PaymentStatusSchema,
+    notes: z.string().optional().nullable(),
+    icn: z.string().optional().nullable(),
+    createdAt: z.date(),
+    updatedAt: z.date(),
+    claim: z.unknown().optional().nullable(),
+    patient: z.unknown(),
+    updatedBy: z.unknown().optional().nullable(),
+    serviceLineTransactions: z.array(z.unknown()),
+    serviceLines: z.array(z.unknown())
+}).strict();
+
+export type PaymentInputType = z.infer<typeof PaymentInputSchema>;

packages/db/shared/schemas/variants/input/PdfFile.input.ts

@@ -0,0 +1,12 @@
+import * as z from 'zod';
+// prettier-ignore
+export const PdfFileInputSchema = z.object({
+    id: z.number().int(),
+    filename: z.string(),
+    pdfData: z.instanceof(Uint8Array),
+    uploadedAt: z.date(),
+    groupId: z.number().int(),
+    group: z.unknown()
+}).strict();
+
+export type PdfFileInputType = z.infer<typeof PdfFileInputSchema>;

packages/db/shared/schemas/variants/input/PdfGroup.input.ts

@@ -0,0 +1,14 @@
+import * as z from 'zod';
+import { PdfTitleKeySchema } from '../../enums/PdfTitleKey.schema';
+// prettier-ignore
+export const PdfGroupInputSchema = z.object({
+    id: z.number().int(),
+    title: z.string(),
+    titleKey: PdfTitleKeySchema,
+    createdAt: z.date(),
+    patientId: z.number().int(),
+    patient: z.unknown(),
+    pdfs: z.array(z.unknown())
+}).strict();
+
+export type PdfGroupInputType = z.infer<typeof PdfGroupInputSchema>;

packages/db/shared/schemas/variants/input/ServiceLine.input.ts

@@ -0,0 +1,24 @@
+import * as z from 'zod';
+import { ServiceLineStatusSchema } from '../../enums/ServiceLineStatus.schema';
+// prettier-ignore
+export const ServiceLineInputSchema = z.object({
+    id: z.number().int(),
+    claimId: z.number().int().optional().nullable(),
+    paymentId: z.number().int().optional().nullable(),
+    procedureCode: z.string(),
+    procedureDate: z.date(),
+    quad: z.string().optional().nullable(),
+    arch: z.string().optional().nullable(),
+    toothNumber: z.string().optional().nullable(),
+    toothSurface: z.string().optional().nullable(),
+    totalBilled: z.number(),
+    totalPaid: z.number(),
+    totalAdjusted: z.number(),
+    totalDue: z.number(),
+    status: ServiceLineStatusSchema,
+    claim: z.unknown().optional().nullable(),
+    payment: z.unknown().optional().nullable(),
+    serviceLineTransactions: z.array(z.unknown())
+}).strict();
+
+export type ServiceLineInputType = z.infer<typeof ServiceLineInputSchema>;

packages/db/shared/schemas/variants/input/ServiceLineTransaction.input.ts

@@ -0,0 +1,20 @@
+import * as z from 'zod';
+import { PaymentMethodSchema } from '../../enums/PaymentMethod.schema';
+// prettier-ignore
+export const ServiceLineTransactionInputSchema = z.object({
+    id: z.number().int(),
+    paymentId: z.number().int(),
+    serviceLineId: z.number().int(),
+    transactionId: z.string().optional().nullable(),
+    paidAmount: z.number(),
+    adjustedAmount: z.number(),
+    method: PaymentMethodSchema,
+    receivedDate: z.date(),
+    payerName: z.string().optional().nullable(),
+    notes: z.string().optional().nullable(),
+    createdAt: z.date(),
+    payment: z.unknown(),
+    serviceLine: z.unknown()
+}).strict();
+
+export type ServiceLineTransactionInputType = z.infer<typeof ServiceLineTransactionInputSchema>;

packages/db/shared/schemas/variants/input/Staff.input.ts

@@ -0,0 +1,16 @@
+import * as z from 'zod';
+// prettier-ignore
+export const StaffInputSchema = z.object({
+    id: z.number().int(),
+    userId: z.number().int(),
+    name: z.string(),
+    email: z.string().optional().nullable(),
+    role: z.string(),
+    phone: z.string().optional().nullable(),
+    createdAt: z.date(),
+    user: z.unknown().optional().nullable(),
+    appointments: z.array(z.unknown()),
+    claims: z.array(z.unknown())
+}).strict();
+
+export type StaffInputType = z.infer<typeof StaffInputSchema>;

packages/db/shared/schemas/variants/input/User.input.ts

@@ -0,0 +1,22 @@
+import * as z from 'zod';
+// prettier-ignore
+export const UserInputSchema = z.object({
+    id: z.number().int(),
+    username: z.string(),
+    password: z.string(),
+    patients: z.array(z.unknown()),
+    appointments: z.array(z.unknown()),
+    staff: z.array(z.unknown()),
+    npiProviders: z.array(z.unknown()),
+    claims: z.array(z.unknown()),
+    insuranceCredentials: z.array(z.unknown()),
+    updatedPayments: z.array(z.unknown()),
+    backups: z.array(z.unknown()),
+    backupDestinations: z.array(z.unknown()),
+    notifications: z.array(z.unknown()),
+    cloudFolders: z.array(z.unknown()),
+    cloudFiles: z.array(z.unknown()),
+    communications: z.array(z.unknown())
+}).strict();
+
+export type UserInputType = z.infer<typeof UserInputSchema>;

packages/db/shared/schemas/variants/input/index.ts

@@ -0,0 +1,27 @@
+/**
+ * Input Variant Schemas
+ * Auto-generated - do not edit manually
+ */
+
+export { UserInputSchema } from './User.input';
+export { PatientInputSchema } from './Patient.input';
+export { AppointmentInputSchema } from './Appointment.input';
+export { StaffInputSchema } from './Staff.input';
+export { NpiProviderInputSchema } from './NpiProvider.input';
+export { AppointmentProcedureInputSchema } from './AppointmentProcedure.input';
+export { ClaimInputSchema } from './Claim.input';
+export { ServiceLineInputSchema } from './ServiceLine.input';
+export { ClaimFileInputSchema } from './ClaimFile.input';
+export { InsuranceCredentialInputSchema } from './InsuranceCredential.input';
+export { PdfGroupInputSchema } from './PdfGroup.input';
+export { PdfFileInputSchema } from './PdfFile.input';
+export { PaymentInputSchema } from './Payment.input';
+export { ServiceLineTransactionInputSchema } from './ServiceLineTransaction.input';
+export { DatabaseBackupInputSchema } from './DatabaseBackup.input';
+export { BackupDestinationInputSchema } from './BackupDestination.input';
+export { NotificationInputSchema } from './Notification.input';
+export { CloudFolderInputSchema } from './CloudFolder.input';
+export { CloudFileInputSchema } from './CloudFile.input';
+export { CloudFileChunkInputSchema } from './CloudFileChunk.input';
+export { CommunicationInputSchema } from './Communication.input';
+export { PatientDocumentInputSchema } from './PatientDocument.input';

packages/db/shared/schemas/variants/pure/Appointment.pure.ts

@@ -0,0 +1,26 @@
+import * as z from 'zod';
+import { PatientStatusSchema } from '../../enums/PatientStatus.schema';
+// prettier-ignore
+export const AppointmentModelSchema = z.object({
+    id: z.number().int(),
+    patientId: z.number().int(),
+    userId: z.number().int(),
+    staffId: z.number().int(),
+    title: z.string(),
+    date: z.date(),
+    startTime: z.string(),
+    endTime: z.string(),
+    type: z.string(),
+    notes: z.string().nullable(),
+    procedureCodeNotes: z.string().nullable(),
+    status: z.string(),
+    createdAt: z.date(),
+    eligibilityStatus: PatientStatusSchema,
+    patient: z.unknown(),
+    user: z.unknown(),
+    staff: z.unknown().nullable(),
+    procedures: z.array(z.unknown()),
+    claims: z.array(z.unknown())
+}).strict();
+
+export type AppointmentPureType = z.infer<typeof AppointmentModelSchema>;

packages/db/shared/schemas/variants/pure/AppointmentProcedure.pure.ts

@@ -0,0 +1,22 @@
+import * as z from 'zod';
+import { ProcedureSourceSchema } from '../../enums/ProcedureSource.schema';
+// prettier-ignore
+export const AppointmentProcedureModelSchema = z.object({
+    id: z.number().int(),
+    appointmentId: z.number().int(),
+    patientId: z.number().int(),
+    procedureCode: z.string(),
+    procedureLabel: z.string().nullable(),
+    fee: z.number().nullable(),
+    category: z.string().nullable(),
+    toothNumber: z.string().nullable(),
+    toothSurface: z.string().nullable(),
+    oralCavityArea: z.string().nullable(),
+    source: ProcedureSourceSchema,
+    comboKey: z.string().nullable(),
+    createdAt: z.date(),
+    appointment: z.unknown(),
+    patient: z.unknown()
+}).strict();
+
+export type AppointmentProcedurePureType = z.infer<typeof AppointmentProcedureModelSchema>;

packages/db/shared/schemas/variants/pure/BackupDestination.pure.ts

@@ -0,0 +1,12 @@
+import * as z from 'zod';
+// prettier-ignore
+export const BackupDestinationModelSchema = z.object({
+    id: z.number().int(),
+    userId: z.number().int(),
+    path: z.string(),
+    isActive: z.boolean(),
+    createdAt: z.date(),
+    user: z.unknown()
+}).strict();
+
+export type BackupDestinationPureType = z.infer<typeof BackupDestinationModelSchema>;

packages/db/shared/schemas/variants/pure/Claim.pure.ts

@@ -0,0 +1,32 @@
+import * as z from 'zod';
+import { MissingTeethStatusSchema } from '../../enums/MissingTeethStatus.schema';
+import { ClaimStatusSchema } from '../../enums/ClaimStatus.schema';
+// prettier-ignore
+export const ClaimModelSchema = z.object({
+    id: z.number().int(),
+    patientId: z.number().int(),
+    appointmentId: z.number().int(),
+    userId: z.number().int(),
+    staffId: z.number().int(),
+    patientName: z.string(),
+    memberId: z.string(),
+    dateOfBirth: z.date(),
+    remarks: z.string(),
+    missingTeethStatus: MissingTeethStatusSchema,
+    missingTeeth: z.unknown().nullable(),
+    serviceDate: z.date(),
+    insuranceProvider: z.string(),
+    createdAt: z.date(),
+    updatedAt: z.date(),
+    status: ClaimStatusSchema,
+    claimNumber: z.string().nullable(),
+    patient: z.unknown(),
+    appointment: z.unknown(),
+    user: z.unknown().nullable(),
+    staff: z.unknown().nullable(),
+    serviceLines: z.array(z.unknown()),
+    claimFiles: z.array(z.unknown()),
+    payment: z.unknown().nullable()
+}).strict();
+
+export type ClaimPureType = z.infer<typeof ClaimModelSchema>;

packages/db/shared/schemas/variants/pure/ClaimFile.pure.ts

@@ -0,0 +1,11 @@
+import * as z from 'zod';
+// prettier-ignore
+export const ClaimFileModelSchema = z.object({
+    id: z.number().int(),
+    claimId: z.number().int(),
+    filename: z.string(),
+    mimeType: z.string(),
+    claim: z.unknown()
+}).strict();
+
+export type ClaimFilePureType = z.infer<typeof ClaimFileModelSchema>;

packages/db/shared/schemas/variants/pure/CloudFile.pure.ts

@@ -0,0 +1,19 @@
+import * as z from 'zod';
+// prettier-ignore
+export const CloudFileModelSchema = z.object({
+    id: z.number().int(),
+    userId: z.number().int(),
+    name: z.string(),
+    mimeType: z.string().nullable(),
+    fileSize: z.bigint(),
+    folderId: z.number().int().nullable(),
+    isComplete: z.boolean(),
+    totalChunks: z.number().int().nullable(),
+    createdAt: z.date(),
+    updatedAt: z.date(),
+    user: z.unknown(),
+    folder: z.unknown().nullable(),
+    chunks: z.array(z.unknown())
+}).strict();
+
+export type CloudFilePureType = z.infer<typeof CloudFileModelSchema>;

packages/db/shared/schemas/variants/pure/CloudFileChunk.pure.ts

@@ -0,0 +1,12 @@
+import * as z from 'zod';
+// prettier-ignore
+export const CloudFileChunkModelSchema = z.object({
+    id: z.number().int(),
+    fileId: z.number().int(),
+    seq: z.number().int(),
+    data: z.instanceof(Uint8Array),
+    createdAt: z.date(),
+    file: z.unknown()
+}).strict();
+
+export type CloudFileChunkPureType = z.infer<typeof CloudFileChunkModelSchema>;

packages/db/shared/schemas/variants/pure/CloudFolder.pure.ts

@@ -0,0 +1,16 @@
+import * as z from 'zod';
+// prettier-ignore
+export const CloudFolderModelSchema = z.object({
+    id: z.number().int(),
+    userId: z.number().int(),
+    name: z.string(),
+    parentId: z.number().int().nullable(),
+    parent: z.unknown().nullable(),
+    children: z.array(z.unknown()),
+    user: z.unknown(),
+    files: z.array(z.unknown()),
+    createdAt: z.date(),
+    updatedAt: z.date()
+}).strict();
+
+export type CloudFolderPureType = z.infer<typeof CloudFolderModelSchema>;

packages/db/shared/schemas/variants/pure/Communication.pure.ts

@@ -0,0 +1,21 @@
+import * as z from 'zod';
+import { CommunicationChannelSchema } from '../../enums/CommunicationChannel.schema';
+import { CommunicationDirectionSchema } from '../../enums/CommunicationDirection.schema';
+import { CommunicationStatusSchema } from '../../enums/CommunicationStatus.schema';
+// prettier-ignore
+export const CommunicationModelSchema = z.object({
+    id: z.number().int(),
+    patientId: z.number().int(),
+    userId: z.number().int().nullable(),
+    channel: CommunicationChannelSchema,
+    direction: CommunicationDirectionSchema,
+    status: CommunicationStatusSchema,
+    body: z.string().nullable(),
+    callDuration: z.number().int().nullable(),
+    twilioSid: z.string().nullable(),
+    createdAt: z.date(),
+    patient: z.unknown(),
+    user: z.unknown().nullable()
+}).strict();
+
+export type CommunicationPureType = z.infer<typeof CommunicationModelSchema>;

packages/db/shared/schemas/variants/pure/DatabaseBackup.pure.ts

@@ -0,0 +1,10 @@
+import * as z from 'zod';
+// prettier-ignore
+export const DatabaseBackupModelSchema = z.object({
+    id: z.number().int(),
+    userId: z.number().int(),
+    createdAt: z.date(),
+    user: z.unknown()
+}).strict();
+
+export type DatabaseBackupPureType = z.infer<typeof DatabaseBackupModelSchema>;

packages/db/shared/schemas/variants/pure/InsuranceCredential.pure.ts

@@ -0,0 +1,12 @@
+import * as z from 'zod';
+// prettier-ignore
+export const InsuranceCredentialModelSchema = z.object({
+    id: z.number().int(),
+    userId: z.number().int(),
+    siteKey: z.string(),
+    username: z.string(),
+    password: z.string(),
+    user: z.unknown()
+}).strict();
+
+export type InsuranceCredentialPureType = z.infer<typeof InsuranceCredentialModelSchema>;

packages/db/shared/schemas/variants/pure/Notification.pure.ts

@@ -0,0 +1,14 @@
+import * as z from 'zod';
+import { NotificationTypesSchema } from '../../enums/NotificationTypes.schema';
+// prettier-ignore
+export const NotificationModelSchema = z.object({
+    id: z.number().int(),
+    userId: z.number().int(),
+    type: NotificationTypesSchema,
+    message: z.string(),
+    createdAt: z.date(),
+    read: z.boolean(),
+    user: z.unknown()
+}).strict();
+
+export type NotificationPureType = z.infer<typeof NotificationModelSchema>;

packages/db/shared/schemas/variants/pure/NpiProvider.pure.ts

@@ -0,0 +1,12 @@
+import * as z from 'zod';
+// prettier-ignore
+export const NpiProviderModelSchema = z.object({
+    id: z.number().int(),
+    userId: z.number().int(),
+    npiNumber: z.string(),
+    providerName: z.string(),
+    createdAt: z.date(),
+    user: z.unknown()
+}).strict();
+
+export type NpiProviderPureType = z.infer<typeof NpiProviderModelSchema>;

packages/db/shared/schemas/variants/pure/Patient.pure.ts

@@ -0,0 +1,34 @@
+import * as z from 'zod';
+import { PatientStatusSchema } from '../../enums/PatientStatus.schema';
+// prettier-ignore
+export const PatientModelSchema = z.object({
+    id: z.number().int(),
+    firstName: z.string(),
+    lastName: z.string(),
+    dateOfBirth: z.date(),
+    gender: z.string(),
+    phone: z.string(),
+    email: z.string().nullable(),
+    address: z.string().nullable(),
+    city: z.string().nullable(),
+    zipCode: z.string().nullable(),
+    insuranceProvider: z.string().nullable(),
+    insuranceId: z.string().nullable(),
+    groupNumber: z.string().nullable(),
+    policyHolder: z.string().nullable(),
+    allergies: z.string().nullable(),
+    medicalConditions: z.string().nullable(),
+    status: PatientStatusSchema,
+    userId: z.number().int(),
+    createdAt: z.date(),
+    user: z.unknown(),
+    appointments: z.array(z.unknown()),
+    procedures: z.array(z.unknown()),
+    claims: z.array(z.unknown()),
+    groups: z.array(z.unknown()),
+    payment: z.array(z.unknown()),
+    communications: z.array(z.unknown()),
+    documents: z.array(z.unknown())
+}).strict();
+
+export type PatientPureType = z.infer<typeof PatientModelSchema>;

packages/db/shared/schemas/variants/pure/PatientDocument.pure.ts

@@ -0,0 +1,16 @@
+import * as z from 'zod';
+// prettier-ignore
+export const PatientDocumentModelSchema = z.object({
+    id: z.number().int(),
+    patientId: z.number().int(),
+    filename: z.string(),
+    originalName: z.string(),
+    mimeType: z.string(),
+    fileSize: z.bigint(),
+    filePath: z.string(),
+    uploadedAt: z.date(),
+    updatedAt: z.date(),
+    patient: z.unknown()
+}).strict();
+
+export type PatientDocumentPureType = z.infer<typeof PatientDocumentModelSchema>;

packages/db/shared/schemas/variants/pure/Payment.pure.ts

@@ -0,0 +1,26 @@
+import * as z from 'zod';
+import { PaymentStatusSchema } from '../../enums/PaymentStatus.schema';
+// prettier-ignore
+export const PaymentModelSchema = z.object({
+    id: z.number().int(),
+    claimId: z.number().int().nullable(),
+    patientId: z.number().int(),
+    userId: z.number().int(),
+    updatedById: z.number().int().nullable(),
+    totalBilled: z.number(),
+    totalPaid: z.number(),
+    totalAdjusted: z.number(),
+    totalDue: z.number(),
+    status: PaymentStatusSchema,
+    notes: z.string().nullable(),
+    icn: z.string().nullable(),
+    createdAt: z.date(),
+    updatedAt: z.date(),
+    claim: z.unknown().nullable(),
+    patient: z.unknown(),
+    updatedBy: z.unknown().nullable(),
+    serviceLineTransactions: z.array(z.unknown()),
+    serviceLines: z.array(z.unknown())
+}).strict();
+
+export type PaymentPureType = z.infer<typeof PaymentModelSchema>;

packages/db/shared/schemas/variants/pure/PdfFile.pure.ts

@@ -0,0 +1,12 @@
+import * as z from 'zod';
+// prettier-ignore
+export const PdfFileModelSchema = z.object({
+    id: z.number().int(),
+    filename: z.string(),
+    pdfData: z.instanceof(Uint8Array),
+    uploadedAt: z.date(),
+    groupId: z.number().int(),
+    group: z.unknown()
+}).strict();
+
+export type PdfFilePureType = z.infer<typeof PdfFileModelSchema>;

packages/db/shared/schemas/variants/pure/PdfGroup.pure.ts

@@ -0,0 +1,14 @@
+import * as z from 'zod';
+import { PdfTitleKeySchema } from '../../enums/PdfTitleKey.schema';
+// prettier-ignore
+export const PdfGroupModelSchema = z.object({
+    id: z.number().int(),
+    title: z.string(),
+    titleKey: PdfTitleKeySchema,
+    createdAt: z.date(),
+    patientId: z.number().int(),
+    patient: z.unknown(),
+    pdfs: z.array(z.unknown())
+}).strict();
+
+export type PdfGroupPureType = z.infer<typeof PdfGroupModelSchema>;

packages/db/shared/schemas/variants/pure/ServiceLine.pure.ts

@@ -0,0 +1,24 @@
+import * as z from 'zod';
+import { ServiceLineStatusSchema } from '../../enums/ServiceLineStatus.schema';
+// prettier-ignore
+export const ServiceLineModelSchema = z.object({
+    id: z.number().int(),
+    claimId: z.number().int().nullable(),
+    paymentId: z.number().int().nullable(),
+    procedureCode: z.string(),
+    procedureDate: z.date(),
+    quad: z.string().nullable(),
+    arch: z.string().nullable(),
+    toothNumber: z.string().nullable(),
+    toothSurface: z.string().nullable(),
+    totalBilled: z.number(),
+    totalPaid: z.number(),
+    totalAdjusted: z.number(),
+    totalDue: z.number(),
+    status: ServiceLineStatusSchema,
+    claim: z.unknown().nullable(),
+    payment: z.unknown().nullable(),
+    serviceLineTransactions: z.array(z.unknown())
+}).strict();
+
+export type ServiceLinePureType = z.infer<typeof ServiceLineModelSchema>;

packages/db/shared/schemas/variants/pure/ServiceLineTransaction.pure.ts

@@ -0,0 +1,20 @@
+import * as z from 'zod';
+import { PaymentMethodSchema } from '../../enums/PaymentMethod.schema';
+// prettier-ignore
+export const ServiceLineTransactionModelSchema = z.object({
+    id: z.number().int(),
+    paymentId: z.number().int(),
+    serviceLineId: z.number().int(),
+    transactionId: z.string().nullable(),
+    paidAmount: z.number(),
+    adjustedAmount: z.number(),
+    method: PaymentMethodSchema,
+    receivedDate: z.date(),
+    payerName: z.string().nullable(),
+    notes: z.string().nullable(),
+    createdAt: z.date(),
+    payment: z.unknown(),
+    serviceLine: z.unknown()
+}).strict();
+
+export type ServiceLineTransactionPureType = z.infer<typeof ServiceLineTransactionModelSchema>;

packages/db/shared/schemas/variants/pure/Staff.pure.ts

@@ -0,0 +1,16 @@
+import * as z from 'zod';
+// prettier-ignore
+export const StaffModelSchema = z.object({
+    id: z.number().int(),
+    userId: z.number().int(),
+    name: z.string(),
+    email: z.string().nullable(),
+    role: z.string(),
+    phone: z.string().nullable(),
+    createdAt: z.date(),
+    user: z.unknown().nullable(),
+    appointments: z.array(z.unknown()),
+    claims: z.array(z.unknown())
+}).strict();
+
+export type StaffPureType = z.infer<typeof StaffModelSchema>;

packages/db/shared/schemas/variants/pure/User.pure.ts

@@ -0,0 +1,22 @@
+import * as z from 'zod';
+// prettier-ignore
+export const UserModelSchema = z.object({
+    id: z.number().int(),
+    username: z.string(),
+    password: z.string(),
+    patients: z.array(z.unknown()),
+    appointments: z.array(z.unknown()),
+    staff: z.array(z.unknown()),
+    npiProviders: z.array(z.unknown()),
+    claims: z.array(z.unknown()),
+    insuranceCredentials: z.array(z.unknown()),
+    updatedPayments: z.array(z.unknown()),
+    backups: z.array(z.unknown()),
+    backupDestinations: z.array(z.unknown()),
+    notifications: z.array(z.unknown()),
+    cloudFolders: z.array(z.unknown()),
+    cloudFiles: z.array(z.unknown()),
+    communications: z.array(z.unknown())
+}).strict();
+
+export type UserPureType = z.infer<typeof UserModelSchema>;

packages/db/shared/schemas/variants/pure/index.ts

@@ -0,0 +1,27 @@
+/**
+ * Pure Variant Schemas
+ * Auto-generated - do not edit manually
+ */
+
+export { UserModelSchema } from './User.pure';
+export { PatientModelSchema } from './Patient.pure';
+export { AppointmentModelSchema } from './Appointment.pure';
+export { StaffModelSchema } from './Staff.pure';
+export { NpiProviderModelSchema } from './NpiProvider.pure';
+export { AppointmentProcedureModelSchema } from './AppointmentProcedure.pure';
+export { ClaimModelSchema } from './Claim.pure';
+export { ServiceLineModelSchema } from './ServiceLine.pure';
+export { ClaimFileModelSchema } from './ClaimFile.pure';
+export { InsuranceCredentialModelSchema } from './InsuranceCredential.pure';
+export { PdfGroupModelSchema } from './PdfGroup.pure';
+export { PdfFileModelSchema } from './PdfFile.pure';
+export { PaymentModelSchema } from './Payment.pure';
+export { ServiceLineTransactionModelSchema } from './ServiceLineTransaction.pure';
+export { DatabaseBackupModelSchema } from './DatabaseBackup.pure';
+export { BackupDestinationModelSchema } from './BackupDestination.pure';
+export { NotificationModelSchema } from './Notification.pure';
+export { CloudFolderModelSchema } from './CloudFolder.pure';
+export { CloudFileModelSchema } from './CloudFile.pure';
+export { CloudFileChunkModelSchema } from './CloudFileChunk.pure';
+export { CommunicationModelSchema } from './Communication.pure';
+export { PatientDocumentModelSchema } from './PatientDocument.pure';

packages/db/shared/schemas/variants/result/Appointment.result.ts

@@ -0,0 +1,26 @@
+import * as z from 'zod';
+import { PatientStatusSchema } from '../../enums/PatientStatus.schema';
+// prettier-ignore
+export const AppointmentResultSchema = z.object({
+    id: z.number().int(),
+    patientId: z.number().int(),
+    userId: z.number().int(),
+    staffId: z.number().int(),
+    title: z.string(),
+    date: z.date(),
+    startTime: z.string(),
+    endTime: z.string(),
+    type: z.string(),
+    notes: z.string().nullable(),
+    procedureCodeNotes: z.string().nullable(),
+    status: z.string(),
+    createdAt: z.date(),
+    eligibilityStatus: PatientStatusSchema,
+    patient: z.unknown(),
+    user: z.unknown(),
+    staff: z.unknown().nullable(),
+    procedures: z.array(z.unknown()),
+    claims: z.array(z.unknown())
+}).strict();
+
+export type AppointmentResultType = z.infer<typeof AppointmentResultSchema>;

packages/db/shared/schemas/variants/result/AppointmentProcedure.result.ts

@@ -0,0 +1,22 @@
+import * as z from 'zod';
+import { ProcedureSourceSchema } from '../../enums/ProcedureSource.schema';
+// prettier-ignore
+export const AppointmentProcedureResultSchema = z.object({
+    id: z.number().int(),
+    appointmentId: z.number().int(),
+    patientId: z.number().int(),
+    procedureCode: z.string(),
+    procedureLabel: z.string().nullable(),
+    fee: z.number().nullable(),
+    category: z.string().nullable(),
+    toothNumber: z.string().nullable(),
+    toothSurface: z.string().nullable(),
+    oralCavityArea: z.string().nullable(),
+    source: ProcedureSourceSchema,
+    comboKey: z.string().nullable(),
+    createdAt: z.date(),
+    appointment: z.unknown(),
+    patient: z.unknown()
+}).strict();
+
+export type AppointmentProcedureResultType = z.infer<typeof AppointmentProcedureResultSchema>;

packages/db/shared/schemas/variants/result/BackupDestination.result.ts

@@ -0,0 +1,12 @@
+import * as z from 'zod';
+// prettier-ignore
+export const BackupDestinationResultSchema = z.object({
+    id: z.number().int(),
+    userId: z.number().int(),
+    path: z.string(),
+    isActive: z.boolean(),
+    createdAt: z.date(),
+    user: z.unknown()
+}).strict();
+
+export type BackupDestinationResultType = z.infer<typeof BackupDestinationResultSchema>;

packages/db/shared/schemas/variants/result/Claim.result.ts

@@ -0,0 +1,32 @@
+import * as z from 'zod';
+import { MissingTeethStatusSchema } from '../../enums/MissingTeethStatus.schema';
+import { ClaimStatusSchema } from '../../enums/ClaimStatus.schema';
+// prettier-ignore
+export const ClaimResultSchema = z.object({
+    id: z.number().int(),
+    patientId: z.number().int(),
+    appointmentId: z.number().int(),
+    userId: z.number().int(),
+    staffId: z.number().int(),
+    patientName: z.string(),
+    memberId: z.string(),
+    dateOfBirth: z.date(),
+    remarks: z.string(),
+    missingTeethStatus: MissingTeethStatusSchema,
+    missingTeeth: z.unknown().nullable(),
+    serviceDate: z.date(),
+    insuranceProvider: z.string(),
+    createdAt: z.date(),
+    updatedAt: z.date(),
+    status: ClaimStatusSchema,
+    claimNumber: z.string().nullable(),
+    patient: z.unknown(),
+    appointment: z.unknown(),
+    user: z.unknown().nullable(),
+    staff: z.unknown().nullable(),
+    serviceLines: z.array(z.unknown()),
+    claimFiles: z.array(z.unknown()),
+    payment: z.unknown().nullable()
+}).strict();
+
+export type ClaimResultType = z.infer<typeof ClaimResultSchema>;

packages/db/shared/schemas/variants/result/ClaimFile.result.ts

@@ -0,0 +1,11 @@
+import * as z from 'zod';
+// prettier-ignore
+export const ClaimFileResultSchema = z.object({
+    id: z.number().int(),
+    claimId: z.number().int(),
+    filename: z.string(),
+    mimeType: z.string(),
+    claim: z.unknown()
+}).strict();
+
+export type ClaimFileResultType = z.infer<typeof ClaimFileResultSchema>;

packages/db/shared/schemas/variants/result/CloudFile.result.ts

@@ -0,0 +1,19 @@
+import * as z from 'zod';
+// prettier-ignore
+export const CloudFileResultSchema = z.object({
+    id: z.number().int(),
+    userId: z.number().int(),
+    name: z.string(),
+    mimeType: z.string().nullable(),
+    fileSize: z.bigint(),
+    folderId: z.number().int().nullable(),
+    isComplete: z.boolean(),
+    totalChunks: z.number().int().nullable(),
+    createdAt: z.date(),
+    updatedAt: z.date(),
+    user: z.unknown(),
+    folder: z.unknown().nullable(),
+    chunks: z.array(z.unknown())
+}).strict();
+
+export type CloudFileResultType = z.infer<typeof CloudFileResultSchema>;

packages/db/shared/schemas/variants/result/CloudFileChunk.result.ts

@@ -0,0 +1,12 @@
+import * as z from 'zod';
+// prettier-ignore
+export const CloudFileChunkResultSchema = z.object({
+    id: z.number().int(),
+    fileId: z.number().int(),
+    seq: z.number().int(),
+    data: z.instanceof(Uint8Array),
+    createdAt: z.date(),
+    file: z.unknown()
+}).strict();
+
+export type CloudFileChunkResultType = z.infer<typeof CloudFileChunkResultSchema>;

packages/db/shared/schemas/variants/result/CloudFolder.result.ts

@@ -0,0 +1,16 @@
+import * as z from 'zod';
+// prettier-ignore
+export const CloudFolderResultSchema = z.object({
+    id: z.number().int(),
+    userId: z.number().int(),
+    name: z.string(),
+    parentId: z.number().int().nullable(),
+    parent: z.unknown().nullable(),
+    children: z.array(z.unknown()),
+    user: z.unknown(),
+    files: z.array(z.unknown()),
+    createdAt: z.date(),
+    updatedAt: z.date()
+}).strict();
+
+export type CloudFolderResultType = z.infer<typeof CloudFolderResultSchema>;

packages/db/shared/schemas/variants/result/Communication.result.ts

@@ -0,0 +1,21 @@
+import * as z from 'zod';
+import { CommunicationChannelSchema } from '../../enums/CommunicationChannel.schema';
+import { CommunicationDirectionSchema } from '../../enums/CommunicationDirection.schema';
+import { CommunicationStatusSchema } from '../../enums/CommunicationStatus.schema';
+// prettier-ignore
+export const CommunicationResultSchema = z.object({
+    id: z.number().int(),
+    patientId: z.number().int(),
+    userId: z.number().int().nullable(),
+    channel: CommunicationChannelSchema,
+    direction: CommunicationDirectionSchema,
+    status: CommunicationStatusSchema,
+    body: z.string().nullable(),
+    callDuration: z.number().int().nullable(),
+    twilioSid: z.string().nullable(),
+    createdAt: z.date(),
+    patient: z.unknown(),
+    user: z.unknown().nullable()
+}).strict();
+
+export type CommunicationResultType = z.infer<typeof CommunicationResultSchema>;

packages/db/shared/schemas/variants/result/DatabaseBackup.result.ts

@@ -0,0 +1,10 @@
+import * as z from 'zod';
+// prettier-ignore
+export const DatabaseBackupResultSchema = z.object({
+    id: z.number().int(),
+    userId: z.number().int(),
+    createdAt: z.date(),
+    user: z.unknown()
+}).strict();
+
+export type DatabaseBackupResultType = z.infer<typeof DatabaseBackupResultSchema>;

packages/db/shared/schemas/variants/result/InsuranceCredential.result.ts

@@ -0,0 +1,12 @@
+import * as z from 'zod';
+// prettier-ignore
+export const InsuranceCredentialResultSchema = z.object({
+    id: z.number().int(),
+    userId: z.number().int(),
+    siteKey: z.string(),
+    username: z.string(),
+    password: z.string(),
+    user: z.unknown()
+}).strict();
+
+export type InsuranceCredentialResultType = z.infer<typeof InsuranceCredentialResultSchema>;

packages/db/shared/schemas/variants/result/Notification.result.ts

@@ -0,0 +1,14 @@
+import * as z from 'zod';
+import { NotificationTypesSchema } from '../../enums/NotificationTypes.schema';
+// prettier-ignore
+export const NotificationResultSchema = z.object({
+    id: z.number().int(),
+    userId: z.number().int(),
+    type: NotificationTypesSchema,
+    message: z.string(),
+    createdAt: z.date(),
+    read: z.boolean(),
+    user: z.unknown()
+}).strict();
+
+export type NotificationResultType = z.infer<typeof NotificationResultSchema>;

packages/db/shared/schemas/variants/result/NpiProvider.result.ts

@@ -0,0 +1,12 @@
+import * as z from 'zod';
+// prettier-ignore
+export const NpiProviderResultSchema = z.object({
+    id: z.number().int(),
+    userId: z.number().int(),
+    npiNumber: z.string(),
+    providerName: z.string(),
+    createdAt: z.date(),
+    user: z.unknown()
+}).strict();
+
+export type NpiProviderResultType = z.infer<typeof NpiProviderResultSchema>;

packages/db/shared/schemas/variants/result/Patient.result.ts

@@ -0,0 +1,34 @@
+import * as z from 'zod';
+import { PatientStatusSchema } from '../../enums/PatientStatus.schema';
+// prettier-ignore
+export const PatientResultSchema = z.object({
+    id: z.number().int(),
+    firstName: z.string(),
+    lastName: z.string(),
+    dateOfBirth: z.date(),
+    gender: z.string(),
+    phone: z.string(),
+    email: z.string().nullable(),
+    address: z.string().nullable(),
+    city: z.string().nullable(),
+    zipCode: z.string().nullable(),
+    insuranceProvider: z.string().nullable(),
+    insuranceId: z.string().nullable(),
+    groupNumber: z.string().nullable(),
+    policyHolder: z.string().nullable(),
+    allergies: z.string().nullable(),
+    medicalConditions: z.string().nullable(),
+    status: PatientStatusSchema,
+    userId: z.number().int(),
+    createdAt: z.date(),
+    user: z.unknown(),
+    appointments: z.array(z.unknown()),
+    procedures: z.array(z.unknown()),
+    claims: z.array(z.unknown()),
+    groups: z.array(z.unknown()),
+    payment: z.array(z.unknown()),
+    communications: z.array(z.unknown()),
+    documents: z.array(z.unknown())
+}).strict();
+
+export type PatientResultType = z.infer<typeof PatientResultSchema>;

packages/db/shared/schemas/variants/result/PatientDocument.result.ts

@@ -0,0 +1,16 @@
+import * as z from 'zod';
+// prettier-ignore
+export const PatientDocumentResultSchema = z.object({
+    id: z.number().int(),
+    patientId: z.number().int(),
+    filename: z.string(),
+    originalName: z.string(),
+    mimeType: z.string(),
+    fileSize: z.bigint(),
+    filePath: z.string(),
+    uploadedAt: z.date(),
+    updatedAt: z.date(),
+    patient: z.unknown()
+}).strict();
+
+export type PatientDocumentResultType = z.infer<typeof PatientDocumentResultSchema>;

packages/db/shared/schemas/variants/result/Payment.result.ts

@@ -0,0 +1,26 @@
+import * as z from 'zod';
+import { PaymentStatusSchema } from '../../enums/PaymentStatus.schema';
+// prettier-ignore
+export const PaymentResultSchema = z.object({
+    id: z.number().int(),
+    claimId: z.number().int().nullable(),
+    patientId: z.number().int(),
+    userId: z.number().int(),
+    updatedById: z.number().int().nullable(),
+    totalBilled: z.number(),
+    totalPaid: z.number(),
+    totalAdjusted: z.number(),
+    totalDue: z.number(),
+    status: PaymentStatusSchema,
+    notes: z.string().nullable(),
+    icn: z.string().nullable(),
+    createdAt: z.date(),
+    updatedAt: z.date(),
+    claim: z.unknown().nullable(),
+    patient: z.unknown(),
+    updatedBy: z.unknown().nullable(),
+    serviceLineTransactions: z.array(z.unknown()),
+    serviceLines: z.array(z.unknown())
+}).strict();
+
+export type PaymentResultType = z.infer<typeof PaymentResultSchema>;

packages/db/shared/schemas/variants/result/PdfFile.result.ts

@@ -0,0 +1,12 @@
+import * as z from 'zod';
+// prettier-ignore
+export const PdfFileResultSchema = z.object({
+    id: z.number().int(),
+    filename: z.string(),
+    pdfData: z.instanceof(Uint8Array),
+    uploadedAt: z.date(),
+    groupId: z.number().int(),
+    group: z.unknown()
+}).strict();
+
+export type PdfFileResultType = z.infer<typeof PdfFileResultSchema>;

packages/db/shared/schemas/variants/result/PdfGroup.result.ts

@@ -0,0 +1,14 @@
+import * as z from 'zod';
+import { PdfTitleKeySchema } from '../../enums/PdfTitleKey.schema';
+// prettier-ignore
+export const PdfGroupResultSchema = z.object({
+    id: z.number().int(),
+    title: z.string(),
+    titleKey: PdfTitleKeySchema,
+    createdAt: z.date(),
+    patientId: z.number().int(),
+    patient: z.unknown(),
+    pdfs: z.array(z.unknown())
+}).strict();
+
+export type PdfGroupResultType = z.infer<typeof PdfGroupResultSchema>;

packages/db/shared/schemas/variants/result/ServiceLine.result.ts

@@ -0,0 +1,24 @@
+import * as z from 'zod';
+import { ServiceLineStatusSchema } from '../../enums/ServiceLineStatus.schema';
+// prettier-ignore
+export const ServiceLineResultSchema = z.object({
+    id: z.number().int(),
+    claimId: z.number().int().nullable(),
+    paymentId: z.number().int().nullable(),
+    procedureCode: z.string(),
+    procedureDate: z.date(),
+    quad: z.string().nullable(),
+    arch: z.string().nullable(),
+    toothNumber: z.string().nullable(),
+    toothSurface: z.string().nullable(),
+    totalBilled: z.number(),
+    totalPaid: z.number(),
+    totalAdjusted: z.number(),
+    totalDue: z.number(),
+    status: ServiceLineStatusSchema,
+    claim: z.unknown().nullable(),
+    payment: z.unknown().nullable(),
+    serviceLineTransactions: z.array(z.unknown())
+}).strict();
+
+export type ServiceLineResultType = z.infer<typeof ServiceLineResultSchema>;

packages/db/shared/schemas/variants/result/ServiceLineTransaction.result.ts

@@ -0,0 +1,20 @@
+import * as z from 'zod';
+import { PaymentMethodSchema } from '../../enums/PaymentMethod.schema';
+// prettier-ignore
+export const ServiceLineTransactionResultSchema = z.object({
+    id: z.number().int(),
+    paymentId: z.number().int(),
+    serviceLineId: z.number().int(),
+    transactionId: z.string().nullable(),
+    paidAmount: z.number(),
+    adjustedAmount: z.number(),
+    method: PaymentMethodSchema,
+    receivedDate: z.date(),
+    payerName: z.string().nullable(),
+    notes: z.string().nullable(),
+    createdAt: z.date(),
+    payment: z.unknown(),
+    serviceLine: z.unknown()
+}).strict();
+
+export type ServiceLineTransactionResultType = z.infer<typeof ServiceLineTransactionResultSchema>;

packages/db/shared/schemas/variants/result/Staff.result.ts

@@ -0,0 +1,16 @@
+import * as z from 'zod';
+// prettier-ignore
+export const StaffResultSchema = z.object({
+    id: z.number().int(),
+    userId: z.number().int(),
+    name: z.string(),
+    email: z.string().nullable(),
+    role: z.string(),
+    phone: z.string().nullable(),
+    createdAt: z.date(),
+    user: z.unknown().nullable(),
+    appointments: z.array(z.unknown()),
+    claims: z.array(z.unknown())
+}).strict();
+
+export type StaffResultType = z.infer<typeof StaffResultSchema>;

packages/db/shared/schemas/variants/result/User.result.ts

@@ -0,0 +1,22 @@
+import * as z from 'zod';
+// prettier-ignore
+export const UserResultSchema = z.object({
+    id: z.number().int(),
+    username: z.string(),
+    password: z.string(),
+    patients: z.array(z.unknown()),
+    appointments: z.array(z.unknown()),
+    staff: z.array(z.unknown()),
+    npiProviders: z.array(z.unknown()),
+    claims: z.array(z.unknown()),
+    insuranceCredentials: z.array(z.unknown()),
+    updatedPayments: z.array(z.unknown()),
+    backups: z.array(z.unknown()),
+    backupDestinations: z.array(z.unknown()),
+    notifications: z.array(z.unknown()),
+    cloudFolders: z.array(z.unknown()),
+    cloudFiles: z.array(z.unknown()),
+    communications: z.array(z.unknown())
+}).strict();
+
+export type UserResultType = z.infer<typeof UserResultSchema>;

packages/db/shared/schemas/variants/result/index.ts

@@ -0,0 +1,27 @@
+/**
+ * Result Variant Schemas
+ * Auto-generated - do not edit manually
+ */
+
+export { UserResultSchema } from './User.result';
+export { PatientResultSchema } from './Patient.result';
+export { AppointmentResultSchema } from './Appointment.result';
+export { StaffResultSchema } from './Staff.result';
+export { NpiProviderResultSchema } from './NpiProvider.result';
+export { AppointmentProcedureResultSchema } from './AppointmentProcedure.result';
+export { ClaimResultSchema } from './Claim.result';
+export { ServiceLineResultSchema } from './ServiceLine.result';
+export { ClaimFileResultSchema } from './ClaimFile.result';
+export { InsuranceCredentialResultSchema } from './InsuranceCredential.result';
+export { PdfGroupResultSchema } from './PdfGroup.result';
+export { PdfFileResultSchema } from './PdfFile.result';
+export { PaymentResultSchema } from './Payment.result';
+export { ServiceLineTransactionResultSchema } from './ServiceLineTransaction.result';
+export { DatabaseBackupResultSchema } from './DatabaseBackup.result';
+export { BackupDestinationResultSchema } from './BackupDestination.result';
+export { NotificationResultSchema } from './Notification.result';
+export { CloudFolderResultSchema } from './CloudFolder.result';
+export { CloudFileResultSchema } from './CloudFile.result';
+export { CloudFileChunkResultSchema } from './CloudFileChunk.result';
+export { CommunicationResultSchema } from './Communication.result';
+export { PatientDocumentResultSchema } from './PatientDocument.result';