initial commit

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';