Gitead/DentalManagementMH06
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: AI chat system with LangGraph, multi-step patient flows, and appointment rescheduling

Browse Source 
- Add floating chat window Hand-off to AI toggle (per-patient) and after-hours AI toggle (global)
- Add LangGraph-powered appointment reminder flow: AI introduces itself, classifies YES/NO, handles confirmation with appointment date/time
- Add multi-step rescheduling flow: ASAP vs next week, tomorrow offer, Mon/Tue/Wed picker, morning/afternoon time slot — automatically updates appointment in DB
- Add new patient / after-hours flow: new vs existing patient, dental insurance check, MassHealth Selenium eligibility check (auto-uses saved member ID + DOB for existing patients), self-pay fallback
- Add AI Chat Settings page (Settings → Advanced) with editable greeting templates and LangGraph flow diagrams for both reminder and new-patient flows
- Add Schedule a New Patient template option in chat window, starts new-patient conversation flow
- Add GET/PUT endpoints for AI handoff, after-hours handoff, and AI chat templates
- Add multilingual support (7 languages) across all AI reply nodes with LLM generation and hardcoded fallbacks
- Add pending reschedule in-memory store and conversation stage tracking across all flows

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
This commit is contained in:
Gitead
2026-05-07 23:21:06 -04:00
parent 86dd685342
commit 9908e5b5fd
317 changed files with 6533 additions and 274 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
packages/db/shared/schemas/aggregateInsuranceContact.schema.ts Normal file
View File

@@ -0,0 +1,14 @@
import type { Prisma } from '../../generated/prisma';
import * as z from 'zod';
import { InsuranceContactOrderByWithRelationInputObjectSchema as InsuranceContactOrderByWithRelationInputObjectSchema } from './objects/InsuranceContactOrderByWithRelationInput.schema';
import { InsuranceContactWhereInputObjectSchema as InsuranceContactWhereInputObjectSchema } from './objects/InsuranceContactWhereInput.schema';
import { InsuranceContactWhereUniqueInputObjectSchema as InsuranceContactWhereUniqueInputObjectSchema } from './objects/InsuranceContactWhereUniqueInput.schema';
import { InsuranceContactCountAggregateInputObjectSchema as InsuranceContactCountAggregateInputObjectSchema } from './objects/InsuranceContactCountAggregateInput.schema';
import { InsuranceContactMinAggregateInputObjectSchema as InsuranceContactMinAggregateInputObjectSchema } from './objects/InsuranceContactMinAggregateInput.schema';
import { InsuranceContactMaxAggregateInputObjectSchema as InsuranceContactMaxAggregateInputObjectSchema } from './objects/InsuranceContactMaxAggregateInput.schema';
import { InsuranceContactAvgAggregateInputObjectSchema as InsuranceContactAvgAggregateInputObjectSchema } from './objects/InsuranceContactAvgAggregateInput.schema';
import { InsuranceContactSumAggregateInputObjectSchema as InsuranceContactSumAggregateInputObjectSchema } from './objects/InsuranceContactSumAggregateInput.schema';
export const InsuranceContactAggregateSchema: z.ZodType<Prisma.InsuranceContactAggregateArgs> = z.object({ orderBy: z.union([InsuranceContactOrderByWithRelationInputObjectSchema, InsuranceContactOrderByWithRelationInputObjectSchema.array()]).optional(), where: InsuranceContactWhereInputObjectSchema.optional(), cursor: InsuranceContactWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), _count: z.union([ z.literal(true), InsuranceContactCountAggregateInputObjectSchema ]).optional(), _min: InsuranceContactMinAggregateInputObjectSchema.optional(), _max: InsuranceContactMaxAggregateInputObjectSchema.optional(), _avg: InsuranceContactAvgAggregateInputObjectSchema.optional(), _sum: InsuranceContactSumAggregateInputObjectSchema.optional() }).strict() as unknown as z.ZodType<Prisma.InsuranceContactAggregateArgs>;
export const InsuranceContactAggregateZodSchema = z.object({ orderBy: z.union([InsuranceContactOrderByWithRelationInputObjectSchema, InsuranceContactOrderByWithRelationInputObjectSchema.array()]).optional(), where: InsuranceContactWhereInputObjectSchema.optional(), cursor: InsuranceContactWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), _count: z.union([ z.literal(true), InsuranceContactCountAggregateInputObjectSchema ]).optional(), _min: InsuranceContactMinAggregateInputObjectSchema.optional(), _max: InsuranceContactMaxAggregateInputObjectSchema.optional(), _avg: InsuranceContactAvgAggregateInputObjectSchema.optional(), _sum: InsuranceContactSumAggregateInputObjectSchema.optional() }).strict();

10
packages/db/shared/schemas/countInsuranceContact.schema.ts Normal file
View File

@@ -0,0 +1,10 @@
import type { Prisma } from '../../generated/prisma';
import * as z from 'zod';
import { InsuranceContactOrderByWithRelationInputObjectSchema as InsuranceContactOrderByWithRelationInputObjectSchema } from './objects/InsuranceContactOrderByWithRelationInput.schema';
import { InsuranceContactWhereInputObjectSchema as InsuranceContactWhereInputObjectSchema } from './objects/InsuranceContactWhereInput.schema';
import { InsuranceContactWhereUniqueInputObjectSchema as InsuranceContactWhereUniqueInputObjectSchema } from './objects/InsuranceContactWhereUniqueInput.schema';
import { InsuranceContactCountAggregateInputObjectSchema as InsuranceContactCountAggregateInputObjectSchema } from './objects/InsuranceContactCountAggregateInput.schema';
export const InsuranceContactCountSchema: z.ZodType<Prisma.InsuranceContactCountArgs> = z.object({ orderBy: z.union([InsuranceContactOrderByWithRelationInputObjectSchema, InsuranceContactOrderByWithRelationInputObjectSchema.array()]).optional(), where: InsuranceContactWhereInputObjectSchema.optional(), cursor: InsuranceContactWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), select: z.union([ z.literal(true), InsuranceContactCountAggregateInputObjectSchema ]).optional() }).strict() as unknown as z.ZodType<Prisma.InsuranceContactCountArgs>;
export const InsuranceContactCountZodSchema = z.object({ orderBy: z.union([InsuranceContactOrderByWithRelationInputObjectSchema, InsuranceContactOrderByWithRelationInputObjectSchema.array()]).optional(), where: InsuranceContactWhereInputObjectSchema.optional(), cursor: InsuranceContactWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), select: z.union([ z.literal(true), InsuranceContactCountAggregateInputObjectSchema ]).optional() }).strict();

8
packages/db/shared/schemas/createManyAndReturnInsuranceContact.schema.ts Normal file
View File

@@ -0,0 +1,8 @@
import type { Prisma } from '../../generated/prisma';
import * as z from 'zod';
import { InsuranceContactSelectObjectSchema as InsuranceContactSelectObjectSchema } from './objects/InsuranceContactSelect.schema';
import { InsuranceContactCreateManyInputObjectSchema as InsuranceContactCreateManyInputObjectSchema } from './objects/InsuranceContactCreateManyInput.schema';
export const InsuranceContactCreateManyAndReturnSchema: z.ZodType<Prisma.InsuranceContactCreateManyAndReturnArgs> = z.object({ select: InsuranceContactSelectObjectSchema.optional(), data: z.union([ InsuranceContactCreateManyInputObjectSchema, z.array(InsuranceContactCreateManyInputObjectSchema) ]), skipDuplicates: z.boolean().optional() }).strict() as unknown as z.ZodType<Prisma.InsuranceContactCreateManyAndReturnArgs>;
export const InsuranceContactCreateManyAndReturnZodSchema = z.object({ select: InsuranceContactSelectObjectSchema.optional(), data: z.union([ InsuranceContactCreateManyInputObjectSchema, z.array(InsuranceContactCreateManyInputObjectSchema) ]), skipDuplicates: z.boolean().optional() }).strict();

7
packages/db/shared/schemas/createManyInsuranceContact.schema.ts Normal file
View File

@@ -0,0 +1,7 @@
import type { Prisma } from '../../generated/prisma';
import * as z from 'zod';
import { InsuranceContactCreateManyInputObjectSchema as InsuranceContactCreateManyInputObjectSchema } from './objects/InsuranceContactCreateManyInput.schema';
export const InsuranceContactCreateManySchema: z.ZodType<Prisma.InsuranceContactCreateManyArgs> = z.object({ data: z.union([ InsuranceContactCreateManyInputObjectSchema, z.array(InsuranceContactCreateManyInputObjectSchema) ]), skipDuplicates: z.boolean().optional() }).strict() as unknown as z.ZodType<Prisma.InsuranceContactCreateManyArgs>;
export const InsuranceContactCreateManyZodSchema = z.object({ data: z.union([ InsuranceContactCreateManyInputObjectSchema, z.array(InsuranceContactCreateManyInputObjectSchema) ]), skipDuplicates: z.boolean().optional() }).strict();

10
packages/db/shared/schemas/createOneInsuranceContact.schema.ts Normal file
View File

@@ -0,0 +1,10 @@
import type { Prisma } from '../../generated/prisma';
import * as z from 'zod';
import { InsuranceContactSelectObjectSchema as InsuranceContactSelectObjectSchema } from './objects/InsuranceContactSelect.schema';
import { InsuranceContactIncludeObjectSchema as InsuranceContactIncludeObjectSchema } from './objects/InsuranceContactInclude.schema';
import { InsuranceContactCreateInputObjectSchema as InsuranceContactCreateInputObjectSchema } from './objects/InsuranceContactCreateInput.schema';
import { InsuranceContactUncheckedCreateInputObjectSchema as InsuranceContactUncheckedCreateInputObjectSchema } from './objects/InsuranceContactUncheckedCreateInput.schema';
export const InsuranceContactCreateOneSchema: z.ZodType<Prisma.InsuranceContactCreateArgs> = z.object({ select: InsuranceContactSelectObjectSchema.optional(), include: InsuranceContactIncludeObjectSchema.optional(), data: z.union([InsuranceContactCreateInputObjectSchema, InsuranceContactUncheckedCreateInputObjectSchema]) }).strict() as unknown as z.ZodType<Prisma.InsuranceContactCreateArgs>;
export const InsuranceContactCreateOneZodSchema = z.object({ select: InsuranceContactSelectObjectSchema.optional(), include: InsuranceContactIncludeObjectSchema.optional(), data: z.union([InsuranceContactCreateInputObjectSchema, InsuranceContactUncheckedCreateInputObjectSchema]) }).strict();

7
packages/db/shared/schemas/deleteManyInsuranceContact.schema.ts Normal file
View File

@@ -0,0 +1,7 @@
import type { Prisma } from '../../generated/prisma';
import * as z from 'zod';
import { InsuranceContactWhereInputObjectSchema as InsuranceContactWhereInputObjectSchema } from './objects/InsuranceContactWhereInput.schema';
export const InsuranceContactDeleteManySchema: z.ZodType<Prisma.InsuranceContactDeleteManyArgs> = z.object({ where: InsuranceContactWhereInputObjectSchema.optional() }).strict() as unknown as z.ZodType<Prisma.InsuranceContactDeleteManyArgs>;
export const InsuranceContactDeleteManyZodSchema = z.object({ where: InsuranceContactWhereInputObjectSchema.optional() }).strict();

9
packages/db/shared/schemas/deleteOneInsuranceContact.schema.ts Normal file
View File

@@ -0,0 +1,9 @@
import type { Prisma } from '../../generated/prisma';
import * as z from 'zod';
import { InsuranceContactSelectObjectSchema as InsuranceContactSelectObjectSchema } from './objects/InsuranceContactSelect.schema';
import { InsuranceContactIncludeObjectSchema as InsuranceContactIncludeObjectSchema } from './objects/InsuranceContactInclude.schema';
import { InsuranceContactWhereUniqueInputObjectSchema as InsuranceContactWhereUniqueInputObjectSchema } from './objects/InsuranceContactWhereUniqueInput.schema';
export const InsuranceContactDeleteOneSchema: z.ZodType<Prisma.InsuranceContactDeleteArgs> = z.object({ select: InsuranceContactSelectObjectSchema.optional(), include: InsuranceContactIncludeObjectSchema.optional(), where: InsuranceContactWhereUniqueInputObjectSchema }).strict() as unknown as z.ZodType<Prisma.InsuranceContactDeleteArgs>;
export const InsuranceContactDeleteOneZodSchema = z.object({ select: InsuranceContactSelectObjectSchema.optional(), include: InsuranceContactIncludeObjectSchema.optional(), where: InsuranceContactWhereUniqueInputObjectSchema }).strict();

5
packages/db/shared/schemas/enums/InsuranceContactScalarFieldEnum.schema.ts Normal file
View File

@@ -0,0 +1,5 @@
import * as z from 'zod';
export const InsuranceContactScalarFieldEnumSchema = z.enum(['id', 'userId', 'name', 'phoneNumber', 'createdAt'])
export type InsuranceContactScalarFieldEnum = z.infer<typeof InsuranceContactScalarFieldEnumSchema>;

2
packages/db/shared/schemas/enums/OfficeContactScalarFieldEnum.schema.ts
View File

@@ -1,5 +1,5 @@
import * as z from 'zod';
export const OfficeContactScalarFieldEnumSchema = z.enum(['id', 'userId', 'receptionistName', 'dentistName', 'phoneNumber', 'email', 'fax'])
export const OfficeContactScalarFieldEnumSchema = z.enum(['id', 'userId', 'officeName', 'receptionistName', 'dentistName', 'phoneNumber', 'email', 'fax'])
export type OfficeContactScalarFieldEnum = z.infer<typeof OfficeContactScalarFieldEnumSchema>;

2
packages/db/shared/schemas/enums/PatientScalarFieldEnum.schema.ts
View File

@@ -1,5 +1,5 @@
import * as z from 'zod';
export const PatientScalarFieldEnumSchema = z.enum(['id', 'firstName', 'lastName', 'dateOfBirth', 'gender', 'phone', 'email', 'address', 'city', 'zipCode', 'insuranceProvider', 'insuranceId', 'groupNumber', 'policyHolder', 'allergies', 'medicalConditions', 'status', 'userId', 'createdAt', 'updatedAt'])
export const PatientScalarFieldEnumSchema = z.enum(['id', 'firstName', 'lastName', 'dateOfBirth', 'gender', 'phone', 'email', 'address', 'city', 'zipCode', 'insuranceProvider', 'insuranceId', 'groupNumber', 'policyHolder', 'allergies', 'medicalConditions', 'preferredLanguage', 'status', 'userId', 'createdAt', 'updatedAt'])
export type PatientScalarFieldEnum = z.infer<typeof PatientScalarFieldEnumSchema>;

32
packages/db/shared/schemas/findFirstInsuranceContact.schema.ts Normal file
View File

@@ -0,0 +1,32 @@
import type { Prisma } from '../../generated/prisma';
import * as z from 'zod';
import { InsuranceContactIncludeObjectSchema as InsuranceContactIncludeObjectSchema } from './objects/InsuranceContactInclude.schema';
import { InsuranceContactOrderByWithRelationInputObjectSchema as InsuranceContactOrderByWithRelationInputObjectSchema } from './objects/InsuranceContactOrderByWithRelationInput.schema';
import { InsuranceContactWhereInputObjectSchema as InsuranceContactWhereInputObjectSchema } from './objects/InsuranceContactWhereInput.schema';
import { InsuranceContactWhereUniqueInputObjectSchema as InsuranceContactWhereUniqueInputObjectSchema } from './objects/InsuranceContactWhereUniqueInput.schema';
import { InsuranceContactScalarFieldEnumSchema } from './enums/InsuranceContactScalarFieldEnum.schema';
// Select schema needs to be in file to prevent circular imports
//------------------------------------------------------
export const InsuranceContactFindFirstSelectSchema: z.ZodType<Prisma.InsuranceContactSelect> = z.object({
id: z.boolean().optional(),
userId: z.boolean().optional(),
name: z.boolean().optional(),
phoneNumber: z.boolean().optional(),
createdAt: z.boolean().optional(),
user: z.boolean().optional()
}).strict() as unknown as z.ZodType<Prisma.InsuranceContactSelect>;
export const InsuranceContactFindFirstSelectZodSchema = z.object({
id: z.boolean().optional(),
userId: z.boolean().optional(),
name: z.boolean().optional(),
phoneNumber: z.boolean().optional(),
createdAt: z.boolean().optional(),
user: z.boolean().optional()
}).strict();
export const InsuranceContactFindFirstSchema: z.ZodType<Prisma.InsuranceContactFindFirstArgs> = z.object({ select: InsuranceContactFindFirstSelectSchema.optional(), include: z.lazy(() => InsuranceContactIncludeObjectSchema.optional()), orderBy: z.union([InsuranceContactOrderByWithRelationInputObjectSchema, InsuranceContactOrderByWithRelationInputObjectSchema.array()]).optional(), where: InsuranceContactWhereInputObjectSchema.optional(), cursor: InsuranceContactWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), distinct: z.union([InsuranceContactScalarFieldEnumSchema, InsuranceContactScalarFieldEnumSchema.array()]).optional() }).strict() as unknown as z.ZodType<Prisma.InsuranceContactFindFirstArgs>;
export const InsuranceContactFindFirstZodSchema = z.object({ select: InsuranceContactFindFirstSelectSchema.optional(), include: z.lazy(() => InsuranceContactIncludeObjectSchema.optional()), orderBy: z.union([InsuranceContactOrderByWithRelationInputObjectSchema, InsuranceContactOrderByWithRelationInputObjectSchema.array()]).optional(), where: InsuranceContactWhereInputObjectSchema.optional(), cursor: InsuranceContactWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), distinct: z.union([InsuranceContactScalarFieldEnumSchema, InsuranceContactScalarFieldEnumSchema.array()]).optional() }).strict();

2
packages/db/shared/schemas/findFirstOfficeContact.schema.ts
View File

@@ -12,6 +12,7 @@ import { OfficeContactScalarFieldEnumSchema } from './enums/OfficeContactScalarF
export const OfficeContactFindFirstSelectSchema: z.ZodType<Prisma.OfficeContactSelect> = z.object({
id: z.boolean().optional(),
userId: z.boolean().optional(),
officeName: z.boolean().optional(),
receptionistName: z.boolean().optional(),
dentistName: z.boolean().optional(),
phoneNumber: z.boolean().optional(),
@@ -23,6 +24,7 @@ export const OfficeContactFindFirstSelectSchema: z.ZodType<Prisma.OfficeContactS
export const OfficeContactFindFirstSelectZodSchema = z.object({
id: z.boolean().optional(),
userId: z.boolean().optional(),
officeName: z.boolean().optional(),
receptionistName: z.boolean().optional(),
dentistName: z.boolean().optional(),
phoneNumber: z.boolean().optional(),

32
packages/db/shared/schemas/findFirstOrThrowInsuranceContact.schema.ts Normal file
View File

@@ -0,0 +1,32 @@
import type { Prisma } from '../../generated/prisma';
import * as z from 'zod';
import { InsuranceContactIncludeObjectSchema as InsuranceContactIncludeObjectSchema } from './objects/InsuranceContactInclude.schema';
import { InsuranceContactOrderByWithRelationInputObjectSchema as InsuranceContactOrderByWithRelationInputObjectSchema } from './objects/InsuranceContactOrderByWithRelationInput.schema';
import { InsuranceContactWhereInputObjectSchema as InsuranceContactWhereInputObjectSchema } from './objects/InsuranceContactWhereInput.schema';
import { InsuranceContactWhereUniqueInputObjectSchema as InsuranceContactWhereUniqueInputObjectSchema } from './objects/InsuranceContactWhereUniqueInput.schema';
import { InsuranceContactScalarFieldEnumSchema } from './enums/InsuranceContactScalarFieldEnum.schema';
// Select schema needs to be in file to prevent circular imports
//------------------------------------------------------
export const InsuranceContactFindFirstOrThrowSelectSchema: z.ZodType<Prisma.InsuranceContactSelect> = z.object({
id: z.boolean().optional(),
userId: z.boolean().optional(),
name: z.boolean().optional(),
phoneNumber: z.boolean().optional(),
createdAt: z.boolean().optional(),
user: z.boolean().optional()
}).strict() as unknown as z.ZodType<Prisma.InsuranceContactSelect>;
export const InsuranceContactFindFirstOrThrowSelectZodSchema = z.object({
id: z.boolean().optional(),
userId: z.boolean().optional(),
name: z.boolean().optional(),
phoneNumber: z.boolean().optional(),
createdAt: z.boolean().optional(),
user: z.boolean().optional()
}).strict();
export const InsuranceContactFindFirstOrThrowSchema: z.ZodType<Prisma.InsuranceContactFindFirstOrThrowArgs> = z.object({ select: InsuranceContactFindFirstOrThrowSelectSchema.optional(), include: z.lazy(() => InsuranceContactIncludeObjectSchema.optional()), orderBy: z.union([InsuranceContactOrderByWithRelationInputObjectSchema, InsuranceContactOrderByWithRelationInputObjectSchema.array()]).optional(), where: InsuranceContactWhereInputObjectSchema.optional(), cursor: InsuranceContactWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), distinct: z.union([InsuranceContactScalarFieldEnumSchema, InsuranceContactScalarFieldEnumSchema.array()]).optional() }).strict() as unknown as z.ZodType<Prisma.InsuranceContactFindFirstOrThrowArgs>;
export const InsuranceContactFindFirstOrThrowZodSchema = z.object({ select: InsuranceContactFindFirstOrThrowSelectSchema.optional(), include: z.lazy(() => InsuranceContactIncludeObjectSchema.optional()), orderBy: z.union([InsuranceContactOrderByWithRelationInputObjectSchema, InsuranceContactOrderByWithRelationInputObjectSchema.array()]).optional(), where: InsuranceContactWhereInputObjectSchema.optional(), cursor: InsuranceContactWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), distinct: z.union([InsuranceContactScalarFieldEnumSchema, InsuranceContactScalarFieldEnumSchema.array()]).optional() }).strict();

2
packages/db/shared/schemas/findFirstOrThrowOfficeContact.schema.ts
View File

@@ -12,6 +12,7 @@ import { OfficeContactScalarFieldEnumSchema } from './enums/OfficeContactScalarF
export const OfficeContactFindFirstOrThrowSelectSchema: z.ZodType<Prisma.OfficeContactSelect> = z.object({
id: z.boolean().optional(),
userId: z.boolean().optional(),
officeName: z.boolean().optional(),
receptionistName: z.boolean().optional(),
dentistName: z.boolean().optional(),
phoneNumber: z.boolean().optional(),
@@ -23,6 +24,7 @@ export const OfficeContactFindFirstOrThrowSelectSchema: z.ZodType<Prisma.OfficeC
export const OfficeContactFindFirstOrThrowSelectZodSchema = z.object({
id: z.boolean().optional(),
userId: z.boolean().optional(),
officeName: z.boolean().optional(),
receptionistName: z.boolean().optional(),
dentistName: z.boolean().optional(),
phoneNumber: z.boolean().optional(),

2
packages/db/shared/schemas/findFirstOrThrowPatient.schema.ts
View File

@@ -26,6 +26,7 @@ export const PatientFindFirstOrThrowSelectSchema: z.ZodType<Prisma.PatientSelect
policyHolder: z.boolean().optional(),
allergies: z.boolean().optional(),
medicalConditions: z.boolean().optional(),
preferredLanguage: z.boolean().optional(),
status: z.boolean().optional(),
userId: z.boolean().optional(),
createdAt: z.boolean().optional(),
@@ -58,6 +59,7 @@ export const PatientFindFirstOrThrowSelectZodSchema = z.object({
policyHolder: z.boolean().optional(),
allergies: z.boolean().optional(),
medicalConditions: z.boolean().optional(),
preferredLanguage: z.boolean().optional(),
status: z.boolean().optional(),
userId: z.boolean().optional(),
createdAt: z.boolean().optional(),

2
packages/db/shared/schemas/findFirstOrThrowUser.schema.ts
View File

@@ -33,6 +33,7 @@ export const UserFindFirstOrThrowSelectSchema: z.ZodType<Prisma.UserSelect> = z.
officeHours: z.boolean().optional(),
officeContact: z.boolean().optional(),
procedureTimeslot: z.boolean().optional(),
insuranceContacts: z.boolean().optional(),
_count: z.boolean().optional()
}).strict() as unknown as z.ZodType<Prisma.UserSelect>;
@@ -60,6 +61,7 @@ export const UserFindFirstOrThrowSelectZodSchema = z.object({
officeHours: z.boolean().optional(),
officeContact: z.boolean().optional(),
procedureTimeslot: z.boolean().optional(),
insuranceContacts: z.boolean().optional(),
_count: z.boolean().optional()
}).strict();

2
packages/db/shared/schemas/findFirstPatient.schema.ts
View File

@@ -26,6 +26,7 @@ export const PatientFindFirstSelectSchema: z.ZodType<Prisma.PatientSelect> = z.o
policyHolder: z.boolean().optional(),
allergies: z.boolean().optional(),
medicalConditions: z.boolean().optional(),
preferredLanguage: z.boolean().optional(),
status: z.boolean().optional(),
userId: z.boolean().optional(),
createdAt: z.boolean().optional(),
@@ -58,6 +59,7 @@ export const PatientFindFirstSelectZodSchema = z.object({
policyHolder: z.boolean().optional(),
allergies: z.boolean().optional(),
medicalConditions: z.boolean().optional(),
preferredLanguage: z.boolean().optional(),
status: z.boolean().optional(),
userId: z.boolean().optional(),
createdAt: z.boolean().optional(),

2
packages/db/shared/schemas/findFirstUser.schema.ts
View File

@@ -33,6 +33,7 @@ export const UserFindFirstSelectSchema: z.ZodType<Prisma.UserSelect> = z.object(
officeHours: z.boolean().optional(),
officeContact: z.boolean().optional(),
procedureTimeslot: z.boolean().optional(),
insuranceContacts: z.boolean().optional(),
_count: z.boolean().optional()
}).strict() as unknown as z.ZodType<Prisma.UserSelect>;
@@ -60,6 +61,7 @@ export const UserFindFirstSelectZodSchema = z.object({
officeHours: z.boolean().optional(),
officeContact: z.boolean().optional(),
procedureTimeslot: z.boolean().optional(),
insuranceContacts: z.boolean().optional(),
_count: z.boolean().optional()
}).strict();

32
packages/db/shared/schemas/findManyInsuranceContact.schema.ts Normal file
View File

@@ -0,0 +1,32 @@
import type { Prisma } from '../../generated/prisma';
import * as z from 'zod';
import { InsuranceContactIncludeObjectSchema as InsuranceContactIncludeObjectSchema } from './objects/InsuranceContactInclude.schema';
import { InsuranceContactOrderByWithRelationInputObjectSchema as InsuranceContactOrderByWithRelationInputObjectSchema } from './objects/InsuranceContactOrderByWithRelationInput.schema';
import { InsuranceContactWhereInputObjectSchema as InsuranceContactWhereInputObjectSchema } from './objects/InsuranceContactWhereInput.schema';
import { InsuranceContactWhereUniqueInputObjectSchema as InsuranceContactWhereUniqueInputObjectSchema } from './objects/InsuranceContactWhereUniqueInput.schema';
import { InsuranceContactScalarFieldEnumSchema } from './enums/InsuranceContactScalarFieldEnum.schema';
// Select schema needs to be in file to prevent circular imports
//------------------------------------------------------
export const InsuranceContactFindManySelectSchema: z.ZodType<Prisma.InsuranceContactSelect> = z.object({
id: z.boolean().optional(),
userId: z.boolean().optional(),
name: z.boolean().optional(),
phoneNumber: z.boolean().optional(),
createdAt: z.boolean().optional(),
user: z.boolean().optional()
}).strict() as unknown as z.ZodType<Prisma.InsuranceContactSelect>;
export const InsuranceContactFindManySelectZodSchema = z.object({
id: z.boolean().optional(),
userId: z.boolean().optional(),
name: z.boolean().optional(),
phoneNumber: z.boolean().optional(),
createdAt: z.boolean().optional(),
user: z.boolean().optional()
}).strict();
export const InsuranceContactFindManySchema: z.ZodType<Prisma.InsuranceContactFindManyArgs> = z.object({ select: InsuranceContactFindManySelectSchema.optional(), include: z.lazy(() => InsuranceContactIncludeObjectSchema.optional()), orderBy: z.union([InsuranceContactOrderByWithRelationInputObjectSchema, InsuranceContactOrderByWithRelationInputObjectSchema.array()]).optional(), where: InsuranceContactWhereInputObjectSchema.optional(), cursor: InsuranceContactWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), distinct: z.union([InsuranceContactScalarFieldEnumSchema, InsuranceContactScalarFieldEnumSchema.array()]).optional() }).strict() as unknown as z.ZodType<Prisma.InsuranceContactFindManyArgs>;
export const InsuranceContactFindManyZodSchema = z.object({ select: InsuranceContactFindManySelectSchema.optional(), include: z.lazy(() => InsuranceContactIncludeObjectSchema.optional()), orderBy: z.union([InsuranceContactOrderByWithRelationInputObjectSchema, InsuranceContactOrderByWithRelationInputObjectSchema.array()]).optional(), where: InsuranceContactWhereInputObjectSchema.optional(), cursor: InsuranceContactWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), distinct: z.union([InsuranceContactScalarFieldEnumSchema, InsuranceContactScalarFieldEnumSchema.array()]).optional() }).strict();

2
packages/db/shared/schemas/findManyOfficeContact.schema.ts
View File

@@ -12,6 +12,7 @@ import { OfficeContactScalarFieldEnumSchema } from './enums/OfficeContactScalarF
export const OfficeContactFindManySelectSchema: z.ZodType<Prisma.OfficeContactSelect> = z.object({
id: z.boolean().optional(),
userId: z.boolean().optional(),
officeName: z.boolean().optional(),
receptionistName: z.boolean().optional(),
dentistName: z.boolean().optional(),
phoneNumber: z.boolean().optional(),
@@ -23,6 +24,7 @@ export const OfficeContactFindManySelectSchema: z.ZodType<Prisma.OfficeContactSe
export const OfficeContactFindManySelectZodSchema = z.object({
id: z.boolean().optional(),
userId: z.boolean().optional(),
officeName: z.boolean().optional(),
receptionistName: z.boolean().optional(),
dentistName: z.boolean().optional(),
phoneNumber: z.boolean().optional(),

2
packages/db/shared/schemas/findManyPatient.schema.ts
View File

@@ -26,6 +26,7 @@ export const PatientFindManySelectSchema: z.ZodType<Prisma.PatientSelect> = z.ob
policyHolder: z.boolean().optional(),
allergies: z.boolean().optional(),
medicalConditions: z.boolean().optional(),
preferredLanguage: z.boolean().optional(),
status: z.boolean().optional(),
userId: z.boolean().optional(),
createdAt: z.boolean().optional(),
@@ -58,6 +59,7 @@ export const PatientFindManySelectZodSchema = z.object({
policyHolder: z.boolean().optional(),
allergies: z.boolean().optional(),
medicalConditions: z.boolean().optional(),
preferredLanguage: z.boolean().optional(),
status: z.boolean().optional(),
userId: z.boolean().optional(),
createdAt: z.boolean().optional(),

2
packages/db/shared/schemas/findManyUser.schema.ts
View File

@@ -33,6 +33,7 @@ export const UserFindManySelectSchema: z.ZodType<Prisma.UserSelect> = z.object({
officeHours: z.boolean().optional(),
officeContact: z.boolean().optional(),
procedureTimeslot: z.boolean().optional(),
insuranceContacts: z.boolean().optional(),
_count: z.boolean().optional()
}).strict() as unknown as z.ZodType<Prisma.UserSelect>;
@@ -60,6 +61,7 @@ export const UserFindManySelectZodSchema = z.object({
officeHours: z.boolean().optional(),
officeContact: z.boolean().optional(),
procedureTimeslot: z.boolean().optional(),
insuranceContacts: z.boolean().optional(),
_count: z.boolean().optional()
}).strict();

9
packages/db/shared/schemas/findUniqueInsuranceContact.schema.ts Normal file
View File

@@ -0,0 +1,9 @@
import type { Prisma } from '../../generated/prisma';
import * as z from 'zod';
import { InsuranceContactSelectObjectSchema as InsuranceContactSelectObjectSchema } from './objects/InsuranceContactSelect.schema';
import { InsuranceContactIncludeObjectSchema as InsuranceContactIncludeObjectSchema } from './objects/InsuranceContactInclude.schema';
import { InsuranceContactWhereUniqueInputObjectSchema as InsuranceContactWhereUniqueInputObjectSchema } from './objects/InsuranceContactWhereUniqueInput.schema';
export const InsuranceContactFindUniqueSchema: z.ZodType<Prisma.InsuranceContactFindUniqueArgs> = z.object({ select: InsuranceContactSelectObjectSchema.optional(), include: InsuranceContactIncludeObjectSchema.optional(), where: InsuranceContactWhereUniqueInputObjectSchema }).strict() as unknown as z.ZodType<Prisma.InsuranceContactFindUniqueArgs>;
export const InsuranceContactFindUniqueZodSchema = z.object({ select: InsuranceContactSelectObjectSchema.optional(), include: InsuranceContactIncludeObjectSchema.optional(), where: InsuranceContactWhereUniqueInputObjectSchema }).strict();

9
packages/db/shared/schemas/findUniqueOrThrowInsuranceContact.schema.ts Normal file
View File

@@ -0,0 +1,9 @@
import type { Prisma } from '../../generated/prisma';
import * as z from 'zod';
import { InsuranceContactSelectObjectSchema as InsuranceContactSelectObjectSchema } from './objects/InsuranceContactSelect.schema';
import { InsuranceContactIncludeObjectSchema as InsuranceContactIncludeObjectSchema } from './objects/InsuranceContactInclude.schema';
import { InsuranceContactWhereUniqueInputObjectSchema as InsuranceContactWhereUniqueInputObjectSchema } from './objects/InsuranceContactWhereUniqueInput.schema';
export const InsuranceContactFindUniqueOrThrowSchema: z.ZodType<Prisma.InsuranceContactFindUniqueOrThrowArgs> = z.object({ select: InsuranceContactSelectObjectSchema.optional(), include: InsuranceContactIncludeObjectSchema.optional(), where: InsuranceContactWhereUniqueInputObjectSchema }).strict() as unknown as z.ZodType<Prisma.InsuranceContactFindUniqueOrThrowArgs>;
export const InsuranceContactFindUniqueOrThrowZodSchema = z.object({ select: InsuranceContactSelectObjectSchema.optional(), include: InsuranceContactIncludeObjectSchema.optional(), where: InsuranceContactWhereUniqueInputObjectSchema }).strict();

15
packages/db/shared/schemas/groupByInsuranceContact.schema.ts Normal file
View File

@@ -0,0 +1,15 @@
import type { Prisma } from '../../generated/prisma';
import * as z from 'zod';
import { InsuranceContactWhereInputObjectSchema as InsuranceContactWhereInputObjectSchema } from './objects/InsuranceContactWhereInput.schema';
import { InsuranceContactOrderByWithAggregationInputObjectSchema as InsuranceContactOrderByWithAggregationInputObjectSchema } from './objects/InsuranceContactOrderByWithAggregationInput.schema';
import { InsuranceContactScalarWhereWithAggregatesInputObjectSchema as InsuranceContactScalarWhereWithAggregatesInputObjectSchema } from './objects/InsuranceContactScalarWhereWithAggregatesInput.schema';
import { InsuranceContactScalarFieldEnumSchema } from './enums/InsuranceContactScalarFieldEnum.schema';
import { InsuranceContactCountAggregateInputObjectSchema as InsuranceContactCountAggregateInputObjectSchema } from './objects/InsuranceContactCountAggregateInput.schema';
import { InsuranceContactMinAggregateInputObjectSchema as InsuranceContactMinAggregateInputObjectSchema } from './objects/InsuranceContactMinAggregateInput.schema';
import { InsuranceContactMaxAggregateInputObjectSchema as InsuranceContactMaxAggregateInputObjectSchema } from './objects/InsuranceContactMaxAggregateInput.schema';
import { InsuranceContactAvgAggregateInputObjectSchema as InsuranceContactAvgAggregateInputObjectSchema } from './objects/InsuranceContactAvgAggregateInput.schema';
import { InsuranceContactSumAggregateInputObjectSchema as InsuranceContactSumAggregateInputObjectSchema } from './objects/InsuranceContactSumAggregateInput.schema';
export const InsuranceContactGroupBySchema: z.ZodType<Prisma.InsuranceContactGroupByArgs> = z.object({ where: InsuranceContactWhereInputObjectSchema.optional(), orderBy: z.union([InsuranceContactOrderByWithAggregationInputObjectSchema, InsuranceContactOrderByWithAggregationInputObjectSchema.array()]).optional(), having: InsuranceContactScalarWhereWithAggregatesInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), by: z.array(InsuranceContactScalarFieldEnumSchema), _count: z.union([ z.literal(true), InsuranceContactCountAggregateInputObjectSchema ]).optional(), _min: InsuranceContactMinAggregateInputObjectSchema.optional(), _max: InsuranceContactMaxAggregateInputObjectSchema.optional(), _avg: InsuranceContactAvgAggregateInputObjectSchema.optional(), _sum: InsuranceContactSumAggregateInputObjectSchema.optional() }).strict() as unknown as z.ZodType<Prisma.InsuranceContactGroupByArgs>;
export const InsuranceContactGroupByZodSchema = z.object({ where: InsuranceContactWhereInputObjectSchema.optional(), orderBy: z.union([InsuranceContactOrderByWithAggregationInputObjectSchema, InsuranceContactOrderByWithAggregationInputObjectSchema.array()]).optional(), having: InsuranceContactScalarWhereWithAggregatesInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), by: z.array(InsuranceContactScalarFieldEnumSchema), _count: z.union([ z.literal(true), InsuranceContactCountAggregateInputObjectSchema ]).optional(), _min: InsuranceContactMinAggregateInputObjectSchema.optional(), _max: InsuranceContactMaxAggregateInputObjectSchema.optional(), _avg: InsuranceContactAvgAggregateInputObjectSchema.optional(), _sum: InsuranceContactSumAggregateInputObjectSchema.optional() }).strict();

34
packages/db/shared/schemas/index.ts
View File

@@ -27,6 +27,7 @@ export * from './enums/TwilioSettingsScalarFieldEnum.schema'
export * from './enums/AiSettingsScalarFieldEnum.schema'
export * from './enums/OfficeHoursScalarFieldEnum.schema'
export * from './enums/OfficeContactScalarFieldEnum.schema'
export * from './enums/InsuranceContactScalarFieldEnum.schema'
export * from './enums/ProcedureTimeslotScalarFieldEnum.schema'
export * from './enums/SortOrder.schema'
export * from './enums/NullableJsonNullValueInput.schema'
@@ -522,6 +523,23 @@ export * from './updateManyAndReturnOfficeContact.schema'
export * from './upsertOneOfficeContact.schema'
export * from './aggregateOfficeContact.schema'
export * from './groupByOfficeContact.schema'
export * from './findUniqueInsuranceContact.schema'
export * from './findUniqueOrThrowInsuranceContact.schema'
export * from './findFirstInsuranceContact.schema'
export * from './findFirstOrThrowInsuranceContact.schema'
export * from './findManyInsuranceContact.schema'
export * from './countInsuranceContact.schema'
export * from './createOneInsuranceContact.schema'
export * from './createManyInsuranceContact.schema'
export * from './createManyAndReturnInsuranceContact.schema'
export * from './deleteOneInsuranceContact.schema'
export * from './deleteManyInsuranceContact.schema'
export * from './updateOneInsuranceContact.schema'
export * from './updateManyInsuranceContact.schema'
export * from './updateManyAndReturnInsuranceContact.schema'
export * from './upsertOneInsuranceContact.schema'
export * from './aggregateInsuranceContact.schema'
export * from './groupByInsuranceContact.schema'
export * from './findUniqueProcedureTimeslot.schema'
export * from './findUniqueOrThrowProcedureTimeslot.schema'
export * from './findFirstProcedureTimeslot.schema'
@@ -903,6 +921,19 @@ export * from './results/OfficeContactDeleteManyResult.schema'
export * from './results/OfficeContactAggregateResult.schema'
export * from './results/OfficeContactGroupByResult.schema'
export * from './results/OfficeContactCountResult.schema'
export * from './results/InsuranceContactFindUniqueResult.schema'
export * from './results/InsuranceContactFindFirstResult.schema'
export * from './results/InsuranceContactFindManyResult.schema'
export * from './results/InsuranceContactCreateResult.schema'
export * from './results/InsuranceContactCreateManyResult.schema'
export * from './results/InsuranceContactUpdateResult.schema'
export * from './results/InsuranceContactUpdateManyResult.schema'
export * from './results/InsuranceContactUpsertResult.schema'
export * from './results/InsuranceContactDeleteResult.schema'
export * from './results/InsuranceContactDeleteManyResult.schema'
export * from './results/InsuranceContactAggregateResult.schema'
export * from './results/InsuranceContactGroupByResult.schema'
export * from './results/InsuranceContactCountResult.schema'
export * from './results/ProcedureTimeslotFindUniqueResult.schema'
export * from './results/ProcedureTimeslotFindFirstResult.schema'
export * from './results/ProcedureTimeslotFindManyResult.schema'
@@ -946,6 +977,7 @@ export * from './variants/pure/TwilioSettings.pure'
export * from './variants/pure/AiSettings.pure'
export * from './variants/pure/OfficeHours.pure'
export * from './variants/pure/OfficeContact.pure'
export * from './variants/pure/InsuranceContact.pure'
export * from './variants/pure/ProcedureTimeslot.pure'
export * from './variants/pure/index'
export * from './variants/input/User.input'
@@ -976,6 +1008,7 @@ export * from './variants/input/TwilioSettings.input'
export * from './variants/input/AiSettings.input'
export * from './variants/input/OfficeHours.input'
export * from './variants/input/OfficeContact.input'
export * from './variants/input/InsuranceContact.input'
export * from './variants/input/ProcedureTimeslot.input'
export * from './variants/input/index'
export * from './variants/result/User.result'
@@ -1006,6 +1039,7 @@ export * from './variants/result/TwilioSettings.result'
export * from './variants/result/AiSettings.result'
export * from './variants/result/OfficeHours.result'
export * from './variants/result/OfficeContact.result'
export * from './variants/result/InsuranceContact.result'
export * from './variants/result/ProcedureTimeslot.result'
export * from './variants/result/index'
export * from './variants/index'

11
packages/db/shared/schemas/objects/InsuranceContactArgs.schema.ts Normal file
View File

@@ -0,0 +1,11 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { InsuranceContactSelectObjectSchema as InsuranceContactSelectObjectSchema } from './InsuranceContactSelect.schema';
import { InsuranceContactIncludeObjectSchema as InsuranceContactIncludeObjectSchema } from './InsuranceContactInclude.schema'
const makeSchema = () => z.object({
select: z.lazy(() => InsuranceContactSelectObjectSchema).optional(),
include: z.lazy(() => InsuranceContactIncludeObjectSchema).optional()
}).strict();
export const InsuranceContactArgsObjectSchema = makeSchema();
export const InsuranceContactArgsObjectZodSchema = makeSchema();

10
packages/db/shared/schemas/objects/InsuranceContactAvgAggregateInput.schema.ts Normal file
View File

@@ -0,0 +1,10 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
const makeSchema = () => z.object({
id: z.literal(true).optional(),
userId: z.literal(true).optional()
}).strict();
export const InsuranceContactAvgAggregateInputObjectSchema: z.ZodType<Prisma.InsuranceContactAvgAggregateInputType> = makeSchema() as unknown as z.ZodType<Prisma.InsuranceContactAvgAggregateInputType>;
export const InsuranceContactAvgAggregateInputObjectZodSchema = makeSchema();

10
packages/db/shared/schemas/objects/InsuranceContactAvgOrderByAggregateInput.schema.ts Normal file
View File

@@ -0,0 +1,10 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { SortOrderSchema } from '../enums/SortOrder.schema'
const makeSchema = () => z.object({
id: SortOrderSchema.optional(),
userId: SortOrderSchema.optional()
}).strict();
export const InsuranceContactAvgOrderByAggregateInputObjectSchema: z.ZodType<Prisma.InsuranceContactAvgOrderByAggregateInput> = makeSchema() as unknown as z.ZodType<Prisma.InsuranceContactAvgOrderByAggregateInput>;
export const InsuranceContactAvgOrderByAggregateInputObjectZodSchema = makeSchema();

14
packages/db/shared/schemas/objects/InsuranceContactCountAggregateInput.schema.ts Normal file
View File

@@ -0,0 +1,14 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
const makeSchema = () => z.object({
id: z.literal(true).optional(),
userId: z.literal(true).optional(),
name: z.literal(true).optional(),
phoneNumber: z.literal(true).optional(),
createdAt: z.literal(true).optional(),
_all: z.literal(true).optional()
}).strict();
export const InsuranceContactCountAggregateInputObjectSchema: z.ZodType<Prisma.InsuranceContactCountAggregateInputType> = makeSchema() as unknown as z.ZodType<Prisma.InsuranceContactCountAggregateInputType>;
export const InsuranceContactCountAggregateInputObjectZodSchema = makeSchema();

13
packages/db/shared/schemas/objects/InsuranceContactCountOrderByAggregateInput.schema.ts Normal file
View File

@@ -0,0 +1,13 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { SortOrderSchema } from '../enums/SortOrder.schema'
const makeSchema = () => z.object({
id: SortOrderSchema.optional(),
userId: SortOrderSchema.optional(),
name: SortOrderSchema.optional(),
phoneNumber: SortOrderSchema.optional(),
createdAt: SortOrderSchema.optional()
}).strict();
export const InsuranceContactCountOrderByAggregateInputObjectSchema: z.ZodType<Prisma.InsuranceContactCountOrderByAggregateInput> = makeSchema() as unknown as z.ZodType<Prisma.InsuranceContactCountOrderByAggregateInput>;
export const InsuranceContactCountOrderByAggregateInputObjectZodSchema = makeSchema();

12
packages/db/shared/schemas/objects/InsuranceContactCreateInput.schema.ts Normal file
View File

@@ -0,0 +1,12 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { UserCreateNestedOneWithoutInsuranceContactsInputObjectSchema as UserCreateNestedOneWithoutInsuranceContactsInputObjectSchema } from './UserCreateNestedOneWithoutInsuranceContactsInput.schema'
const makeSchema = () => z.object({
name: z.string(),
phoneNumber: z.string().optional().nullable(),
createdAt: z.coerce.date().optional(),
user: z.lazy(() => UserCreateNestedOneWithoutInsuranceContactsInputObjectSchema)
}).strict();
export const InsuranceContactCreateInputObjectSchema: z.ZodType<Prisma.InsuranceContactCreateInput> = makeSchema() as unknown as z.ZodType<Prisma.InsuranceContactCreateInput>;
export const InsuranceContactCreateInputObjectZodSchema = makeSchema();

13
packages/db/shared/schemas/objects/InsuranceContactCreateManyInput.schema.ts Normal file
View File

@@ -0,0 +1,13 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
const makeSchema = () => z.object({
id: z.number().int().optional(),
userId: z.number().int(),
name: z.string(),
phoneNumber: z.string().optional().nullable(),
createdAt: z.coerce.date().optional()
}).strict();
export const InsuranceContactCreateManyInputObjectSchema: z.ZodType<Prisma.InsuranceContactCreateManyInput> = makeSchema() as unknown as z.ZodType<Prisma.InsuranceContactCreateManyInput>;
export const InsuranceContactCreateManyInputObjectZodSchema = makeSchema();

12
packages/db/shared/schemas/objects/InsuranceContactCreateManyUserInput.schema.ts Normal file
View File

@@ -0,0 +1,12 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
const makeSchema = () => z.object({
id: z.number().int().optional(),
name: z.string(),
phoneNumber: z.string().optional().nullable(),
createdAt: z.coerce.date().optional()
}).strict();
export const InsuranceContactCreateManyUserInputObjectSchema: z.ZodType<Prisma.InsuranceContactCreateManyUserInput> = makeSchema() as unknown as z.ZodType<Prisma.InsuranceContactCreateManyUserInput>;
export const InsuranceContactCreateManyUserInputObjectZodSchema = makeSchema();

10
packages/db/shared/schemas/objects/InsuranceContactCreateManyUserInputEnvelope.schema.ts Normal file
View File

@@ -0,0 +1,10 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { InsuranceContactCreateManyUserInputObjectSchema as InsuranceContactCreateManyUserInputObjectSchema } from './InsuranceContactCreateManyUserInput.schema'
const makeSchema = () => z.object({
data: z.union([z.lazy(() => InsuranceContactCreateManyUserInputObjectSchema), z.lazy(() => InsuranceContactCreateManyUserInputObjectSchema).array()]),
skipDuplicates: z.boolean().optional()
}).strict();
export const InsuranceContactCreateManyUserInputEnvelopeObjectSchema: z.ZodType<Prisma.InsuranceContactCreateManyUserInputEnvelope> = makeSchema() as unknown as z.ZodType<Prisma.InsuranceContactCreateManyUserInputEnvelope>;
export const InsuranceContactCreateManyUserInputEnvelopeObjectZodSchema = makeSchema();

16
packages/db/shared/schemas/objects/InsuranceContactCreateNestedManyWithoutUserInput.schema.ts Normal file
View File

@@ -0,0 +1,16 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { InsuranceContactCreateWithoutUserInputObjectSchema as InsuranceContactCreateWithoutUserInputObjectSchema } from './InsuranceContactCreateWithoutUserInput.schema';
import { InsuranceContactUncheckedCreateWithoutUserInputObjectSchema as InsuranceContactUncheckedCreateWithoutUserInputObjectSchema } from './InsuranceContactUncheckedCreateWithoutUserInput.schema';
import { InsuranceContactCreateOrConnectWithoutUserInputObjectSchema as InsuranceContactCreateOrConnectWithoutUserInputObjectSchema } from './InsuranceContactCreateOrConnectWithoutUserInput.schema';
import { InsuranceContactCreateManyUserInputEnvelopeObjectSchema as InsuranceContactCreateManyUserInputEnvelopeObjectSchema } from './InsuranceContactCreateManyUserInputEnvelope.schema';
import { InsuranceContactWhereUniqueInputObjectSchema as InsuranceContactWhereUniqueInputObjectSchema } from './InsuranceContactWhereUniqueInput.schema'
const makeSchema = () => z.object({
create: z.union([z.lazy(() => InsuranceContactCreateWithoutUserInputObjectSchema), z.lazy(() => InsuranceContactCreateWithoutUserInputObjectSchema).array(), z.lazy(() => InsuranceContactUncheckedCreateWithoutUserInputObjectSchema), z.lazy(() => InsuranceContactUncheckedCreateWithoutUserInputObjectSchema).array()]).optional(),
connectOrCreate: z.union([z.lazy(() => InsuranceContactCreateOrConnectWithoutUserInputObjectSchema), z.lazy(() => InsuranceContactCreateOrConnectWithoutUserInputObjectSchema).array()]).optional(),
createMany: z.lazy(() => InsuranceContactCreateManyUserInputEnvelopeObjectSchema).optional(),
connect: z.union([z.lazy(() => InsuranceContactWhereUniqueInputObjectSchema), z.lazy(() => InsuranceContactWhereUniqueInputObjectSchema).array()]).optional()
}).strict();
export const InsuranceContactCreateNestedManyWithoutUserInputObjectSchema: z.ZodType<Prisma.InsuranceContactCreateNestedManyWithoutUserInput> = makeSchema() as unknown as z.ZodType<Prisma.InsuranceContactCreateNestedManyWithoutUserInput>;
export const InsuranceContactCreateNestedManyWithoutUserInputObjectZodSchema = makeSchema();

12
packages/db/shared/schemas/objects/InsuranceContactCreateOrConnectWithoutUserInput.schema.ts Normal file
View File

@@ -0,0 +1,12 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { InsuranceContactWhereUniqueInputObjectSchema as InsuranceContactWhereUniqueInputObjectSchema } from './InsuranceContactWhereUniqueInput.schema';
import { InsuranceContactCreateWithoutUserInputObjectSchema as InsuranceContactCreateWithoutUserInputObjectSchema } from './InsuranceContactCreateWithoutUserInput.schema';
import { InsuranceContactUncheckedCreateWithoutUserInputObjectSchema as InsuranceContactUncheckedCreateWithoutUserInputObjectSchema } from './InsuranceContactUncheckedCreateWithoutUserInput.schema'
const makeSchema = () => z.object({
where: z.lazy(() => InsuranceContactWhereUniqueInputObjectSchema),
create: z.union([z.lazy(() => InsuranceContactCreateWithoutUserInputObjectSchema), z.lazy(() => InsuranceContactUncheckedCreateWithoutUserInputObjectSchema)])
}).strict();
export const InsuranceContactCreateOrConnectWithoutUserInputObjectSchema: z.ZodType<Prisma.InsuranceContactCreateOrConnectWithoutUserInput> = makeSchema() as unknown as z.ZodType<Prisma.InsuranceContactCreateOrConnectWithoutUserInput>;
export const InsuranceContactCreateOrConnectWithoutUserInputObjectZodSchema = makeSchema();

11
packages/db/shared/schemas/objects/InsuranceContactCreateWithoutUserInput.schema.ts Normal file
View File

@@ -0,0 +1,11 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
const makeSchema = () => z.object({
name: z.string(),
phoneNumber: z.string().optional().nullable(),
createdAt: z.coerce.date().optional()
}).strict();
export const InsuranceContactCreateWithoutUserInputObjectSchema: z.ZodType<Prisma.InsuranceContactCreateWithoutUserInput> = makeSchema() as unknown as z.ZodType<Prisma.InsuranceContactCreateWithoutUserInput>;
export const InsuranceContactCreateWithoutUserInputObjectZodSchema = makeSchema();

9
packages/db/shared/schemas/objects/InsuranceContactInclude.schema.ts Normal file
View File

@@ -0,0 +1,9 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { UserArgsObjectSchema as UserArgsObjectSchema } from './UserArgs.schema'
const makeSchema = () => z.object({
user: z.union([z.boolean(), z.lazy(() => UserArgsObjectSchema)]).optional()
}).strict();
export const InsuranceContactIncludeObjectSchema: z.ZodType<Prisma.InsuranceContactInclude> = makeSchema() as unknown as z.ZodType<Prisma.InsuranceContactInclude>;
export const InsuranceContactIncludeObjectZodSchema = makeSchema();

11
packages/db/shared/schemas/objects/InsuranceContactListRelationFilter.schema.ts Normal file
View File

@@ -0,0 +1,11 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { InsuranceContactWhereInputObjectSchema as InsuranceContactWhereInputObjectSchema } from './InsuranceContactWhereInput.schema'
const makeSchema = () => z.object({
every: z.lazy(() => InsuranceContactWhereInputObjectSchema).optional(),
some: z.lazy(() => InsuranceContactWhereInputObjectSchema).optional(),
none: z.lazy(() => InsuranceContactWhereInputObjectSchema).optional()
}).strict();
export const InsuranceContactListRelationFilterObjectSchema: z.ZodType<Prisma.InsuranceContactListRelationFilter> = makeSchema() as unknown as z.ZodType<Prisma.InsuranceContactListRelationFilter>;
export const InsuranceContactListRelationFilterObjectZodSchema = makeSchema();

13
packages/db/shared/schemas/objects/InsuranceContactMaxAggregateInput.schema.ts Normal file
View File

@@ -0,0 +1,13 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
const makeSchema = () => z.object({
id: z.literal(true).optional(),
userId: z.literal(true).optional(),
name: z.literal(true).optional(),
phoneNumber: z.literal(true).optional(),
createdAt: z.literal(true).optional()
}).strict();
export const InsuranceContactMaxAggregateInputObjectSchema: z.ZodType<Prisma.InsuranceContactMaxAggregateInputType> = makeSchema() as unknown as z.ZodType<Prisma.InsuranceContactMaxAggregateInputType>;
export const InsuranceContactMaxAggregateInputObjectZodSchema = makeSchema();

13
packages/db/shared/schemas/objects/InsuranceContactMaxOrderByAggregateInput.schema.ts Normal file
View File

@@ -0,0 +1,13 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { SortOrderSchema } from '../enums/SortOrder.schema'
const makeSchema = () => z.object({
id: SortOrderSchema.optional(),
userId: SortOrderSchema.optional(),
name: SortOrderSchema.optional(),
phoneNumber: SortOrderSchema.optional(),
createdAt: SortOrderSchema.optional()
}).strict();
export const InsuranceContactMaxOrderByAggregateInputObjectSchema: z.ZodType<Prisma.InsuranceContactMaxOrderByAggregateInput> = makeSchema() as unknown as z.ZodType<Prisma.InsuranceContactMaxOrderByAggregateInput>;
export const InsuranceContactMaxOrderByAggregateInputObjectZodSchema = makeSchema();

13
packages/db/shared/schemas/objects/InsuranceContactMinAggregateInput.schema.ts Normal file
View File

@@ -0,0 +1,13 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
const makeSchema = () => z.object({
id: z.literal(true).optional(),
userId: z.literal(true).optional(),
name: z.literal(true).optional(),
phoneNumber: z.literal(true).optional(),
createdAt: z.literal(true).optional()
}).strict();
export const InsuranceContactMinAggregateInputObjectSchema: z.ZodType<Prisma.InsuranceContactMinAggregateInputType> = makeSchema() as unknown as z.ZodType<Prisma.InsuranceContactMinAggregateInputType>;
export const InsuranceContactMinAggregateInputObjectZodSchema = makeSchema();

13
packages/db/shared/schemas/objects/InsuranceContactMinOrderByAggregateInput.schema.ts Normal file
View File

@@ -0,0 +1,13 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { SortOrderSchema } from '../enums/SortOrder.schema'
const makeSchema = () => z.object({
id: SortOrderSchema.optional(),
userId: SortOrderSchema.optional(),
name: SortOrderSchema.optional(),
phoneNumber: SortOrderSchema.optional(),
createdAt: SortOrderSchema.optional()
}).strict();
export const InsuranceContactMinOrderByAggregateInputObjectSchema: z.ZodType<Prisma.InsuranceContactMinOrderByAggregateInput> = makeSchema() as unknown as z.ZodType<Prisma.InsuranceContactMinOrderByAggregateInput>;
export const InsuranceContactMinOrderByAggregateInputObjectZodSchema = makeSchema();

9
packages/db/shared/schemas/objects/InsuranceContactOrderByRelationAggregateInput.schema.ts Normal file
View File

@@ -0,0 +1,9 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { SortOrderSchema } from '../enums/SortOrder.schema'
const makeSchema = () => z.object({
_count: SortOrderSchema.optional()
}).strict();
export const InsuranceContactOrderByRelationAggregateInputObjectSchema: z.ZodType<Prisma.InsuranceContactOrderByRelationAggregateInput> = makeSchema() as unknown as z.ZodType<Prisma.InsuranceContactOrderByRelationAggregateInput>;
export const InsuranceContactOrderByRelationAggregateInputObjectZodSchema = makeSchema();

24
packages/db/shared/schemas/objects/InsuranceContactOrderByWithAggregationInput.schema.ts Normal file
View File

@@ -0,0 +1,24 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { SortOrderSchema } from '../enums/SortOrder.schema';
import { SortOrderInputObjectSchema as SortOrderInputObjectSchema } from './SortOrderInput.schema';
import { InsuranceContactCountOrderByAggregateInputObjectSchema as InsuranceContactCountOrderByAggregateInputObjectSchema } from './InsuranceContactCountOrderByAggregateInput.schema';
import { InsuranceContactAvgOrderByAggregateInputObjectSchema as InsuranceContactAvgOrderByAggregateInputObjectSchema } from './InsuranceContactAvgOrderByAggregateInput.schema';
import { InsuranceContactMaxOrderByAggregateInputObjectSchema as InsuranceContactMaxOrderByAggregateInputObjectSchema } from './InsuranceContactMaxOrderByAggregateInput.schema';
import { InsuranceContactMinOrderByAggregateInputObjectSchema as InsuranceContactMinOrderByAggregateInputObjectSchema } from './InsuranceContactMinOrderByAggregateInput.schema';
import { InsuranceContactSumOrderByAggregateInputObjectSchema as InsuranceContactSumOrderByAggregateInputObjectSchema } from './InsuranceContactSumOrderByAggregateInput.schema'
const makeSchema = () => z.object({
id: SortOrderSchema.optional(),
userId: SortOrderSchema.optional(),
name: SortOrderSchema.optional(),
phoneNumber: z.union([SortOrderSchema, z.lazy(() => SortOrderInputObjectSchema)]).optional(),
createdAt: SortOrderSchema.optional(),
_count: z.lazy(() => InsuranceContactCountOrderByAggregateInputObjectSchema).optional(),
_avg: z.lazy(() => InsuranceContactAvgOrderByAggregateInputObjectSchema).optional(),
_max: z.lazy(() => InsuranceContactMaxOrderByAggregateInputObjectSchema).optional(),
_min: z.lazy(() => InsuranceContactMinOrderByAggregateInputObjectSchema).optional(),
_sum: z.lazy(() => InsuranceContactSumOrderByAggregateInputObjectSchema).optional()
}).strict();
export const InsuranceContactOrderByWithAggregationInputObjectSchema: z.ZodType<Prisma.InsuranceContactOrderByWithAggregationInput> = makeSchema() as unknown as z.ZodType<Prisma.InsuranceContactOrderByWithAggregationInput>;
export const InsuranceContactOrderByWithAggregationInputObjectZodSchema = makeSchema();

16
packages/db/shared/schemas/objects/InsuranceContactOrderByWithRelationInput.schema.ts Normal file
View File

@@ -0,0 +1,16 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { SortOrderSchema } from '../enums/SortOrder.schema';
import { SortOrderInputObjectSchema as SortOrderInputObjectSchema } from './SortOrderInput.schema';
import { UserOrderByWithRelationInputObjectSchema as UserOrderByWithRelationInputObjectSchema } from './UserOrderByWithRelationInput.schema'
const makeSchema = () => z.object({
id: SortOrderSchema.optional(),
userId: SortOrderSchema.optional(),
name: SortOrderSchema.optional(),
phoneNumber: z.union([SortOrderSchema, z.lazy(() => SortOrderInputObjectSchema)]).optional(),
createdAt: SortOrderSchema.optional(),
user: z.lazy(() => UserOrderByWithRelationInputObjectSchema).optional()
}).strict();
export const InsuranceContactOrderByWithRelationInputObjectSchema: z.ZodType<Prisma.InsuranceContactOrderByWithRelationInput> = makeSchema() as unknown as z.ZodType<Prisma.InsuranceContactOrderByWithRelationInput>;
export const InsuranceContactOrderByWithRelationInputObjectZodSchema = makeSchema();

19
packages/db/shared/schemas/objects/InsuranceContactScalarWhereInput.schema.ts Normal file
View File

@@ -0,0 +1,19 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { IntFilterObjectSchema as IntFilterObjectSchema } from './IntFilter.schema';
import { StringFilterObjectSchema as StringFilterObjectSchema } from './StringFilter.schema';
import { StringNullableFilterObjectSchema as StringNullableFilterObjectSchema } from './StringNullableFilter.schema';
import { DateTimeFilterObjectSchema as DateTimeFilterObjectSchema } from './DateTimeFilter.schema'
const insurancecontactscalarwhereinputSchema = z.object({
AND: z.union([z.lazy(() => InsuranceContactScalarWhereInputObjectSchema), z.lazy(() => InsuranceContactScalarWhereInputObjectSchema).array()]).optional(),
OR: z.lazy(() => InsuranceContactScalarWhereInputObjectSchema).array().optional(),
NOT: z.union([z.lazy(() => InsuranceContactScalarWhereInputObjectSchema), z.lazy(() => InsuranceContactScalarWhereInputObjectSchema).array()]).optional(),
id: z.union([z.lazy(() => IntFilterObjectSchema), z.number().int()]).optional(),
userId: z.union([z.lazy(() => IntFilterObjectSchema), z.number().int()]).optional(),
name: z.union([z.lazy(() => StringFilterObjectSchema), z.string()]).optional(),
phoneNumber: z.union([z.lazy(() => StringNullableFilterObjectSchema), z.string()]).optional().nullable(),
createdAt: z.union([z.lazy(() => DateTimeFilterObjectSchema), z.coerce.date()]).optional()
}).strict();
export const InsuranceContactScalarWhereInputObjectSchema: z.ZodType<Prisma.InsuranceContactScalarWhereInput> = insurancecontactscalarwhereinputSchema as unknown as z.ZodType<Prisma.InsuranceContactScalarWhereInput>;
export const InsuranceContactScalarWhereInputObjectZodSchema = insurancecontactscalarwhereinputSchema;

19
packages/db/shared/schemas/objects/InsuranceContactScalarWhereWithAggregatesInput.schema.ts Normal file
View File

@@ -0,0 +1,19 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { IntWithAggregatesFilterObjectSchema as IntWithAggregatesFilterObjectSchema } from './IntWithAggregatesFilter.schema';
import { StringWithAggregatesFilterObjectSchema as StringWithAggregatesFilterObjectSchema } from './StringWithAggregatesFilter.schema';
import { StringNullableWithAggregatesFilterObjectSchema as StringNullableWithAggregatesFilterObjectSchema } from './StringNullableWithAggregatesFilter.schema';
import { DateTimeWithAggregatesFilterObjectSchema as DateTimeWithAggregatesFilterObjectSchema } from './DateTimeWithAggregatesFilter.schema'
const insurancecontactscalarwherewithaggregatesinputSchema = z.object({
AND: z.union([z.lazy(() => InsuranceContactScalarWhereWithAggregatesInputObjectSchema), z.lazy(() => InsuranceContactScalarWhereWithAggregatesInputObjectSchema).array()]).optional(),
OR: z.lazy(() => InsuranceContactScalarWhereWithAggregatesInputObjectSchema).array().optional(),
NOT: z.union([z.lazy(() => InsuranceContactScalarWhereWithAggregatesInputObjectSchema), z.lazy(() => InsuranceContactScalarWhereWithAggregatesInputObjectSchema).array()]).optional(),
id: z.union([z.lazy(() => IntWithAggregatesFilterObjectSchema), z.number().int()]).optional(),
userId: z.union([z.lazy(() => IntWithAggregatesFilterObjectSchema), z.number().int()]).optional(),
name: z.union([z.lazy(() => StringWithAggregatesFilterObjectSchema), z.string()]).optional(),
phoneNumber: z.union([z.lazy(() => StringNullableWithAggregatesFilterObjectSchema), z.string()]).optional().nullable(),
createdAt: z.union([z.lazy(() => DateTimeWithAggregatesFilterObjectSchema), z.coerce.date()]).optional()
}).strict();
export const InsuranceContactScalarWhereWithAggregatesInputObjectSchema: z.ZodType<Prisma.InsuranceContactScalarWhereWithAggregatesInput> = insurancecontactscalarwherewithaggregatesinputSchema as unknown as z.ZodType<Prisma.InsuranceContactScalarWhereWithAggregatesInput>;
export const InsuranceContactScalarWhereWithAggregatesInputObjectZodSchema = insurancecontactscalarwherewithaggregatesinputSchema;

14
packages/db/shared/schemas/objects/InsuranceContactSelect.schema.ts Normal file
View File

@@ -0,0 +1,14 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { UserArgsObjectSchema as UserArgsObjectSchema } from './UserArgs.schema'
const makeSchema = () => z.object({
id: z.boolean().optional(),
userId: z.boolean().optional(),
name: z.boolean().optional(),
phoneNumber: z.boolean().optional(),
createdAt: z.boolean().optional(),
user: z.union([z.boolean(), z.lazy(() => UserArgsObjectSchema)]).optional()
}).strict();
export const InsuranceContactSelectObjectSchema: z.ZodType<Prisma.InsuranceContactSelect> = makeSchema() as unknown as z.ZodType<Prisma.InsuranceContactSelect>;
export const InsuranceContactSelectObjectZodSchema = makeSchema();

10
packages/db/shared/schemas/objects/InsuranceContactSumAggregateInput.schema.ts Normal file
View File

@@ -0,0 +1,10 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
const makeSchema = () => z.object({
id: z.literal(true).optional(),
userId: z.literal(true).optional()
}).strict();
export const InsuranceContactSumAggregateInputObjectSchema: z.ZodType<Prisma.InsuranceContactSumAggregateInputType> = makeSchema() as unknown as z.ZodType<Prisma.InsuranceContactSumAggregateInputType>;
export const InsuranceContactSumAggregateInputObjectZodSchema = makeSchema();

10
packages/db/shared/schemas/objects/InsuranceContactSumOrderByAggregateInput.schema.ts Normal file
View File

@@ -0,0 +1,10 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { SortOrderSchema } from '../enums/SortOrder.schema'
const makeSchema = () => z.object({
id: SortOrderSchema.optional(),
userId: SortOrderSchema.optional()
}).strict();
export const InsuranceContactSumOrderByAggregateInputObjectSchema: z.ZodType<Prisma.InsuranceContactSumOrderByAggregateInput> = makeSchema() as unknown as z.ZodType<Prisma.InsuranceContactSumOrderByAggregateInput>;
export const InsuranceContactSumOrderByAggregateInputObjectZodSchema = makeSchema();

13
packages/db/shared/schemas/objects/InsuranceContactUncheckedCreateInput.schema.ts Normal file
View File

@@ -0,0 +1,13 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
const makeSchema = () => z.object({
id: z.number().int().optional(),
userId: z.number().int(),
name: z.string(),
phoneNumber: z.string().optional().nullable(),
createdAt: z.coerce.date().optional()
}).strict();
export const InsuranceContactUncheckedCreateInputObjectSchema: z.ZodType<Prisma.InsuranceContactUncheckedCreateInput> = makeSchema() as unknown as z.ZodType<Prisma.InsuranceContactUncheckedCreateInput>;
export const InsuranceContactUncheckedCreateInputObjectZodSchema = makeSchema();

16
packages/db/shared/schemas/objects/InsuranceContactUncheckedCreateNestedManyWithoutUserInput.schema.ts Normal file
View File

@@ -0,0 +1,16 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { InsuranceContactCreateWithoutUserInputObjectSchema as InsuranceContactCreateWithoutUserInputObjectSchema } from './InsuranceContactCreateWithoutUserInput.schema';
import { InsuranceContactUncheckedCreateWithoutUserInputObjectSchema as InsuranceContactUncheckedCreateWithoutUserInputObjectSchema } from './InsuranceContactUncheckedCreateWithoutUserInput.schema';
import { InsuranceContactCreateOrConnectWithoutUserInputObjectSchema as InsuranceContactCreateOrConnectWithoutUserInputObjectSchema } from './InsuranceContactCreateOrConnectWithoutUserInput.schema';
import { InsuranceContactCreateManyUserInputEnvelopeObjectSchema as InsuranceContactCreateManyUserInputEnvelopeObjectSchema } from './InsuranceContactCreateManyUserInputEnvelope.schema';
import { InsuranceContactWhereUniqueInputObjectSchema as InsuranceContactWhereUniqueInputObjectSchema } from './InsuranceContactWhereUniqueInput.schema'
const makeSchema = () => z.object({
create: z.union([z.lazy(() => InsuranceContactCreateWithoutUserInputObjectSchema), z.lazy(() => InsuranceContactCreateWithoutUserInputObjectSchema).array(), z.lazy(() => InsuranceContactUncheckedCreateWithoutUserInputObjectSchema), z.lazy(() => InsuranceContactUncheckedCreateWithoutUserInputObjectSchema).array()]).optional(),
connectOrCreate: z.union([z.lazy(() => InsuranceContactCreateOrConnectWithoutUserInputObjectSchema), z.lazy(() => InsuranceContactCreateOrConnectWithoutUserInputObjectSchema).array()]).optional(),
createMany: z.lazy(() => InsuranceContactCreateManyUserInputEnvelopeObjectSchema).optional(),
connect: z.union([z.lazy(() => InsuranceContactWhereUniqueInputObjectSchema), z.lazy(() => InsuranceContactWhereUniqueInputObjectSchema).array()]).optional()
}).strict();
export const InsuranceContactUncheckedCreateNestedManyWithoutUserInputObjectSchema: z.ZodType<Prisma.InsuranceContactUncheckedCreateNestedManyWithoutUserInput> = makeSchema() as unknown as z.ZodType<Prisma.InsuranceContactUncheckedCreateNestedManyWithoutUserInput>;
export const InsuranceContactUncheckedCreateNestedManyWithoutUserInputObjectZodSchema = makeSchema();

12
packages/db/shared/schemas/objects/InsuranceContactUncheckedCreateWithoutUserInput.schema.ts Normal file
View File

@@ -0,0 +1,12 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
const makeSchema = () => z.object({
id: z.number().int().optional(),
name: z.string(),
phoneNumber: z.string().optional().nullable(),
createdAt: z.coerce.date().optional()
}).strict();
export const InsuranceContactUncheckedCreateWithoutUserInputObjectSchema: z.ZodType<Prisma.InsuranceContactUncheckedCreateWithoutUserInput> = makeSchema() as unknown as z.ZodType<Prisma.InsuranceContactUncheckedCreateWithoutUserInput>;
export const InsuranceContactUncheckedCreateWithoutUserInputObjectZodSchema = makeSchema();

16
packages/db/shared/schemas/objects/InsuranceContactUncheckedUpdateInput.schema.ts Normal file
View File

@@ -0,0 +1,16 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { IntFieldUpdateOperationsInputObjectSchema as IntFieldUpdateOperationsInputObjectSchema } from './IntFieldUpdateOperationsInput.schema';
import { StringFieldUpdateOperationsInputObjectSchema as StringFieldUpdateOperationsInputObjectSchema } from './StringFieldUpdateOperationsInput.schema';
import { NullableStringFieldUpdateOperationsInputObjectSchema as NullableStringFieldUpdateOperationsInputObjectSchema } from './NullableStringFieldUpdateOperationsInput.schema';
import { DateTimeFieldUpdateOperationsInputObjectSchema as DateTimeFieldUpdateOperationsInputObjectSchema } from './DateTimeFieldUpdateOperationsInput.schema'
const makeSchema = () => z.object({
id: z.union([z.number().int(), z.lazy(() => IntFieldUpdateOperationsInputObjectSchema)]).optional(),
userId: z.union([z.number().int(), z.lazy(() => IntFieldUpdateOperationsInputObjectSchema)]).optional(),
name: z.union([z.string(), z.lazy(() => StringFieldUpdateOperationsInputObjectSchema)]).optional(),
phoneNumber: z.union([z.string(), z.lazy(() => NullableStringFieldUpdateOperationsInputObjectSchema)]).optional().nullable(),
createdAt: z.union([z.coerce.date(), z.lazy(() => DateTimeFieldUpdateOperationsInputObjectSchema)]).optional()
}).strict();
export const InsuranceContactUncheckedUpdateInputObjectSchema: z.ZodType<Prisma.InsuranceContactUncheckedUpdateInput> = makeSchema() as unknown as z.ZodType<Prisma.InsuranceContactUncheckedUpdateInput>;
export const InsuranceContactUncheckedUpdateInputObjectZodSchema = makeSchema();

16
packages/db/shared/schemas/objects/InsuranceContactUncheckedUpdateManyInput.schema.ts Normal file
View File

@@ -0,0 +1,16 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { IntFieldUpdateOperationsInputObjectSchema as IntFieldUpdateOperationsInputObjectSchema } from './IntFieldUpdateOperationsInput.schema';
import { StringFieldUpdateOperationsInputObjectSchema as StringFieldUpdateOperationsInputObjectSchema } from './StringFieldUpdateOperationsInput.schema';
import { NullableStringFieldUpdateOperationsInputObjectSchema as NullableStringFieldUpdateOperationsInputObjectSchema } from './NullableStringFieldUpdateOperationsInput.schema';
import { DateTimeFieldUpdateOperationsInputObjectSchema as DateTimeFieldUpdateOperationsInputObjectSchema } from './DateTimeFieldUpdateOperationsInput.schema'
const makeSchema = () => z.object({
id: z.union([z.number().int(), z.lazy(() => IntFieldUpdateOperationsInputObjectSchema)]).optional(),
userId: z.union([z.number().int(), z.lazy(() => IntFieldUpdateOperationsInputObjectSchema)]).optional(),
name: z.union([z.string(), z.lazy(() => StringFieldUpdateOperationsInputObjectSchema)]).optional(),
phoneNumber: z.union([z.string(), z.lazy(() => NullableStringFieldUpdateOperationsInputObjectSchema)]).optional().nullable(),
createdAt: z.union([z.coerce.date(), z.lazy(() => DateTimeFieldUpdateOperationsInputObjectSchema)]).optional()
}).strict();
export const InsuranceContactUncheckedUpdateManyInputObjectSchema: z.ZodType<Prisma.InsuranceContactUncheckedUpdateManyInput> = makeSchema() as unknown as z.ZodType<Prisma.InsuranceContactUncheckedUpdateManyInput>;
export const InsuranceContactUncheckedUpdateManyInputObjectZodSchema = makeSchema();

15
packages/db/shared/schemas/objects/InsuranceContactUncheckedUpdateManyWithoutUserInput.schema.ts Normal file
View File

@@ -0,0 +1,15 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { IntFieldUpdateOperationsInputObjectSchema as IntFieldUpdateOperationsInputObjectSchema } from './IntFieldUpdateOperationsInput.schema';
import { StringFieldUpdateOperationsInputObjectSchema as StringFieldUpdateOperationsInputObjectSchema } from './StringFieldUpdateOperationsInput.schema';
import { NullableStringFieldUpdateOperationsInputObjectSchema as NullableStringFieldUpdateOperationsInputObjectSchema } from './NullableStringFieldUpdateOperationsInput.schema';
import { DateTimeFieldUpdateOperationsInputObjectSchema as DateTimeFieldUpdateOperationsInputObjectSchema } from './DateTimeFieldUpdateOperationsInput.schema'
const makeSchema = () => z.object({
id: z.union([z.number().int(), z.lazy(() => IntFieldUpdateOperationsInputObjectSchema)]).optional(),
name: z.union([z.string(), z.lazy(() => StringFieldUpdateOperationsInputObjectSchema)]).optional(),
phoneNumber: z.union([z.string(), z.lazy(() => NullableStringFieldUpdateOperationsInputObjectSchema)]).optional().nullable(),
createdAt: z.union([z.coerce.date(), z.lazy(() => DateTimeFieldUpdateOperationsInputObjectSchema)]).optional()
}).strict();
export const InsuranceContactUncheckedUpdateManyWithoutUserInputObjectSchema: z.ZodType<Prisma.InsuranceContactUncheckedUpdateManyWithoutUserInput> = makeSchema() as unknown as z.ZodType<Prisma.InsuranceContactUncheckedUpdateManyWithoutUserInput>;
export const InsuranceContactUncheckedUpdateManyWithoutUserInputObjectZodSchema = makeSchema();

27
packages/db/shared/schemas/objects/InsuranceContactUncheckedUpdateManyWithoutUserNestedInput.schema.ts Normal file
View File

@@ -0,0 +1,27 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { InsuranceContactCreateWithoutUserInputObjectSchema as InsuranceContactCreateWithoutUserInputObjectSchema } from './InsuranceContactCreateWithoutUserInput.schema';
import { InsuranceContactUncheckedCreateWithoutUserInputObjectSchema as InsuranceContactUncheckedCreateWithoutUserInputObjectSchema } from './InsuranceContactUncheckedCreateWithoutUserInput.schema';
import { InsuranceContactCreateOrConnectWithoutUserInputObjectSchema as InsuranceContactCreateOrConnectWithoutUserInputObjectSchema } from './InsuranceContactCreateOrConnectWithoutUserInput.schema';
import { InsuranceContactUpsertWithWhereUniqueWithoutUserInputObjectSchema as InsuranceContactUpsertWithWhereUniqueWithoutUserInputObjectSchema } from './InsuranceContactUpsertWithWhereUniqueWithoutUserInput.schema';
import { InsuranceContactCreateManyUserInputEnvelopeObjectSchema as InsuranceContactCreateManyUserInputEnvelopeObjectSchema } from './InsuranceContactCreateManyUserInputEnvelope.schema';
import { InsuranceContactWhereUniqueInputObjectSchema as InsuranceContactWhereUniqueInputObjectSchema } from './InsuranceContactWhereUniqueInput.schema';
import { InsuranceContactUpdateWithWhereUniqueWithoutUserInputObjectSchema as InsuranceContactUpdateWithWhereUniqueWithoutUserInputObjectSchema } from './InsuranceContactUpdateWithWhereUniqueWithoutUserInput.schema';
import { InsuranceContactUpdateManyWithWhereWithoutUserInputObjectSchema as InsuranceContactUpdateManyWithWhereWithoutUserInputObjectSchema } from './InsuranceContactUpdateManyWithWhereWithoutUserInput.schema';
import { InsuranceContactScalarWhereInputObjectSchema as InsuranceContactScalarWhereInputObjectSchema } from './InsuranceContactScalarWhereInput.schema'
const makeSchema = () => z.object({
create: z.union([z.lazy(() => InsuranceContactCreateWithoutUserInputObjectSchema), z.lazy(() => InsuranceContactCreateWithoutUserInputObjectSchema).array(), z.lazy(() => InsuranceContactUncheckedCreateWithoutUserInputObjectSchema), z.lazy(() => InsuranceContactUncheckedCreateWithoutUserInputObjectSchema).array()]).optional(),
connectOrCreate: z.union([z.lazy(() => InsuranceContactCreateOrConnectWithoutUserInputObjectSchema), z.lazy(() => InsuranceContactCreateOrConnectWithoutUserInputObjectSchema).array()]).optional(),
upsert: z.union([z.lazy(() => InsuranceContactUpsertWithWhereUniqueWithoutUserInputObjectSchema), z.lazy(() => InsuranceContactUpsertWithWhereUniqueWithoutUserInputObjectSchema).array()]).optional(),
createMany: z.lazy(() => InsuranceContactCreateManyUserInputEnvelopeObjectSchema).optional(),
set: z.union([z.lazy(() => InsuranceContactWhereUniqueInputObjectSchema), z.lazy(() => InsuranceContactWhereUniqueInputObjectSchema).array()]).optional(),
disconnect: z.union([z.lazy(() => InsuranceContactWhereUniqueInputObjectSchema), z.lazy(() => InsuranceContactWhereUniqueInputObjectSchema).array()]).optional(),
delete: z.union([z.lazy(() => InsuranceContactWhereUniqueInputObjectSchema), z.lazy(() => InsuranceContactWhereUniqueInputObjectSchema).array()]).optional(),
connect: z.union([z.lazy(() => InsuranceContactWhereUniqueInputObjectSchema), z.lazy(() => InsuranceContactWhereUniqueInputObjectSchema).array()]).optional(),
update: z.union([z.lazy(() => InsuranceContactUpdateWithWhereUniqueWithoutUserInputObjectSchema), z.lazy(() => InsuranceContactUpdateWithWhereUniqueWithoutUserInputObjectSchema).array()]).optional(),
updateMany: z.union([z.lazy(() => InsuranceContactUpdateManyWithWhereWithoutUserInputObjectSchema), z.lazy(() => InsuranceContactUpdateManyWithWhereWithoutUserInputObjectSchema).array()]).optional(),
deleteMany: z.union([z.lazy(() => InsuranceContactScalarWhereInputObjectSchema), z.lazy(() => InsuranceContactScalarWhereInputObjectSchema).array()]).optional()
}).strict();
export const InsuranceContactUncheckedUpdateManyWithoutUserNestedInputObjectSchema: z.ZodType<Prisma.InsuranceContactUncheckedUpdateManyWithoutUserNestedInput> = makeSchema() as unknown as z.ZodType<Prisma.InsuranceContactUncheckedUpdateManyWithoutUserNestedInput>;
export const InsuranceContactUncheckedUpdateManyWithoutUserNestedInputObjectZodSchema = makeSchema();

15
packages/db/shared/schemas/objects/InsuranceContactUncheckedUpdateWithoutUserInput.schema.ts Normal file
View File

@@ -0,0 +1,15 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { IntFieldUpdateOperationsInputObjectSchema as IntFieldUpdateOperationsInputObjectSchema } from './IntFieldUpdateOperationsInput.schema';
import { StringFieldUpdateOperationsInputObjectSchema as StringFieldUpdateOperationsInputObjectSchema } from './StringFieldUpdateOperationsInput.schema';
import { NullableStringFieldUpdateOperationsInputObjectSchema as NullableStringFieldUpdateOperationsInputObjectSchema } from './NullableStringFieldUpdateOperationsInput.schema';
import { DateTimeFieldUpdateOperationsInputObjectSchema as DateTimeFieldUpdateOperationsInputObjectSchema } from './DateTimeFieldUpdateOperationsInput.schema'
const makeSchema = () => z.object({
id: z.union([z.number().int(), z.lazy(() => IntFieldUpdateOperationsInputObjectSchema)]).optional(),
name: z.union([z.string(), z.lazy(() => StringFieldUpdateOperationsInputObjectSchema)]).optional(),
phoneNumber: z.union([z.string(), z.lazy(() => NullableStringFieldUpdateOperationsInputObjectSchema)]).optional().nullable(),
createdAt: z.union([z.coerce.date(), z.lazy(() => DateTimeFieldUpdateOperationsInputObjectSchema)]).optional()
}).strict();
export const InsuranceContactUncheckedUpdateWithoutUserInputObjectSchema: z.ZodType<Prisma.InsuranceContactUncheckedUpdateWithoutUserInput> = makeSchema() as unknown as z.ZodType<Prisma.InsuranceContactUncheckedUpdateWithoutUserInput>;
export const InsuranceContactUncheckedUpdateWithoutUserInputObjectZodSchema = makeSchema();

15
packages/db/shared/schemas/objects/InsuranceContactUpdateInput.schema.ts Normal file
View File

@@ -0,0 +1,15 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { StringFieldUpdateOperationsInputObjectSchema as StringFieldUpdateOperationsInputObjectSchema } from './StringFieldUpdateOperationsInput.schema';
import { NullableStringFieldUpdateOperationsInputObjectSchema as NullableStringFieldUpdateOperationsInputObjectSchema } from './NullableStringFieldUpdateOperationsInput.schema';
import { DateTimeFieldUpdateOperationsInputObjectSchema as DateTimeFieldUpdateOperationsInputObjectSchema } from './DateTimeFieldUpdateOperationsInput.schema';
import { UserUpdateOneRequiredWithoutInsuranceContactsNestedInputObjectSchema as UserUpdateOneRequiredWithoutInsuranceContactsNestedInputObjectSchema } from './UserUpdateOneRequiredWithoutInsuranceContactsNestedInput.schema'
const makeSchema = () => z.object({
name: z.union([z.string(), z.lazy(() => StringFieldUpdateOperationsInputObjectSchema)]).optional(),
phoneNumber: z.union([z.string(), z.lazy(() => NullableStringFieldUpdateOperationsInputObjectSchema)]).optional().nullable(),
createdAt: z.union([z.coerce.date(), z.lazy(() => DateTimeFieldUpdateOperationsInputObjectSchema)]).optional(),
user: z.lazy(() => UserUpdateOneRequiredWithoutInsuranceContactsNestedInputObjectSchema).optional()
}).strict();
export const InsuranceContactUpdateInputObjectSchema: z.ZodType<Prisma.InsuranceContactUpdateInput> = makeSchema() as unknown as z.ZodType<Prisma.InsuranceContactUpdateInput>;
export const InsuranceContactUpdateInputObjectZodSchema = makeSchema();

13
packages/db/shared/schemas/objects/InsuranceContactUpdateManyMutationInput.schema.ts Normal file
View File

@@ -0,0 +1,13 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { StringFieldUpdateOperationsInputObjectSchema as StringFieldUpdateOperationsInputObjectSchema } from './StringFieldUpdateOperationsInput.schema';
import { NullableStringFieldUpdateOperationsInputObjectSchema as NullableStringFieldUpdateOperationsInputObjectSchema } from './NullableStringFieldUpdateOperationsInput.schema';
import { DateTimeFieldUpdateOperationsInputObjectSchema as DateTimeFieldUpdateOperationsInputObjectSchema } from './DateTimeFieldUpdateOperationsInput.schema'
const makeSchema = () => z.object({
name: z.union([z.string(), z.lazy(() => StringFieldUpdateOperationsInputObjectSchema)]).optional(),
phoneNumber: z.union([z.string(), z.lazy(() => NullableStringFieldUpdateOperationsInputObjectSchema)]).optional().nullable(),
createdAt: z.union([z.coerce.date(), z.lazy(() => DateTimeFieldUpdateOperationsInputObjectSchema)]).optional()
}).strict();
export const InsuranceContactUpdateManyMutationInputObjectSchema: z.ZodType<Prisma.InsuranceContactUpdateManyMutationInput> = makeSchema() as unknown as z.ZodType<Prisma.InsuranceContactUpdateManyMutationInput>;
export const InsuranceContactUpdateManyMutationInputObjectZodSchema = makeSchema();

12
packages/db/shared/schemas/objects/InsuranceContactUpdateManyWithWhereWithoutUserInput.schema.ts Normal file
View File

@@ -0,0 +1,12 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { InsuranceContactScalarWhereInputObjectSchema as InsuranceContactScalarWhereInputObjectSchema } from './InsuranceContactScalarWhereInput.schema';
import { InsuranceContactUpdateManyMutationInputObjectSchema as InsuranceContactUpdateManyMutationInputObjectSchema } from './InsuranceContactUpdateManyMutationInput.schema';
import { InsuranceContactUncheckedUpdateManyWithoutUserInputObjectSchema as InsuranceContactUncheckedUpdateManyWithoutUserInputObjectSchema } from './InsuranceContactUncheckedUpdateManyWithoutUserInput.schema'
const makeSchema = () => z.object({
where: z.lazy(() => InsuranceContactScalarWhereInputObjectSchema),
data: z.union([z.lazy(() => InsuranceContactUpdateManyMutationInputObjectSchema), z.lazy(() => InsuranceContactUncheckedUpdateManyWithoutUserInputObjectSchema)])
}).strict();
export const InsuranceContactUpdateManyWithWhereWithoutUserInputObjectSchema: z.ZodType<Prisma.InsuranceContactUpdateManyWithWhereWithoutUserInput> = makeSchema() as unknown as z.ZodType<Prisma.InsuranceContactUpdateManyWithWhereWithoutUserInput>;
export const InsuranceContactUpdateManyWithWhereWithoutUserInputObjectZodSchema = makeSchema();

27
packages/db/shared/schemas/objects/InsuranceContactUpdateManyWithoutUserNestedInput.schema.ts Normal file
View File

@@ -0,0 +1,27 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { InsuranceContactCreateWithoutUserInputObjectSchema as InsuranceContactCreateWithoutUserInputObjectSchema } from './InsuranceContactCreateWithoutUserInput.schema';
import { InsuranceContactUncheckedCreateWithoutUserInputObjectSchema as InsuranceContactUncheckedCreateWithoutUserInputObjectSchema } from './InsuranceContactUncheckedCreateWithoutUserInput.schema';
import { InsuranceContactCreateOrConnectWithoutUserInputObjectSchema as InsuranceContactCreateOrConnectWithoutUserInputObjectSchema } from './InsuranceContactCreateOrConnectWithoutUserInput.schema';
import { InsuranceContactUpsertWithWhereUniqueWithoutUserInputObjectSchema as InsuranceContactUpsertWithWhereUniqueWithoutUserInputObjectSchema } from './InsuranceContactUpsertWithWhereUniqueWithoutUserInput.schema';
import { InsuranceContactCreateManyUserInputEnvelopeObjectSchema as InsuranceContactCreateManyUserInputEnvelopeObjectSchema } from './InsuranceContactCreateManyUserInputEnvelope.schema';
import { InsuranceContactWhereUniqueInputObjectSchema as InsuranceContactWhereUniqueInputObjectSchema } from './InsuranceContactWhereUniqueInput.schema';
import { InsuranceContactUpdateWithWhereUniqueWithoutUserInputObjectSchema as InsuranceContactUpdateWithWhereUniqueWithoutUserInputObjectSchema } from './InsuranceContactUpdateWithWhereUniqueWithoutUserInput.schema';
import { InsuranceContactUpdateManyWithWhereWithoutUserInputObjectSchema as InsuranceContactUpdateManyWithWhereWithoutUserInputObjectSchema } from './InsuranceContactUpdateManyWithWhereWithoutUserInput.schema';
import { InsuranceContactScalarWhereInputObjectSchema as InsuranceContactScalarWhereInputObjectSchema } from './InsuranceContactScalarWhereInput.schema'
const makeSchema = () => z.object({
create: z.union([z.lazy(() => InsuranceContactCreateWithoutUserInputObjectSchema), z.lazy(() => InsuranceContactCreateWithoutUserInputObjectSchema).array(), z.lazy(() => InsuranceContactUncheckedCreateWithoutUserInputObjectSchema), z.lazy(() => InsuranceContactUncheckedCreateWithoutUserInputObjectSchema).array()]).optional(),
connectOrCreate: z.union([z.lazy(() => InsuranceContactCreateOrConnectWithoutUserInputObjectSchema), z.lazy(() => InsuranceContactCreateOrConnectWithoutUserInputObjectSchema).array()]).optional(),
upsert: z.union([z.lazy(() => InsuranceContactUpsertWithWhereUniqueWithoutUserInputObjectSchema), z.lazy(() => InsuranceContactUpsertWithWhereUniqueWithoutUserInputObjectSchema).array()]).optional(),
createMany: z.lazy(() => InsuranceContactCreateManyUserInputEnvelopeObjectSchema).optional(),
set: z.union([z.lazy(() => InsuranceContactWhereUniqueInputObjectSchema), z.lazy(() => InsuranceContactWhereUniqueInputObjectSchema).array()]).optional(),
disconnect: z.union([z.lazy(() => InsuranceContactWhereUniqueInputObjectSchema), z.lazy(() => InsuranceContactWhereUniqueInputObjectSchema).array()]).optional(),
delete: z.union([z.lazy(() => InsuranceContactWhereUniqueInputObjectSchema), z.lazy(() => InsuranceContactWhereUniqueInputObjectSchema).array()]).optional(),
connect: z.union([z.lazy(() => InsuranceContactWhereUniqueInputObjectSchema), z.lazy(() => InsuranceContactWhereUniqueInputObjectSchema).array()]).optional(),
update: z.union([z.lazy(() => InsuranceContactUpdateWithWhereUniqueWithoutUserInputObjectSchema), z.lazy(() => InsuranceContactUpdateWithWhereUniqueWithoutUserInputObjectSchema).array()]).optional(),
updateMany: z.union([z.lazy(() => InsuranceContactUpdateManyWithWhereWithoutUserInputObjectSchema), z.lazy(() => InsuranceContactUpdateManyWithWhereWithoutUserInputObjectSchema).array()]).optional(),
deleteMany: z.union([z.lazy(() => InsuranceContactScalarWhereInputObjectSchema), z.lazy(() => InsuranceContactScalarWhereInputObjectSchema).array()]).optional()
}).strict();
export const InsuranceContactUpdateManyWithoutUserNestedInputObjectSchema: z.ZodType<Prisma.InsuranceContactUpdateManyWithoutUserNestedInput> = makeSchema() as unknown as z.ZodType<Prisma.InsuranceContactUpdateManyWithoutUserNestedInput>;
export const InsuranceContactUpdateManyWithoutUserNestedInputObjectZodSchema = makeSchema();

12
packages/db/shared/schemas/objects/InsuranceContactUpdateWithWhereUniqueWithoutUserInput.schema.ts Normal file
View File

@@ -0,0 +1,12 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { InsuranceContactWhereUniqueInputObjectSchema as InsuranceContactWhereUniqueInputObjectSchema } from './InsuranceContactWhereUniqueInput.schema';
import { InsuranceContactUpdateWithoutUserInputObjectSchema as InsuranceContactUpdateWithoutUserInputObjectSchema } from './InsuranceContactUpdateWithoutUserInput.schema';
import { InsuranceContactUncheckedUpdateWithoutUserInputObjectSchema as InsuranceContactUncheckedUpdateWithoutUserInputObjectSchema } from './InsuranceContactUncheckedUpdateWithoutUserInput.schema'
const makeSchema = () => z.object({
where: z.lazy(() => InsuranceContactWhereUniqueInputObjectSchema),
data: z.union([z.lazy(() => InsuranceContactUpdateWithoutUserInputObjectSchema), z.lazy(() => InsuranceContactUncheckedUpdateWithoutUserInputObjectSchema)])
}).strict();
export const InsuranceContactUpdateWithWhereUniqueWithoutUserInputObjectSchema: z.ZodType<Prisma.InsuranceContactUpdateWithWhereUniqueWithoutUserInput> = makeSchema() as unknown as z.ZodType<Prisma.InsuranceContactUpdateWithWhereUniqueWithoutUserInput>;
export const InsuranceContactUpdateWithWhereUniqueWithoutUserInputObjectZodSchema = makeSchema();

13
packages/db/shared/schemas/objects/InsuranceContactUpdateWithoutUserInput.schema.ts Normal file
View File

@@ -0,0 +1,13 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { StringFieldUpdateOperationsInputObjectSchema as StringFieldUpdateOperationsInputObjectSchema } from './StringFieldUpdateOperationsInput.schema';
import { NullableStringFieldUpdateOperationsInputObjectSchema as NullableStringFieldUpdateOperationsInputObjectSchema } from './NullableStringFieldUpdateOperationsInput.schema';
import { DateTimeFieldUpdateOperationsInputObjectSchema as DateTimeFieldUpdateOperationsInputObjectSchema } from './DateTimeFieldUpdateOperationsInput.schema'
const makeSchema = () => z.object({
name: z.union([z.string(), z.lazy(() => StringFieldUpdateOperationsInputObjectSchema)]).optional(),
phoneNumber: z.union([z.string(), z.lazy(() => NullableStringFieldUpdateOperationsInputObjectSchema)]).optional().nullable(),
createdAt: z.union([z.coerce.date(), z.lazy(() => DateTimeFieldUpdateOperationsInputObjectSchema)]).optional()
}).strict();
export const InsuranceContactUpdateWithoutUserInputObjectSchema: z.ZodType<Prisma.InsuranceContactUpdateWithoutUserInput> = makeSchema() as unknown as z.ZodType<Prisma.InsuranceContactUpdateWithoutUserInput>;
export const InsuranceContactUpdateWithoutUserInputObjectZodSchema = makeSchema();

15
packages/db/shared/schemas/objects/InsuranceContactUpsertWithWhereUniqueWithoutUserInput.schema.ts Normal file
View File

@@ -0,0 +1,15 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { InsuranceContactWhereUniqueInputObjectSchema as InsuranceContactWhereUniqueInputObjectSchema } from './InsuranceContactWhereUniqueInput.schema';
import { InsuranceContactUpdateWithoutUserInputObjectSchema as InsuranceContactUpdateWithoutUserInputObjectSchema } from './InsuranceContactUpdateWithoutUserInput.schema';
import { InsuranceContactUncheckedUpdateWithoutUserInputObjectSchema as InsuranceContactUncheckedUpdateWithoutUserInputObjectSchema } from './InsuranceContactUncheckedUpdateWithoutUserInput.schema';
import { InsuranceContactCreateWithoutUserInputObjectSchema as InsuranceContactCreateWithoutUserInputObjectSchema } from './InsuranceContactCreateWithoutUserInput.schema';
import { InsuranceContactUncheckedCreateWithoutUserInputObjectSchema as InsuranceContactUncheckedCreateWithoutUserInputObjectSchema } from './InsuranceContactUncheckedCreateWithoutUserInput.schema'
const makeSchema = () => z.object({
where: z.lazy(() => InsuranceContactWhereUniqueInputObjectSchema),
update: z.union([z.lazy(() => InsuranceContactUpdateWithoutUserInputObjectSchema), z.lazy(() => InsuranceContactUncheckedUpdateWithoutUserInputObjectSchema)]),
create: z.union([z.lazy(() => InsuranceContactCreateWithoutUserInputObjectSchema), z.lazy(() => InsuranceContactUncheckedCreateWithoutUserInputObjectSchema)])
}).strict();
export const InsuranceContactUpsertWithWhereUniqueWithoutUserInputObjectSchema: z.ZodType<Prisma.InsuranceContactUpsertWithWhereUniqueWithoutUserInput> = makeSchema() as unknown as z.ZodType<Prisma.InsuranceContactUpsertWithWhereUniqueWithoutUserInput>;
export const InsuranceContactUpsertWithWhereUniqueWithoutUserInputObjectZodSchema = makeSchema();

22
packages/db/shared/schemas/objects/InsuranceContactWhereInput.schema.ts Normal file
View File

@@ -0,0 +1,22 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { IntFilterObjectSchema as IntFilterObjectSchema } from './IntFilter.schema';
import { StringFilterObjectSchema as StringFilterObjectSchema } from './StringFilter.schema';
import { StringNullableFilterObjectSchema as StringNullableFilterObjectSchema } from './StringNullableFilter.schema';
import { DateTimeFilterObjectSchema as DateTimeFilterObjectSchema } from './DateTimeFilter.schema';
import { UserScalarRelationFilterObjectSchema as UserScalarRelationFilterObjectSchema } from './UserScalarRelationFilter.schema';
import { UserWhereInputObjectSchema as UserWhereInputObjectSchema } from './UserWhereInput.schema'
const insurancecontactwhereinputSchema = z.object({
AND: z.union([z.lazy(() => InsuranceContactWhereInputObjectSchema), z.lazy(() => InsuranceContactWhereInputObjectSchema).array()]).optional(),
OR: z.lazy(() => InsuranceContactWhereInputObjectSchema).array().optional(),
NOT: z.union([z.lazy(() => InsuranceContactWhereInputObjectSchema), z.lazy(() => InsuranceContactWhereInputObjectSchema).array()]).optional(),
id: z.union([z.lazy(() => IntFilterObjectSchema), z.number().int()]).optional(),
userId: z.union([z.lazy(() => IntFilterObjectSchema), z.number().int()]).optional(),
name: z.union([z.lazy(() => StringFilterObjectSchema), z.string()]).optional(),
phoneNumber: z.union([z.lazy(() => StringNullableFilterObjectSchema), z.string()]).optional().nullable(),
createdAt: z.union([z.lazy(() => DateTimeFilterObjectSchema), z.coerce.date()]).optional(),
user: z.union([z.lazy(() => UserScalarRelationFilterObjectSchema), z.lazy(() => UserWhereInputObjectSchema)]).optional()
}).strict();
export const InsuranceContactWhereInputObjectSchema: z.ZodType<Prisma.InsuranceContactWhereInput> = insurancecontactwhereinputSchema as unknown as z.ZodType<Prisma.InsuranceContactWhereInput>;
export const InsuranceContactWhereInputObjectZodSchema = insurancecontactwhereinputSchema;

9
packages/db/shared/schemas/objects/InsuranceContactWhereUniqueInput.schema.ts Normal file
View File

@@ -0,0 +1,9 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
const makeSchema = () => z.object({
id: z.number().int().optional()
}).strict();
export const InsuranceContactWhereUniqueInputObjectSchema: z.ZodType<Prisma.InsuranceContactWhereUniqueInput> = makeSchema() as unknown as z.ZodType<Prisma.InsuranceContactWhereUniqueInput>;
export const InsuranceContactWhereUniqueInputObjectZodSchema = makeSchema();

1
packages/db/shared/schemas/objects/OfficeContactCountAggregateInput.schema.ts
View File

@@ -5,6 +5,7 @@ import type { Prisma } from '../../../generated/prisma';
const makeSchema = () => z.object({
id: z.literal(true).optional(),
userId: z.literal(true).optional(),
officeName: z.literal(true).optional(),
receptionistName: z.literal(true).optional(),
dentistName: z.literal(true).optional(),
phoneNumber: z.literal(true).optional(),

1
packages/db/shared/schemas/objects/OfficeContactCountOrderByAggregateInput.schema.ts
View File

@@ -5,6 +5,7 @@ import { SortOrderSchema } from '../enums/SortOrder.schema'
const makeSchema = () => z.object({
id: SortOrderSchema.optional(),
userId: SortOrderSchema.optional(),
officeName: SortOrderSchema.optional(),
receptionistName: SortOrderSchema.optional(),
dentistName: SortOrderSchema.optional(),
phoneNumber: SortOrderSchema.optional(),

1
packages/db/shared/schemas/objects/OfficeContactCreateInput.schema.ts
View File

@@ -3,6 +3,7 @@ import type { Prisma } from '../../../generated/prisma';
import { UserCreateNestedOneWithoutOfficeContactInputObjectSchema as UserCreateNestedOneWithoutOfficeContactInputObjectSchema } from './UserCreateNestedOneWithoutOfficeContactInput.schema'
const makeSchema = () => z.object({
officeName: z.string().optional().nullable(),
receptionistName: z.string().optional().nullable(),
dentistName: z.string().optional().nullable(),
phoneNumber: z.string().optional().nullable(),

1
packages/db/shared/schemas/objects/OfficeContactCreateManyInput.schema.ts
View File

@@ -5,6 +5,7 @@ import type { Prisma } from '../../../generated/prisma';
const makeSchema = () => z.object({
id: z.number().int().optional(),
userId: z.number().int(),
officeName: z.string().optional().nullable(),
receptionistName: z.string().optional().nullable(),
dentistName: z.string().optional().nullable(),
phoneNumber: z.string().optional().nullable(),

1
packages/db/shared/schemas/objects/OfficeContactCreateWithoutUserInput.schema.ts
View File

@@ -3,6 +3,7 @@ import type { Prisma } from '../../../generated/prisma';
const makeSchema = () => z.object({
officeName: z.string().optional().nullable(),
receptionistName: z.string().optional().nullable(),
dentistName: z.string().optional().nullable(),
phoneNumber: z.string().optional().nullable(),

1
packages/db/shared/schemas/objects/OfficeContactMaxAggregateInput.schema.ts
View File

@@ -5,6 +5,7 @@ import type { Prisma } from '../../../generated/prisma';
const makeSchema = () => z.object({
id: z.literal(true).optional(),
userId: z.literal(true).optional(),
officeName: z.literal(true).optional(),
receptionistName: z.literal(true).optional(),
dentistName: z.literal(true).optional(),
phoneNumber: z.literal(true).optional(),

1
packages/db/shared/schemas/objects/OfficeContactMaxOrderByAggregateInput.schema.ts
View File

@@ -5,6 +5,7 @@ import { SortOrderSchema } from '../enums/SortOrder.schema'
const makeSchema = () => z.object({
id: SortOrderSchema.optional(),
userId: SortOrderSchema.optional(),
officeName: SortOrderSchema.optional(),
receptionistName: SortOrderSchema.optional(),
dentistName: SortOrderSchema.optional(),
phoneNumber: SortOrderSchema.optional(),

1
packages/db/shared/schemas/objects/OfficeContactMinAggregateInput.schema.ts
View File

@@ -5,6 +5,7 @@ import type { Prisma } from '../../../generated/prisma';
const makeSchema = () => z.object({
id: z.literal(true).optional(),
userId: z.literal(true).optional(),
officeName: z.literal(true).optional(),
receptionistName: z.literal(true).optional(),
dentistName: z.literal(true).optional(),
phoneNumber: z.literal(true).optional(),

1
packages/db/shared/schemas/objects/OfficeContactMinOrderByAggregateInput.schema.ts
View File

@@ -5,6 +5,7 @@ import { SortOrderSchema } from '../enums/SortOrder.schema'
const makeSchema = () => z.object({
id: SortOrderSchema.optional(),
userId: SortOrderSchema.optional(),
officeName: SortOrderSchema.optional(),
receptionistName: SortOrderSchema.optional(),
dentistName: SortOrderSchema.optional(),
phoneNumber: SortOrderSchema.optional(),

1
packages/db/shared/schemas/objects/OfficeContactOrderByWithAggregationInput.schema.ts
View File

@@ -11,6 +11,7 @@ import { OfficeContactSumOrderByAggregateInputObjectSchema as OfficeContactSumOr
const makeSchema = () => z.object({
id: SortOrderSchema.optional(),
userId: SortOrderSchema.optional(),
officeName: z.union([SortOrderSchema, z.lazy(() => SortOrderInputObjectSchema)]).optional(),
receptionistName: z.union([SortOrderSchema, z.lazy(() => SortOrderInputObjectSchema)]).optional(),
dentistName: z.union([SortOrderSchema, z.lazy(() => SortOrderInputObjectSchema)]).optional(),
phoneNumber: z.union([SortOrderSchema, z.lazy(() => SortOrderInputObjectSchema)]).optional(),

1
packages/db/shared/schemas/objects/OfficeContactOrderByWithRelationInput.schema.ts
View File

@@ -7,6 +7,7 @@ import { UserOrderByWithRelationInputObjectSchema as UserOrderByWithRelationInpu
const makeSchema = () => z.object({
id: SortOrderSchema.optional(),
userId: SortOrderSchema.optional(),
officeName: z.union([SortOrderSchema, z.lazy(() => SortOrderInputObjectSchema)]).optional(),
receptionistName: z.union([SortOrderSchema, z.lazy(() => SortOrderInputObjectSchema)]).optional(),
dentistName: z.union([SortOrderSchema, z.lazy(() => SortOrderInputObjectSchema)]).optional(),
phoneNumber: z.union([SortOrderSchema, z.lazy(() => SortOrderInputObjectSchema)]).optional(),

1
packages/db/shared/schemas/objects/OfficeContactScalarWhereWithAggregatesInput.schema.ts
View File

@@ -9,6 +9,7 @@ const officecontactscalarwherewithaggregatesinputSchema = z.object({
NOT: z.union([z.lazy(() => OfficeContactScalarWhereWithAggregatesInputObjectSchema), z.lazy(() => OfficeContactScalarWhereWithAggregatesInputObjectSchema).array()]).optional(),
id: z.union([z.lazy(() => IntWithAggregatesFilterObjectSchema), z.number().int()]).optional(),
userId: z.union([z.lazy(() => IntWithAggregatesFilterObjectSchema), z.number().int()]).optional(),
officeName: z.union([z.lazy(() => StringNullableWithAggregatesFilterObjectSchema), z.string()]).optional().nullable(),
receptionistName: z.union([z.lazy(() => StringNullableWithAggregatesFilterObjectSchema), z.string()]).optional().nullable(),
dentistName: z.union([z.lazy(() => StringNullableWithAggregatesFilterObjectSchema), z.string()]).optional().nullable(),
phoneNumber: z.union([z.lazy(() => StringNullableWithAggregatesFilterObjectSchema), z.string()]).optional().nullable(),

1
packages/db/shared/schemas/objects/OfficeContactSelect.schema.ts
View File

@@ -5,6 +5,7 @@ import { UserArgsObjectSchema as UserArgsObjectSchema } from './UserArgs.schema'
const makeSchema = () => z.object({
id: z.boolean().optional(),
userId: z.boolean().optional(),
officeName: z.boolean().optional(),
receptionistName: z.boolean().optional(),
dentistName: z.boolean().optional(),
phoneNumber: z.boolean().optional(),

1
packages/db/shared/schemas/objects/OfficeContactUncheckedCreateInput.schema.ts
View File

@@ -5,6 +5,7 @@ import type { Prisma } from '../../../generated/prisma';
const makeSchema = () => z.object({
id: z.number().int().optional(),
userId: z.number().int(),
officeName: z.string().optional().nullable(),
receptionistName: z.string().optional().nullable(),
dentistName: z.string().optional().nullable(),
phoneNumber: z.string().optional().nullable(),

1
packages/db/shared/schemas/objects/OfficeContactUncheckedCreateWithoutUserInput.schema.ts
View File

@@ -4,6 +4,7 @@ import type { Prisma } from '../../../generated/prisma';
const makeSchema = () => z.object({
id: z.number().int().optional(),
officeName: z.string().optional().nullable(),
receptionistName: z.string().optional().nullable(),
dentistName: z.string().optional().nullable(),
phoneNumber: z.string().optional().nullable(),

1
packages/db/shared/schemas/objects/OfficeContactUncheckedUpdateInput.schema.ts
View File

@@ -6,6 +6,7 @@ import { NullableStringFieldUpdateOperationsInputObjectSchema as NullableStringF
const makeSchema = () => z.object({
id: z.union([z.number().int(), z.lazy(() => IntFieldUpdateOperationsInputObjectSchema)]).optional(),
userId: z.union([z.number().int(), z.lazy(() => IntFieldUpdateOperationsInputObjectSchema)]).optional(),
officeName: z.union([z.string(), z.lazy(() => NullableStringFieldUpdateOperationsInputObjectSchema)]).optional().nullable(),
receptionistName: z.union([z.string(), z.lazy(() => NullableStringFieldUpdateOperationsInputObjectSchema)]).optional().nullable(),
dentistName: z.union([z.string(), z.lazy(() => NullableStringFieldUpdateOperationsInputObjectSchema)]).optional().nullable(),
phoneNumber: z.union([z.string(), z.lazy(() => NullableStringFieldUpdateOperationsInputObjectSchema)]).optional().nullable(),

1
packages/db/shared/schemas/objects/OfficeContactUncheckedUpdateManyInput.schema.ts
View File

@@ -6,6 +6,7 @@ import { NullableStringFieldUpdateOperationsInputObjectSchema as NullableStringF
const makeSchema = () => z.object({
id: z.union([z.number().int(), z.lazy(() => IntFieldUpdateOperationsInputObjectSchema)]).optional(),
userId: z.union([z.number().int(), z.lazy(() => IntFieldUpdateOperationsInputObjectSchema)]).optional(),
officeName: z.union([z.string(), z.lazy(() => NullableStringFieldUpdateOperationsInputObjectSchema)]).optional().nullable(),
receptionistName: z.union([z.string(), z.lazy(() => NullableStringFieldUpdateOperationsInputObjectSchema)]).optional().nullable(),
dentistName: z.union([z.string(), z.lazy(() => NullableStringFieldUpdateOperationsInputObjectSchema)]).optional().nullable(),
phoneNumber: z.union([z.string(), z.lazy(() => NullableStringFieldUpdateOperationsInputObjectSchema)]).optional().nullable(),

1
packages/db/shared/schemas/objects/OfficeContactUncheckedUpdateWithoutUserInput.schema.ts
View File

@@ -5,6 +5,7 @@ import { NullableStringFieldUpdateOperationsInputObjectSchema as NullableStringF
const makeSchema = () => z.object({
id: z.union([z.number().int(), z.lazy(() => IntFieldUpdateOperationsInputObjectSchema)]).optional(),
officeName: z.union([z.string(), z.lazy(() => NullableStringFieldUpdateOperationsInputObjectSchema)]).optional().nullable(),
receptionistName: z.union([z.string(), z.lazy(() => NullableStringFieldUpdateOperationsInputObjectSchema)]).optional().nullable(),
dentistName: z.union([z.string(), z.lazy(() => NullableStringFieldUpdateOperationsInputObjectSchema)]).optional().nullable(),
phoneNumber: z.union([z.string(), z.lazy(() => NullableStringFieldUpdateOperationsInputObjectSchema)]).optional().nullable(),

1
packages/db/shared/schemas/objects/OfficeContactUpdateInput.schema.ts
View File

@@ -4,6 +4,7 @@ import { NullableStringFieldUpdateOperationsInputObjectSchema as NullableStringF
import { UserUpdateOneRequiredWithoutOfficeContactNestedInputObjectSchema as UserUpdateOneRequiredWithoutOfficeContactNestedInputObjectSchema } from './UserUpdateOneRequiredWithoutOfficeContactNestedInput.schema'
const makeSchema = () => z.object({
officeName: z.union([z.string(), z.lazy(() => NullableStringFieldUpdateOperationsInputObjectSchema)]).optional().nullable(),
receptionistName: z.union([z.string(), z.lazy(() => NullableStringFieldUpdateOperationsInputObjectSchema)]).optional().nullable(),
dentistName: z.union([z.string(), z.lazy(() => NullableStringFieldUpdateOperationsInputObjectSchema)]).optional().nullable(),
phoneNumber: z.union([z.string(), z.lazy(() => NullableStringFieldUpdateOperationsInputObjectSchema)]).optional().nullable(),

1
packages/db/shared/schemas/objects/OfficeContactUpdateManyMutationInput.schema.ts
View File

@@ -3,6 +3,7 @@ import type { Prisma } from '../../../generated/prisma';
import { NullableStringFieldUpdateOperationsInputObjectSchema as NullableStringFieldUpdateOperationsInputObjectSchema } from './NullableStringFieldUpdateOperationsInput.schema'
const makeSchema = () => z.object({
officeName: z.union([z.string(), z.lazy(() => NullableStringFieldUpdateOperationsInputObjectSchema)]).optional().nullable(),
receptionistName: z.union([z.string(), z.lazy(() => NullableStringFieldUpdateOperationsInputObjectSchema)]).optional().nullable(),
dentistName: z.union([z.string(), z.lazy(() => NullableStringFieldUpdateOperationsInputObjectSchema)]).optional().nullable(),
phoneNumber: z.union([z.string(), z.lazy(() => NullableStringFieldUpdateOperationsInputObjectSchema)]).optional().nullable(),

1
packages/db/shared/schemas/objects/OfficeContactUpdateWithoutUserInput.schema.ts
View File

@@ -3,6 +3,7 @@ import type { Prisma } from '../../../generated/prisma';
import { NullableStringFieldUpdateOperationsInputObjectSchema as NullableStringFieldUpdateOperationsInputObjectSchema } from './NullableStringFieldUpdateOperationsInput.schema'
const makeSchema = () => z.object({
officeName: z.union([z.string(), z.lazy(() => NullableStringFieldUpdateOperationsInputObjectSchema)]).optional().nullable(),
receptionistName: z.union([z.string(), z.lazy(() => NullableStringFieldUpdateOperationsInputObjectSchema)]).optional().nullable(),
dentistName: z.union([z.string(), z.lazy(() => NullableStringFieldUpdateOperationsInputObjectSchema)]).optional().nullable(),
phoneNumber: z.union([z.string(), z.lazy(() => NullableStringFieldUpdateOperationsInputObjectSchema)]).optional().nullable(),

1
packages/db/shared/schemas/objects/OfficeContactWhereInput.schema.ts
View File

@@ -11,6 +11,7 @@ const officecontactwhereinputSchema = z.object({
NOT: z.union([z.lazy(() => OfficeContactWhereInputObjectSchema), z.lazy(() => OfficeContactWhereInputObjectSchema).array()]).optional(),
id: z.union([z.lazy(() => IntFilterObjectSchema), z.number().int()]).optional(),
userId: z.union([z.lazy(() => IntFilterObjectSchema), z.number().int()]).optional(),
officeName: z.union([z.lazy(() => StringNullableFilterObjectSchema), z.string()]).optional().nullable(),
receptionistName: z.union([z.lazy(() => StringNullableFilterObjectSchema), z.string()]).optional().nullable(),
dentistName: z.union([z.lazy(() => StringNullableFilterObjectSchema), z.string()]).optional().nullable(),
phoneNumber: z.union([z.lazy(() => StringNullableFilterObjectSchema), z.string()]).optional().nullable(),

1
packages/db/shared/schemas/objects/PatientCountAggregateInput.schema.ts
View File

@@ -19,6 +19,7 @@ const makeSchema = () => z.object({
policyHolder: z.literal(true).optional(),
allergies: z.literal(true).optional(),
medicalConditions: z.literal(true).optional(),
preferredLanguage: z.literal(true).optional(),
status: z.literal(true).optional(),
userId: z.literal(true).optional(),
createdAt: z.literal(true).optional(),

1
packages/db/shared/schemas/objects/PatientCountOrderByAggregateInput.schema.ts
View File

@@ -19,6 +19,7 @@ const makeSchema = () => z.object({
policyHolder: SortOrderSchema.optional(),
allergies: SortOrderSchema.optional(),
medicalConditions: SortOrderSchema.optional(),
preferredLanguage: SortOrderSchema.optional(),
status: SortOrderSchema.optional(),
userId: SortOrderSchema.optional(),
createdAt: SortOrderSchema.optional(),

1
packages/db/shared/schemas/objects/PatientCreateInput.schema.ts
View File

@@ -26,6 +26,7 @@ const makeSchema = () => z.object({
policyHolder: z.string().optional().nullable(),
allergies: z.string().optional().nullable(),
medicalConditions: z.string().optional().nullable(),
preferredLanguage: z.string().optional().nullable(),
status: PatientStatusSchema.optional(),
createdAt: z.coerce.date().optional(),
user: z.lazy(() => UserCreateNestedOneWithoutPatientsInputObjectSchema),

1
packages/db/shared/schemas/objects/PatientCreateManyInput.schema.ts
View File

@@ -19,6 +19,7 @@ const makeSchema = () => z.object({
policyHolder: z.string().optional().nullable(),
allergies: z.string().optional().nullable(),
medicalConditions: z.string().optional().nullable(),
preferredLanguage: z.string().optional().nullable(),
status: PatientStatusSchema.optional(),
userId: z.number().int(),
createdAt: z.coerce.date().optional(),

1
packages/db/shared/schemas/objects/PatientCreateManyUserInput.schema.ts
View File

@@ -19,6 +19,7 @@ const makeSchema = () => z.object({
policyHolder: z.string().optional().nullable(),
allergies: z.string().optional().nullable(),
medicalConditions: z.string().optional().nullable(),
preferredLanguage: z.string().optional().nullable(),
status: PatientStatusSchema.optional(),
createdAt: z.coerce.date().optional(),
updatedAt: z.coerce.date().optional()

1
packages/db/shared/schemas/objects/PatientCreateWithoutAppointmentsInput.schema.ts
View File

@@ -25,6 +25,7 @@ const makeSchema = () => z.object({
policyHolder: z.string().optional().nullable(),
allergies: z.string().optional().nullable(),
medicalConditions: z.string().optional().nullable(),
preferredLanguage: z.string().optional().nullable(),
status: PatientStatusSchema.optional(),
createdAt: z.coerce.date().optional(),
updatedAt: z.coerce.date().optional(),

1
packages/db/shared/schemas/objects/PatientCreateWithoutClaimsInput.schema.ts
View File

@@ -25,6 +25,7 @@ const makeSchema = () => z.object({
policyHolder: z.string().optional().nullable(),
allergies: z.string().optional().nullable(),
medicalConditions: z.string().optional().nullable(),
preferredLanguage: z.string().optional().nullable(),
status: PatientStatusSchema.optional(),
createdAt: z.coerce.date().optional(),
updatedAt: z.coerce.date().optional(),

1
packages/db/shared/schemas/objects/PatientCreateWithoutCommunicationsInput.schema.ts
View File

@@ -25,6 +25,7 @@ const makeSchema = () => z.object({
policyHolder: z.string().optional().nullable(),
allergies: z.string().optional().nullable(),
medicalConditions: z.string().optional().nullable(),
preferredLanguage: z.string().optional().nullable(),
status: PatientStatusSchema.optional(),
createdAt: z.coerce.date().optional(),
updatedAt: z.coerce.date().optional(),

1
packages/db/shared/schemas/objects/PatientCreateWithoutDocumentsInput.schema.ts
View File

@@ -25,6 +25,7 @@ const makeSchema = () => z.object({
policyHolder: z.string().optional().nullable(),
allergies: z.string().optional().nullable(),
medicalConditions: z.string().optional().nullable(),
preferredLanguage: z.string().optional().nullable(),
status: PatientStatusSchema.optional(),
createdAt: z.coerce.date().optional(),
updatedAt: z.coerce.date().optional(),

Some files were not shown because too many files have changed in this diff Show More