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

feat: persist AI conversation state in DB and fix LangGraph flow bugs

Browse Source 
- Replace in-memory Maps in aiHandoffStore with DB-backed async functions
  using new patient_conversation table (stage + aiHandoff per patient)
- Add afterHoursEnabled to ai_settings table (persists across restarts)
- Fix runtime crash in reschedule-graph: mon/tue/wed variables were out
  of scope in the next-week fallback branch (ReferenceError)
- Wire rescheduleGreeting and generalFallback chat templates through to
  LangGraph nodes so user-configured messages take effect
- Add otherNode to reminder-graph to handle unclassified patient replies
  (e.g. "I want another appointment") and route to booking flow
- Fetch chatTemplates once per webhook request instead of per stage

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
This commit is contained in:
Gitead
2026-05-09 15:23:55 -04:00
parent e9296c68f9
commit 112529155c
321 changed files with 5096 additions and 446 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -0,0 +1,14 @@
import type { Prisma } from '../../generated/prisma';
import * as z from 'zod';
import { PatientConversationOrderByWithRelationInputObjectSchema as PatientConversationOrderByWithRelationInputObjectSchema } from './objects/PatientConversationOrderByWithRelationInput.schema';
import { PatientConversationWhereInputObjectSchema as PatientConversationWhereInputObjectSchema } from './objects/PatientConversationWhereInput.schema';
import { PatientConversationWhereUniqueInputObjectSchema as PatientConversationWhereUniqueInputObjectSchema } from './objects/PatientConversationWhereUniqueInput.schema';
import { PatientConversationCountAggregateInputObjectSchema as PatientConversationCountAggregateInputObjectSchema } from './objects/PatientConversationCountAggregateInput.schema';
import { PatientConversationMinAggregateInputObjectSchema as PatientConversationMinAggregateInputObjectSchema } from './objects/PatientConversationMinAggregateInput.schema';
import { PatientConversationMaxAggregateInputObjectSchema as PatientConversationMaxAggregateInputObjectSchema } from './objects/PatientConversationMaxAggregateInput.schema';
import { PatientConversationAvgAggregateInputObjectSchema as PatientConversationAvgAggregateInputObjectSchema } from './objects/PatientConversationAvgAggregateInput.schema';
import { PatientConversationSumAggregateInputObjectSchema as PatientConversationSumAggregateInputObjectSchema } from './objects/PatientConversationSumAggregateInput.schema';
export const PatientConversationAggregateSchema: z.ZodType<Prisma.PatientConversationAggregateArgs> = z.object({ orderBy: z.union([PatientConversationOrderByWithRelationInputObjectSchema, PatientConversationOrderByWithRelationInputObjectSchema.array()]).optional(), where: PatientConversationWhereInputObjectSchema.optional(), cursor: PatientConversationWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), _count: z.union([ z.literal(true), PatientConversationCountAggregateInputObjectSchema ]).optional(), _min: PatientConversationMinAggregateInputObjectSchema.optional(), _max: PatientConversationMaxAggregateInputObjectSchema.optional(), _avg: PatientConversationAvgAggregateInputObjectSchema.optional(), _sum: PatientConversationSumAggregateInputObjectSchema.optional() }).strict() as unknown as z.ZodType<Prisma.PatientConversationAggregateArgs>;
export const PatientConversationAggregateZodSchema = z.object({ orderBy: z.union([PatientConversationOrderByWithRelationInputObjectSchema, PatientConversationOrderByWithRelationInputObjectSchema.array()]).optional(), where: PatientConversationWhereInputObjectSchema.optional(), cursor: PatientConversationWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), _count: z.union([ z.literal(true), PatientConversationCountAggregateInputObjectSchema ]).optional(), _min: PatientConversationMinAggregateInputObjectSchema.optional(), _max: PatientConversationMaxAggregateInputObjectSchema.optional(), _avg: PatientConversationAvgAggregateInputObjectSchema.optional(), _sum: PatientConversationSumAggregateInputObjectSchema.optional() }).strict();

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

@@ -0,0 +1,10 @@
import type { Prisma } from '../../generated/prisma';
import * as z from 'zod';
import { PatientConversationOrderByWithRelationInputObjectSchema as PatientConversationOrderByWithRelationInputObjectSchema } from './objects/PatientConversationOrderByWithRelationInput.schema';
import { PatientConversationWhereInputObjectSchema as PatientConversationWhereInputObjectSchema } from './objects/PatientConversationWhereInput.schema';
import { PatientConversationWhereUniqueInputObjectSchema as PatientConversationWhereUniqueInputObjectSchema } from './objects/PatientConversationWhereUniqueInput.schema';
import { PatientConversationCountAggregateInputObjectSchema as PatientConversationCountAggregateInputObjectSchema } from './objects/PatientConversationCountAggregateInput.schema';
export const PatientConversationCountSchema: z.ZodType<Prisma.PatientConversationCountArgs> = z.object({ orderBy: z.union([PatientConversationOrderByWithRelationInputObjectSchema, PatientConversationOrderByWithRelationInputObjectSchema.array()]).optional(), where: PatientConversationWhereInputObjectSchema.optional(), cursor: PatientConversationWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), select: z.union([ z.literal(true), PatientConversationCountAggregateInputObjectSchema ]).optional() }).strict() as unknown as z.ZodType<Prisma.PatientConversationCountArgs>;
export const PatientConversationCountZodSchema = z.object({ orderBy: z.union([PatientConversationOrderByWithRelationInputObjectSchema, PatientConversationOrderByWithRelationInputObjectSchema.array()]).optional(), where: PatientConversationWhereInputObjectSchema.optional(), cursor: PatientConversationWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), select: z.union([ z.literal(true), PatientConversationCountAggregateInputObjectSchema ]).optional() }).strict();

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

@@ -0,0 +1,8 @@
import type { Prisma } from '../../generated/prisma';
import * as z from 'zod';
import { PatientConversationSelectObjectSchema as PatientConversationSelectObjectSchema } from './objects/PatientConversationSelect.schema';
import { PatientConversationCreateManyInputObjectSchema as PatientConversationCreateManyInputObjectSchema } from './objects/PatientConversationCreateManyInput.schema';
export const PatientConversationCreateManyAndReturnSchema: z.ZodType<Prisma.PatientConversationCreateManyAndReturnArgs> = z.object({ select: PatientConversationSelectObjectSchema.optional(), data: z.union([ PatientConversationCreateManyInputObjectSchema, z.array(PatientConversationCreateManyInputObjectSchema) ]), skipDuplicates: z.boolean().optional() }).strict() as unknown as z.ZodType<Prisma.PatientConversationCreateManyAndReturnArgs>;
export const PatientConversationCreateManyAndReturnZodSchema = z.object({ select: PatientConversationSelectObjectSchema.optional(), data: z.union([ PatientConversationCreateManyInputObjectSchema, z.array(PatientConversationCreateManyInputObjectSchema) ]), skipDuplicates: z.boolean().optional() }).strict();

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

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

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

@@ -0,0 +1,10 @@
import type { Prisma } from '../../generated/prisma';
import * as z from 'zod';
import { PatientConversationSelectObjectSchema as PatientConversationSelectObjectSchema } from './objects/PatientConversationSelect.schema';
import { PatientConversationIncludeObjectSchema as PatientConversationIncludeObjectSchema } from './objects/PatientConversationInclude.schema';
import { PatientConversationCreateInputObjectSchema as PatientConversationCreateInputObjectSchema } from './objects/PatientConversationCreateInput.schema';
import { PatientConversationUncheckedCreateInputObjectSchema as PatientConversationUncheckedCreateInputObjectSchema } from './objects/PatientConversationUncheckedCreateInput.schema';
export const PatientConversationCreateOneSchema: z.ZodType<Prisma.PatientConversationCreateArgs> = z.object({ select: PatientConversationSelectObjectSchema.optional(), include: PatientConversationIncludeObjectSchema.optional(), data: z.union([PatientConversationCreateInputObjectSchema, PatientConversationUncheckedCreateInputObjectSchema]) }).strict() as unknown as z.ZodType<Prisma.PatientConversationCreateArgs>;
export const PatientConversationCreateOneZodSchema = z.object({ select: PatientConversationSelectObjectSchema.optional(), include: PatientConversationIncludeObjectSchema.optional(), data: z.union([PatientConversationCreateInputObjectSchema, PatientConversationUncheckedCreateInputObjectSchema]) }).strict();

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

@@ -0,0 +1,7 @@
import type { Prisma } from '../../generated/prisma';
import * as z from 'zod';
import { PatientConversationWhereInputObjectSchema as PatientConversationWhereInputObjectSchema } from './objects/PatientConversationWhereInput.schema';
export const PatientConversationDeleteManySchema: z.ZodType<Prisma.PatientConversationDeleteManyArgs> = z.object({ where: PatientConversationWhereInputObjectSchema.optional() }).strict() as unknown as z.ZodType<Prisma.PatientConversationDeleteManyArgs>;
export const PatientConversationDeleteManyZodSchema = z.object({ where: PatientConversationWhereInputObjectSchema.optional() }).strict();

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

@@ -0,0 +1,9 @@
import type { Prisma } from '../../generated/prisma';
import * as z from 'zod';
import { PatientConversationSelectObjectSchema as PatientConversationSelectObjectSchema } from './objects/PatientConversationSelect.schema';
import { PatientConversationIncludeObjectSchema as PatientConversationIncludeObjectSchema } from './objects/PatientConversationInclude.schema';
import { PatientConversationWhereUniqueInputObjectSchema as PatientConversationWhereUniqueInputObjectSchema } from './objects/PatientConversationWhereUniqueInput.schema';
export const PatientConversationDeleteOneSchema: z.ZodType<Prisma.PatientConversationDeleteArgs> = z.object({ select: PatientConversationSelectObjectSchema.optional(), include: PatientConversationIncludeObjectSchema.optional(), where: PatientConversationWhereUniqueInputObjectSchema }).strict() as unknown as z.ZodType<Prisma.PatientConversationDeleteArgs>;
export const PatientConversationDeleteOneZodSchema = z.object({ select: PatientConversationSelectObjectSchema.optional(), include: PatientConversationIncludeObjectSchema.optional(), where: PatientConversationWhereUniqueInputObjectSchema }).strict();

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

@@ -1,5 +1,5 @@
import * as z from 'zod';
export const AiSettingsScalarFieldEnumSchema = z.enum(['id', 'userId', 'apiKey'])
export const AiSettingsScalarFieldEnumSchema = z.enum(['id', 'userId', 'apiKey', 'afterHoursEnabled'])
export type AiSettingsScalarFieldEnum = z.infer<typeof AiSettingsScalarFieldEnumSchema>;

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

@@ -0,0 +1,5 @@
import * as z from 'zod';
export const PatientConversationScalarFieldEnumSchema = z.enum(['id', 'patientId', 'userId', 'stage', 'aiHandoff', 'updatedAt'])
export type PatientConversationScalarFieldEnum = z.infer<typeof PatientConversationScalarFieldEnumSchema>;

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

@@ -13,6 +13,7 @@ export const AiSettingsFindFirstSelectSchema: z.ZodType<Prisma.AiSettingsSelect>
id: z.boolean().optional(),
userId: z.boolean().optional(),
apiKey: z.boolean().optional(),
afterHoursEnabled: z.boolean().optional(),
user: z.boolean().optional()
}).strict() as unknown as z.ZodType<Prisma.AiSettingsSelect>;
@@ -20,6 +21,7 @@ export const AiSettingsFindFirstSelectZodSchema = z.object({
id: z.boolean().optional(),
userId: z.boolean().optional(),
apiKey: z.boolean().optional(),
afterHoursEnabled: z.boolean().optional(),
user: z.boolean().optional()
}).strict();

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

@@ -13,6 +13,7 @@ export const AiSettingsFindFirstOrThrowSelectSchema: z.ZodType<Prisma.AiSettings
id: z.boolean().optional(),
userId: z.boolean().optional(),
apiKey: z.boolean().optional(),
afterHoursEnabled: z.boolean().optional(),
user: z.boolean().optional()
}).strict() as unknown as z.ZodType<Prisma.AiSettingsSelect>;
@@ -20,6 +21,7 @@ export const AiSettingsFindFirstOrThrowSelectZodSchema = z.object({
id: z.boolean().optional(),
userId: z.boolean().optional(),
apiKey: z.boolean().optional(),
afterHoursEnabled: z.boolean().optional(),
user: z.boolean().optional()
}).strict();

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

@@ -39,6 +39,7 @@ export const PatientFindFirstOrThrowSelectSchema: z.ZodType<Prisma.PatientSelect
payment: z.boolean().optional(),
communications: z.boolean().optional(),
documents: z.boolean().optional(),
conversation: z.boolean().optional(),
_count: z.boolean().optional()
}).strict() as unknown as z.ZodType<Prisma.PatientSelect>;
@@ -72,6 +73,7 @@ export const PatientFindFirstOrThrowSelectZodSchema = z.object({
payment: z.boolean().optional(),
communications: z.boolean().optional(),
documents: z.boolean().optional(),
conversation: z.boolean().optional(),
_count: z.boolean().optional()
}).strict();

36
packages/db/shared/schemas/findFirstOrThrowPatientConversation.schema.ts Normal file
View File

@@ -0,0 +1,36 @@
import type { Prisma } from '../../generated/prisma';
import * as z from 'zod';
import { PatientConversationIncludeObjectSchema as PatientConversationIncludeObjectSchema } from './objects/PatientConversationInclude.schema';
import { PatientConversationOrderByWithRelationInputObjectSchema as PatientConversationOrderByWithRelationInputObjectSchema } from './objects/PatientConversationOrderByWithRelationInput.schema';
import { PatientConversationWhereInputObjectSchema as PatientConversationWhereInputObjectSchema } from './objects/PatientConversationWhereInput.schema';
import { PatientConversationWhereUniqueInputObjectSchema as PatientConversationWhereUniqueInputObjectSchema } from './objects/PatientConversationWhereUniqueInput.schema';
import { PatientConversationScalarFieldEnumSchema } from './enums/PatientConversationScalarFieldEnum.schema';
// Select schema needs to be in file to prevent circular imports
//------------------------------------------------------
export const PatientConversationFindFirstOrThrowSelectSchema: z.ZodType<Prisma.PatientConversationSelect> = z.object({
id: z.boolean().optional(),
patientId: z.boolean().optional(),
userId: z.boolean().optional(),
stage: z.boolean().optional(),
aiHandoff: z.boolean().optional(),
updatedAt: z.boolean().optional(),
patient: z.boolean().optional(),
user: z.boolean().optional()
}).strict() as unknown as z.ZodType<Prisma.PatientConversationSelect>;
export const PatientConversationFindFirstOrThrowSelectZodSchema = z.object({
id: z.boolean().optional(),
patientId: z.boolean().optional(),
userId: z.boolean().optional(),
stage: z.boolean().optional(),
aiHandoff: z.boolean().optional(),
updatedAt: z.boolean().optional(),
patient: z.boolean().optional(),
user: z.boolean().optional()
}).strict();
export const PatientConversationFindFirstOrThrowSchema: z.ZodType<Prisma.PatientConversationFindFirstOrThrowArgs> = z.object({ select: PatientConversationFindFirstOrThrowSelectSchema.optional(), include: z.lazy(() => PatientConversationIncludeObjectSchema.optional()), orderBy: z.union([PatientConversationOrderByWithRelationInputObjectSchema, PatientConversationOrderByWithRelationInputObjectSchema.array()]).optional(), where: PatientConversationWhereInputObjectSchema.optional(), cursor: PatientConversationWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), distinct: z.union([PatientConversationScalarFieldEnumSchema, PatientConversationScalarFieldEnumSchema.array()]).optional() }).strict() as unknown as z.ZodType<Prisma.PatientConversationFindFirstOrThrowArgs>;
export const PatientConversationFindFirstOrThrowZodSchema = z.object({ select: PatientConversationFindFirstOrThrowSelectSchema.optional(), include: z.lazy(() => PatientConversationIncludeObjectSchema.optional()), orderBy: z.union([PatientConversationOrderByWithRelationInputObjectSchema, PatientConversationOrderByWithRelationInputObjectSchema.array()]).optional(), where: PatientConversationWhereInputObjectSchema.optional(), cursor: PatientConversationWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), distinct: z.union([PatientConversationScalarFieldEnumSchema, PatientConversationScalarFieldEnumSchema.array()]).optional() }).strict();

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

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

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

@@ -39,6 +39,7 @@ export const PatientFindFirstSelectSchema: z.ZodType<Prisma.PatientSelect> = z.o
payment: z.boolean().optional(),
communications: z.boolean().optional(),
documents: z.boolean().optional(),
conversation: z.boolean().optional(),
_count: z.boolean().optional()
}).strict() as unknown as z.ZodType<Prisma.PatientSelect>;
@@ -72,6 +73,7 @@ export const PatientFindFirstSelectZodSchema = z.object({
payment: z.boolean().optional(),
communications: z.boolean().optional(),
documents: z.boolean().optional(),
conversation: z.boolean().optional(),
_count: z.boolean().optional()
}).strict();

36
packages/db/shared/schemas/findFirstPatientConversation.schema.ts Normal file
View File

@@ -0,0 +1,36 @@
import type { Prisma } from '../../generated/prisma';
import * as z from 'zod';
import { PatientConversationIncludeObjectSchema as PatientConversationIncludeObjectSchema } from './objects/PatientConversationInclude.schema';
import { PatientConversationOrderByWithRelationInputObjectSchema as PatientConversationOrderByWithRelationInputObjectSchema } from './objects/PatientConversationOrderByWithRelationInput.schema';
import { PatientConversationWhereInputObjectSchema as PatientConversationWhereInputObjectSchema } from './objects/PatientConversationWhereInput.schema';
import { PatientConversationWhereUniqueInputObjectSchema as PatientConversationWhereUniqueInputObjectSchema } from './objects/PatientConversationWhereUniqueInput.schema';
import { PatientConversationScalarFieldEnumSchema } from './enums/PatientConversationScalarFieldEnum.schema';
// Select schema needs to be in file to prevent circular imports
//------------------------------------------------------
export const PatientConversationFindFirstSelectSchema: z.ZodType<Prisma.PatientConversationSelect> = z.object({
id: z.boolean().optional(),
patientId: z.boolean().optional(),
userId: z.boolean().optional(),
stage: z.boolean().optional(),
aiHandoff: z.boolean().optional(),
updatedAt: z.boolean().optional(),
patient: z.boolean().optional(),
user: z.boolean().optional()
}).strict() as unknown as z.ZodType<Prisma.PatientConversationSelect>;
export const PatientConversationFindFirstSelectZodSchema = z.object({
id: z.boolean().optional(),
patientId: z.boolean().optional(),
userId: z.boolean().optional(),
stage: z.boolean().optional(),
aiHandoff: z.boolean().optional(),
updatedAt: z.boolean().optional(),
patient: z.boolean().optional(),
user: z.boolean().optional()
}).strict();
export const PatientConversationFindFirstSchema: z.ZodType<Prisma.PatientConversationFindFirstArgs> = z.object({ select: PatientConversationFindFirstSelectSchema.optional(), include: z.lazy(() => PatientConversationIncludeObjectSchema.optional()), orderBy: z.union([PatientConversationOrderByWithRelationInputObjectSchema, PatientConversationOrderByWithRelationInputObjectSchema.array()]).optional(), where: PatientConversationWhereInputObjectSchema.optional(), cursor: PatientConversationWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), distinct: z.union([PatientConversationScalarFieldEnumSchema, PatientConversationScalarFieldEnumSchema.array()]).optional() }).strict() as unknown as z.ZodType<Prisma.PatientConversationFindFirstArgs>;
export const PatientConversationFindFirstZodSchema = z.object({ select: PatientConversationFindFirstSelectSchema.optional(), include: z.lazy(() => PatientConversationIncludeObjectSchema.optional()), orderBy: z.union([PatientConversationOrderByWithRelationInputObjectSchema, PatientConversationOrderByWithRelationInputObjectSchema.array()]).optional(), where: PatientConversationWhereInputObjectSchema.optional(), cursor: PatientConversationWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), distinct: z.union([PatientConversationScalarFieldEnumSchema, PatientConversationScalarFieldEnumSchema.array()]).optional() }).strict();

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

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

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

@@ -13,6 +13,7 @@ export const AiSettingsFindManySelectSchema: z.ZodType<Prisma.AiSettingsSelect>
id: z.boolean().optional(),
userId: z.boolean().optional(),
apiKey: z.boolean().optional(),
afterHoursEnabled: z.boolean().optional(),
user: z.boolean().optional()
}).strict() as unknown as z.ZodType<Prisma.AiSettingsSelect>;
@@ -20,6 +21,7 @@ export const AiSettingsFindManySelectZodSchema = z.object({
id: z.boolean().optional(),
userId: z.boolean().optional(),
apiKey: z.boolean().optional(),
afterHoursEnabled: z.boolean().optional(),
user: z.boolean().optional()
}).strict();

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

@@ -39,6 +39,7 @@ export const PatientFindManySelectSchema: z.ZodType<Prisma.PatientSelect> = z.ob
payment: z.boolean().optional(),
communications: z.boolean().optional(),
documents: z.boolean().optional(),
conversation: z.boolean().optional(),
_count: z.boolean().optional()
}).strict() as unknown as z.ZodType<Prisma.PatientSelect>;
@@ -72,6 +73,7 @@ export const PatientFindManySelectZodSchema = z.object({
payment: z.boolean().optional(),
communications: z.boolean().optional(),
documents: z.boolean().optional(),
conversation: z.boolean().optional(),
_count: z.boolean().optional()
}).strict();

36
packages/db/shared/schemas/findManyPatientConversation.schema.ts Normal file
View File

@@ -0,0 +1,36 @@
import type { Prisma } from '../../generated/prisma';
import * as z from 'zod';
import { PatientConversationIncludeObjectSchema as PatientConversationIncludeObjectSchema } from './objects/PatientConversationInclude.schema';
import { PatientConversationOrderByWithRelationInputObjectSchema as PatientConversationOrderByWithRelationInputObjectSchema } from './objects/PatientConversationOrderByWithRelationInput.schema';
import { PatientConversationWhereInputObjectSchema as PatientConversationWhereInputObjectSchema } from './objects/PatientConversationWhereInput.schema';
import { PatientConversationWhereUniqueInputObjectSchema as PatientConversationWhereUniqueInputObjectSchema } from './objects/PatientConversationWhereUniqueInput.schema';
import { PatientConversationScalarFieldEnumSchema } from './enums/PatientConversationScalarFieldEnum.schema';
// Select schema needs to be in file to prevent circular imports
//------------------------------------------------------
export const PatientConversationFindManySelectSchema: z.ZodType<Prisma.PatientConversationSelect> = z.object({
id: z.boolean().optional(),
patientId: z.boolean().optional(),
userId: z.boolean().optional(),
stage: z.boolean().optional(),
aiHandoff: z.boolean().optional(),
updatedAt: z.boolean().optional(),
patient: z.boolean().optional(),
user: z.boolean().optional()
}).strict() as unknown as z.ZodType<Prisma.PatientConversationSelect>;
export const PatientConversationFindManySelectZodSchema = z.object({
id: z.boolean().optional(),
patientId: z.boolean().optional(),
userId: z.boolean().optional(),
stage: z.boolean().optional(),
aiHandoff: z.boolean().optional(),
updatedAt: z.boolean().optional(),
patient: z.boolean().optional(),
user: z.boolean().optional()
}).strict();
export const PatientConversationFindManySchema: z.ZodType<Prisma.PatientConversationFindManyArgs> = z.object({ select: PatientConversationFindManySelectSchema.optional(), include: z.lazy(() => PatientConversationIncludeObjectSchema.optional()), orderBy: z.union([PatientConversationOrderByWithRelationInputObjectSchema, PatientConversationOrderByWithRelationInputObjectSchema.array()]).optional(), where: PatientConversationWhereInputObjectSchema.optional(), cursor: PatientConversationWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), distinct: z.union([PatientConversationScalarFieldEnumSchema, PatientConversationScalarFieldEnumSchema.array()]).optional() }).strict() as unknown as z.ZodType<Prisma.PatientConversationFindManyArgs>;
export const PatientConversationFindManyZodSchema = z.object({ select: PatientConversationFindManySelectSchema.optional(), include: z.lazy(() => PatientConversationIncludeObjectSchema.optional()), orderBy: z.union([PatientConversationOrderByWithRelationInputObjectSchema, PatientConversationOrderByWithRelationInputObjectSchema.array()]).optional(), where: PatientConversationWhereInputObjectSchema.optional(), cursor: PatientConversationWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), distinct: z.union([PatientConversationScalarFieldEnumSchema, PatientConversationScalarFieldEnumSchema.array()]).optional() }).strict();

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

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

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

@@ -0,0 +1,9 @@
import type { Prisma } from '../../generated/prisma';
import * as z from 'zod';
import { PatientConversationSelectObjectSchema as PatientConversationSelectObjectSchema } from './objects/PatientConversationSelect.schema';
import { PatientConversationIncludeObjectSchema as PatientConversationIncludeObjectSchema } from './objects/PatientConversationInclude.schema';
import { PatientConversationWhereUniqueInputObjectSchema as PatientConversationWhereUniqueInputObjectSchema } from './objects/PatientConversationWhereUniqueInput.schema';
export const PatientConversationFindUniqueOrThrowSchema: z.ZodType<Prisma.PatientConversationFindUniqueOrThrowArgs> = z.object({ select: PatientConversationSelectObjectSchema.optional(), include: PatientConversationIncludeObjectSchema.optional(), where: PatientConversationWhereUniqueInputObjectSchema }).strict() as unknown as z.ZodType<Prisma.PatientConversationFindUniqueOrThrowArgs>;
export const PatientConversationFindUniqueOrThrowZodSchema = z.object({ select: PatientConversationSelectObjectSchema.optional(), include: PatientConversationIncludeObjectSchema.optional(), where: PatientConversationWhereUniqueInputObjectSchema }).strict();

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

@@ -0,0 +1,9 @@
import type { Prisma } from '../../generated/prisma';
import * as z from 'zod';
import { PatientConversationSelectObjectSchema as PatientConversationSelectObjectSchema } from './objects/PatientConversationSelect.schema';
import { PatientConversationIncludeObjectSchema as PatientConversationIncludeObjectSchema } from './objects/PatientConversationInclude.schema';
import { PatientConversationWhereUniqueInputObjectSchema as PatientConversationWhereUniqueInputObjectSchema } from './objects/PatientConversationWhereUniqueInput.schema';
export const PatientConversationFindUniqueSchema: z.ZodType<Prisma.PatientConversationFindUniqueArgs> = z.object({ select: PatientConversationSelectObjectSchema.optional(), include: PatientConversationIncludeObjectSchema.optional(), where: PatientConversationWhereUniqueInputObjectSchema }).strict() as unknown as z.ZodType<Prisma.PatientConversationFindUniqueArgs>;
export const PatientConversationFindUniqueZodSchema = z.object({ select: PatientConversationSelectObjectSchema.optional(), include: PatientConversationIncludeObjectSchema.optional(), where: PatientConversationWhereUniqueInputObjectSchema }).strict();

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

@@ -0,0 +1,15 @@
import type { Prisma } from '../../generated/prisma';
import * as z from 'zod';
import { PatientConversationWhereInputObjectSchema as PatientConversationWhereInputObjectSchema } from './objects/PatientConversationWhereInput.schema';
import { PatientConversationOrderByWithAggregationInputObjectSchema as PatientConversationOrderByWithAggregationInputObjectSchema } from './objects/PatientConversationOrderByWithAggregationInput.schema';
import { PatientConversationScalarWhereWithAggregatesInputObjectSchema as PatientConversationScalarWhereWithAggregatesInputObjectSchema } from './objects/PatientConversationScalarWhereWithAggregatesInput.schema';
import { PatientConversationScalarFieldEnumSchema } from './enums/PatientConversationScalarFieldEnum.schema';
import { PatientConversationCountAggregateInputObjectSchema as PatientConversationCountAggregateInputObjectSchema } from './objects/PatientConversationCountAggregateInput.schema';
import { PatientConversationMinAggregateInputObjectSchema as PatientConversationMinAggregateInputObjectSchema } from './objects/PatientConversationMinAggregateInput.schema';
import { PatientConversationMaxAggregateInputObjectSchema as PatientConversationMaxAggregateInputObjectSchema } from './objects/PatientConversationMaxAggregateInput.schema';
import { PatientConversationAvgAggregateInputObjectSchema as PatientConversationAvgAggregateInputObjectSchema } from './objects/PatientConversationAvgAggregateInput.schema';
import { PatientConversationSumAggregateInputObjectSchema as PatientConversationSumAggregateInputObjectSchema } from './objects/PatientConversationSumAggregateInput.schema';
export const PatientConversationGroupBySchema: z.ZodType<Prisma.PatientConversationGroupByArgs> = z.object({ where: PatientConversationWhereInputObjectSchema.optional(), orderBy: z.union([PatientConversationOrderByWithAggregationInputObjectSchema, PatientConversationOrderByWithAggregationInputObjectSchema.array()]).optional(), having: PatientConversationScalarWhereWithAggregatesInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), by: z.array(PatientConversationScalarFieldEnumSchema), _count: z.union([ z.literal(true), PatientConversationCountAggregateInputObjectSchema ]).optional(), _min: PatientConversationMinAggregateInputObjectSchema.optional(), _max: PatientConversationMaxAggregateInputObjectSchema.optional(), _avg: PatientConversationAvgAggregateInputObjectSchema.optional(), _sum: PatientConversationSumAggregateInputObjectSchema.optional() }).strict() as unknown as z.ZodType<Prisma.PatientConversationGroupByArgs>;
export const PatientConversationGroupByZodSchema = z.object({ where: PatientConversationWhereInputObjectSchema.optional(), orderBy: z.union([PatientConversationOrderByWithAggregationInputObjectSchema, PatientConversationOrderByWithAggregationInputObjectSchema.array()]).optional(), having: PatientConversationScalarWhereWithAggregatesInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), by: z.array(PatientConversationScalarFieldEnumSchema), _count: z.union([ z.literal(true), PatientConversationCountAggregateInputObjectSchema ]).optional(), _min: PatientConversationMinAggregateInputObjectSchema.optional(), _max: PatientConversationMaxAggregateInputObjectSchema.optional(), _avg: PatientConversationAvgAggregateInputObjectSchema.optional(), _sum: PatientConversationSumAggregateInputObjectSchema.optional() }).strict();

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

@@ -29,6 +29,7 @@ export * from './enums/OfficeHoursScalarFieldEnum.schema'
export * from './enums/OfficeContactScalarFieldEnum.schema'
export * from './enums/InsuranceContactScalarFieldEnum.schema'
export * from './enums/ProcedureTimeslotScalarFieldEnum.schema'
export * from './enums/PatientConversationScalarFieldEnum.schema'
export * from './enums/SortOrder.schema'
export * from './enums/NullableJsonNullValueInput.schema'
export * from './enums/JsonNullValueInput.schema'
@@ -557,6 +558,23 @@ export * from './updateManyAndReturnProcedureTimeslot.schema'
export * from './upsertOneProcedureTimeslot.schema'
export * from './aggregateProcedureTimeslot.schema'
export * from './groupByProcedureTimeslot.schema'
export * from './findUniquePatientConversation.schema'
export * from './findUniqueOrThrowPatientConversation.schema'
export * from './findFirstPatientConversation.schema'
export * from './findFirstOrThrowPatientConversation.schema'
export * from './findManyPatientConversation.schema'
export * from './countPatientConversation.schema'
export * from './createOnePatientConversation.schema'
export * from './createManyPatientConversation.schema'
export * from './createManyAndReturnPatientConversation.schema'
export * from './deleteOnePatientConversation.schema'
export * from './deleteManyPatientConversation.schema'
export * from './updateOnePatientConversation.schema'
export * from './updateManyPatientConversation.schema'
export * from './updateManyAndReturnPatientConversation.schema'
export * from './upsertOnePatientConversation.schema'
export * from './aggregatePatientConversation.schema'
export * from './groupByPatientConversation.schema'
export * from './results/UserFindUniqueResult.schema'
export * from './results/UserFindFirstResult.schema'
export * from './results/UserFindManyResult.schema'
@@ -947,6 +965,19 @@ export * from './results/ProcedureTimeslotDeleteManyResult.schema'
export * from './results/ProcedureTimeslotAggregateResult.schema'
export * from './results/ProcedureTimeslotGroupByResult.schema'
export * from './results/ProcedureTimeslotCountResult.schema'
export * from './results/PatientConversationFindUniqueResult.schema'
export * from './results/PatientConversationFindFirstResult.schema'
export * from './results/PatientConversationFindManyResult.schema'
export * from './results/PatientConversationCreateResult.schema'
export * from './results/PatientConversationCreateManyResult.schema'
export * from './results/PatientConversationUpdateResult.schema'
export * from './results/PatientConversationUpdateManyResult.schema'
export * from './results/PatientConversationUpsertResult.schema'
export * from './results/PatientConversationDeleteResult.schema'
export * from './results/PatientConversationDeleteManyResult.schema'
export * from './results/PatientConversationAggregateResult.schema'
export * from './results/PatientConversationGroupByResult.schema'
export * from './results/PatientConversationCountResult.schema'
export * from './results/index'
export * from './objects/index'
export * from './variants/pure/User.pure'
@@ -979,6 +1010,7 @@ 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/PatientConversation.pure'
export * from './variants/pure/index'
export * from './variants/input/User.input'
export * from './variants/input/Patient.input'
@@ -1010,6 +1042,7 @@ 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/PatientConversation.input'
export * from './variants/input/index'
export * from './variants/result/User.result'
export * from './variants/result/Patient.result'
@@ -1041,5 +1074,6 @@ 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/PatientConversation.result'
export * from './variants/result/index'
export * from './variants/index'

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

@@ -6,6 +6,7 @@ const makeSchema = () => z.object({
id: z.literal(true).optional(),
userId: z.literal(true).optional(),
apiKey: z.literal(true).optional(),
afterHoursEnabled: z.literal(true).optional(),
_all: z.literal(true).optional()
}).strict();
export const AiSettingsCountAggregateInputObjectSchema: z.ZodType<Prisma.AiSettingsCountAggregateInputType> = makeSchema() as unknown as z.ZodType<Prisma.AiSettingsCountAggregateInputType>;

3
packages/db/shared/schemas/objects/AiSettingsCountOrderByAggregateInput.schema.ts
View File

@@ -5,7 +5,8 @@ import { SortOrderSchema } from '../enums/SortOrder.schema'
const makeSchema = () => z.object({
id: SortOrderSchema.optional(),
userId: SortOrderSchema.optional(),
apiKey: SortOrderSchema.optional()
apiKey: SortOrderSchema.optional(),
afterHoursEnabled: SortOrderSchema.optional()
}).strict();
export const AiSettingsCountOrderByAggregateInputObjectSchema: z.ZodType<Prisma.AiSettingsCountOrderByAggregateInput> = makeSchema() as unknown as z.ZodType<Prisma.AiSettingsCountOrderByAggregateInput>;
export const AiSettingsCountOrderByAggregateInputObjectZodSchema = makeSchema();

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

@@ -4,6 +4,7 @@ import { UserCreateNestedOneWithoutAiSettingsInputObjectSchema as UserCreateNest
const makeSchema = () => z.object({
apiKey: z.string(),
afterHoursEnabled: z.boolean().optional(),
user: z.lazy(() => UserCreateNestedOneWithoutAiSettingsInputObjectSchema)
}).strict();
export const AiSettingsCreateInputObjectSchema: z.ZodType<Prisma.AiSettingsCreateInput> = makeSchema() as unknown as z.ZodType<Prisma.AiSettingsCreateInput>;

3
packages/db/shared/schemas/objects/AiSettingsCreateManyInput.schema.ts
View File

@@ -5,7 +5,8 @@ import type { Prisma } from '../../../generated/prisma';
const makeSchema = () => z.object({
id: z.number().int().optional(),
userId: z.number().int(),
apiKey: z.string()
apiKey: z.string(),
afterHoursEnabled: z.boolean().optional()
}).strict();
export const AiSettingsCreateManyInputObjectSchema: z.ZodType<Prisma.AiSettingsCreateManyInput> = makeSchema() as unknown as z.ZodType<Prisma.AiSettingsCreateManyInput>;
export const AiSettingsCreateManyInputObjectZodSchema = makeSchema();

3
packages/db/shared/schemas/objects/AiSettingsCreateWithoutUserInput.schema.ts
View File

@@ -3,7 +3,8 @@ import type { Prisma } from '../../../generated/prisma';
const makeSchema = () => z.object({
apiKey: z.string()
apiKey: z.string(),
afterHoursEnabled: z.boolean().optional()
}).strict();
export const AiSettingsCreateWithoutUserInputObjectSchema: z.ZodType<Prisma.AiSettingsCreateWithoutUserInput> = makeSchema() as unknown as z.ZodType<Prisma.AiSettingsCreateWithoutUserInput>;
export const AiSettingsCreateWithoutUserInputObjectZodSchema = makeSchema();

3
packages/db/shared/schemas/objects/AiSettingsMaxAggregateInput.schema.ts
View File

@@ -5,7 +5,8 @@ import type { Prisma } from '../../../generated/prisma';
const makeSchema = () => z.object({
id: z.literal(true).optional(),
userId: z.literal(true).optional(),
apiKey: z.literal(true).optional()
apiKey: z.literal(true).optional(),
afterHoursEnabled: z.literal(true).optional()
}).strict();
export const AiSettingsMaxAggregateInputObjectSchema: z.ZodType<Prisma.AiSettingsMaxAggregateInputType> = makeSchema() as unknown as z.ZodType<Prisma.AiSettingsMaxAggregateInputType>;
export const AiSettingsMaxAggregateInputObjectZodSchema = makeSchema();

3
packages/db/shared/schemas/objects/AiSettingsMaxOrderByAggregateInput.schema.ts
View File

@@ -5,7 +5,8 @@ import { SortOrderSchema } from '../enums/SortOrder.schema'
const makeSchema = () => z.object({
id: SortOrderSchema.optional(),
userId: SortOrderSchema.optional(),
apiKey: SortOrderSchema.optional()
apiKey: SortOrderSchema.optional(),
afterHoursEnabled: SortOrderSchema.optional()
}).strict();
export const AiSettingsMaxOrderByAggregateInputObjectSchema: z.ZodType<Prisma.AiSettingsMaxOrderByAggregateInput> = makeSchema() as unknown as z.ZodType<Prisma.AiSettingsMaxOrderByAggregateInput>;
export const AiSettingsMaxOrderByAggregateInputObjectZodSchema = makeSchema();

3
packages/db/shared/schemas/objects/AiSettingsMinAggregateInput.schema.ts
View File

@@ -5,7 +5,8 @@ import type { Prisma } from '../../../generated/prisma';
const makeSchema = () => z.object({
id: z.literal(true).optional(),
userId: z.literal(true).optional(),
apiKey: z.literal(true).optional()
apiKey: z.literal(true).optional(),
afterHoursEnabled: z.literal(true).optional()
}).strict();
export const AiSettingsMinAggregateInputObjectSchema: z.ZodType<Prisma.AiSettingsMinAggregateInputType> = makeSchema() as unknown as z.ZodType<Prisma.AiSettingsMinAggregateInputType>;
export const AiSettingsMinAggregateInputObjectZodSchema = makeSchema();

3
packages/db/shared/schemas/objects/AiSettingsMinOrderByAggregateInput.schema.ts
View File

@@ -5,7 +5,8 @@ import { SortOrderSchema } from '../enums/SortOrder.schema'
const makeSchema = () => z.object({
id: SortOrderSchema.optional(),
userId: SortOrderSchema.optional(),
apiKey: SortOrderSchema.optional()
apiKey: SortOrderSchema.optional(),
afterHoursEnabled: SortOrderSchema.optional()
}).strict();
export const AiSettingsMinOrderByAggregateInputObjectSchema: z.ZodType<Prisma.AiSettingsMinOrderByAggregateInput> = makeSchema() as unknown as z.ZodType<Prisma.AiSettingsMinOrderByAggregateInput>;
export const AiSettingsMinOrderByAggregateInputObjectZodSchema = makeSchema();

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

@@ -11,6 +11,7 @@ const makeSchema = () => z.object({
id: SortOrderSchema.optional(),
userId: SortOrderSchema.optional(),
apiKey: SortOrderSchema.optional(),
afterHoursEnabled: SortOrderSchema.optional(),
_count: z.lazy(() => AiSettingsCountOrderByAggregateInputObjectSchema).optional(),
_avg: z.lazy(() => AiSettingsAvgOrderByAggregateInputObjectSchema).optional(),
_max: z.lazy(() => AiSettingsMaxOrderByAggregateInputObjectSchema).optional(),

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

@@ -7,6 +7,7 @@ const makeSchema = () => z.object({
id: SortOrderSchema.optional(),
userId: SortOrderSchema.optional(),
apiKey: SortOrderSchema.optional(),
afterHoursEnabled: SortOrderSchema.optional(),
user: z.lazy(() => UserOrderByWithRelationInputObjectSchema).optional()
}).strict();
export const AiSettingsOrderByWithRelationInputObjectSchema: z.ZodType<Prisma.AiSettingsOrderByWithRelationInput> = makeSchema() as unknown as z.ZodType<Prisma.AiSettingsOrderByWithRelationInput>;

6
packages/db/shared/schemas/objects/AiSettingsScalarWhereWithAggregatesInput.schema.ts
View File

@@ -1,7 +1,8 @@
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 { StringWithAggregatesFilterObjectSchema as StringWithAggregatesFilterObjectSchema } from './StringWithAggregatesFilter.schema';
import { BoolWithAggregatesFilterObjectSchema as BoolWithAggregatesFilterObjectSchema } from './BoolWithAggregatesFilter.schema'
const aisettingsscalarwherewithaggregatesinputSchema = z.object({
AND: z.union([z.lazy(() => AiSettingsScalarWhereWithAggregatesInputObjectSchema), z.lazy(() => AiSettingsScalarWhereWithAggregatesInputObjectSchema).array()]).optional(),
@@ -9,7 +10,8 @@ const aisettingsscalarwherewithaggregatesinputSchema = z.object({
NOT: z.union([z.lazy(() => AiSettingsScalarWhereWithAggregatesInputObjectSchema), z.lazy(() => AiSettingsScalarWhereWithAggregatesInputObjectSchema).array()]).optional(),
id: z.union([z.lazy(() => IntWithAggregatesFilterObjectSchema), z.number().int()]).optional(),
userId: z.union([z.lazy(() => IntWithAggregatesFilterObjectSchema), z.number().int()]).optional(),
apiKey: z.union([z.lazy(() => StringWithAggregatesFilterObjectSchema), z.string()]).optional()
apiKey: z.union([z.lazy(() => StringWithAggregatesFilterObjectSchema), z.string()]).optional(),
afterHoursEnabled: z.union([z.lazy(() => BoolWithAggregatesFilterObjectSchema), z.boolean()]).optional()
}).strict();
export const AiSettingsScalarWhereWithAggregatesInputObjectSchema: z.ZodType<Prisma.AiSettingsScalarWhereWithAggregatesInput> = aisettingsscalarwherewithaggregatesinputSchema as unknown as z.ZodType<Prisma.AiSettingsScalarWhereWithAggregatesInput>;
export const AiSettingsScalarWhereWithAggregatesInputObjectZodSchema = aisettingsscalarwherewithaggregatesinputSchema;

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

@@ -6,6 +6,7 @@ const makeSchema = () => z.object({
id: z.boolean().optional(),
userId: z.boolean().optional(),
apiKey: z.boolean().optional(),
afterHoursEnabled: z.boolean().optional(),
user: z.union([z.boolean(), z.lazy(() => UserArgsObjectSchema)]).optional()
}).strict();
export const AiSettingsSelectObjectSchema: z.ZodType<Prisma.AiSettingsSelect> = makeSchema() as unknown as z.ZodType<Prisma.AiSettingsSelect>;

3
packages/db/shared/schemas/objects/AiSettingsUncheckedCreateInput.schema.ts
View File

@@ -5,7 +5,8 @@ import type { Prisma } from '../../../generated/prisma';
const makeSchema = () => z.object({
id: z.number().int().optional(),
userId: z.number().int(),
apiKey: z.string()
apiKey: z.string(),
afterHoursEnabled: z.boolean().optional()
}).strict();
export const AiSettingsUncheckedCreateInputObjectSchema: z.ZodType<Prisma.AiSettingsUncheckedCreateInput> = makeSchema() as unknown as z.ZodType<Prisma.AiSettingsUncheckedCreateInput>;
export const AiSettingsUncheckedCreateInputObjectZodSchema = makeSchema();

3
packages/db/shared/schemas/objects/AiSettingsUncheckedCreateWithoutUserInput.schema.ts
View File

@@ -4,7 +4,8 @@ import type { Prisma } from '../../../generated/prisma';
const makeSchema = () => z.object({
id: z.number().int().optional(),
apiKey: z.string()
apiKey: z.string(),
afterHoursEnabled: z.boolean().optional()
}).strict();
export const AiSettingsUncheckedCreateWithoutUserInputObjectSchema: z.ZodType<Prisma.AiSettingsUncheckedCreateWithoutUserInput> = makeSchema() as unknown as z.ZodType<Prisma.AiSettingsUncheckedCreateWithoutUserInput>;
export const AiSettingsUncheckedCreateWithoutUserInputObjectZodSchema = makeSchema();

6
packages/db/shared/schemas/objects/AiSettingsUncheckedUpdateInput.schema.ts
View File

@@ -1,12 +1,14 @@
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 { StringFieldUpdateOperationsInputObjectSchema as StringFieldUpdateOperationsInputObjectSchema } from './StringFieldUpdateOperationsInput.schema';
import { BoolFieldUpdateOperationsInputObjectSchema as BoolFieldUpdateOperationsInputObjectSchema } from './BoolFieldUpdateOperationsInput.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(),
apiKey: z.union([z.string(), z.lazy(() => StringFieldUpdateOperationsInputObjectSchema)]).optional()
apiKey: z.union([z.string(), z.lazy(() => StringFieldUpdateOperationsInputObjectSchema)]).optional(),
afterHoursEnabled: z.union([z.boolean(), z.lazy(() => BoolFieldUpdateOperationsInputObjectSchema)]).optional()
}).strict();
export const AiSettingsUncheckedUpdateInputObjectSchema: z.ZodType<Prisma.AiSettingsUncheckedUpdateInput> = makeSchema() as unknown as z.ZodType<Prisma.AiSettingsUncheckedUpdateInput>;
export const AiSettingsUncheckedUpdateInputObjectZodSchema = makeSchema();

6
packages/db/shared/schemas/objects/AiSettingsUncheckedUpdateManyInput.schema.ts
View File

@@ -1,12 +1,14 @@
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 { StringFieldUpdateOperationsInputObjectSchema as StringFieldUpdateOperationsInputObjectSchema } from './StringFieldUpdateOperationsInput.schema';
import { BoolFieldUpdateOperationsInputObjectSchema as BoolFieldUpdateOperationsInputObjectSchema } from './BoolFieldUpdateOperationsInput.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(),
apiKey: z.union([z.string(), z.lazy(() => StringFieldUpdateOperationsInputObjectSchema)]).optional()
apiKey: z.union([z.string(), z.lazy(() => StringFieldUpdateOperationsInputObjectSchema)]).optional(),
afterHoursEnabled: z.union([z.boolean(), z.lazy(() => BoolFieldUpdateOperationsInputObjectSchema)]).optional()
}).strict();
export const AiSettingsUncheckedUpdateManyInputObjectSchema: z.ZodType<Prisma.AiSettingsUncheckedUpdateManyInput> = makeSchema() as unknown as z.ZodType<Prisma.AiSettingsUncheckedUpdateManyInput>;
export const AiSettingsUncheckedUpdateManyInputObjectZodSchema = makeSchema();

6
packages/db/shared/schemas/objects/AiSettingsUncheckedUpdateWithoutUserInput.schema.ts
View File

@@ -1,11 +1,13 @@
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 { StringFieldUpdateOperationsInputObjectSchema as StringFieldUpdateOperationsInputObjectSchema } from './StringFieldUpdateOperationsInput.schema';
import { BoolFieldUpdateOperationsInputObjectSchema as BoolFieldUpdateOperationsInputObjectSchema } from './BoolFieldUpdateOperationsInput.schema'
const makeSchema = () => z.object({
id: z.union([z.number().int(), z.lazy(() => IntFieldUpdateOperationsInputObjectSchema)]).optional(),
apiKey: z.union([z.string(), z.lazy(() => StringFieldUpdateOperationsInputObjectSchema)]).optional()
apiKey: z.union([z.string(), z.lazy(() => StringFieldUpdateOperationsInputObjectSchema)]).optional(),
afterHoursEnabled: z.union([z.boolean(), z.lazy(() => BoolFieldUpdateOperationsInputObjectSchema)]).optional()
}).strict();
export const AiSettingsUncheckedUpdateWithoutUserInputObjectSchema: z.ZodType<Prisma.AiSettingsUncheckedUpdateWithoutUserInput> = makeSchema() as unknown as z.ZodType<Prisma.AiSettingsUncheckedUpdateWithoutUserInput>;
export const AiSettingsUncheckedUpdateWithoutUserInputObjectZodSchema = makeSchema();

2
packages/db/shared/schemas/objects/AiSettingsUpdateInput.schema.ts
View File

@@ -1,10 +1,12 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { StringFieldUpdateOperationsInputObjectSchema as StringFieldUpdateOperationsInputObjectSchema } from './StringFieldUpdateOperationsInput.schema';
import { BoolFieldUpdateOperationsInputObjectSchema as BoolFieldUpdateOperationsInputObjectSchema } from './BoolFieldUpdateOperationsInput.schema';
import { UserUpdateOneRequiredWithoutAiSettingsNestedInputObjectSchema as UserUpdateOneRequiredWithoutAiSettingsNestedInputObjectSchema } from './UserUpdateOneRequiredWithoutAiSettingsNestedInput.schema'
const makeSchema = () => z.object({
apiKey: z.union([z.string(), z.lazy(() => StringFieldUpdateOperationsInputObjectSchema)]).optional(),
afterHoursEnabled: z.union([z.boolean(), z.lazy(() => BoolFieldUpdateOperationsInputObjectSchema)]).optional(),
user: z.lazy(() => UserUpdateOneRequiredWithoutAiSettingsNestedInputObjectSchema).optional()
}).strict();
export const AiSettingsUpdateInputObjectSchema: z.ZodType<Prisma.AiSettingsUpdateInput> = makeSchema() as unknown as z.ZodType<Prisma.AiSettingsUpdateInput>;

6
packages/db/shared/schemas/objects/AiSettingsUpdateManyMutationInput.schema.ts
View File

@@ -1,9 +1,11 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { StringFieldUpdateOperationsInputObjectSchema as StringFieldUpdateOperationsInputObjectSchema } from './StringFieldUpdateOperationsInput.schema'
import { StringFieldUpdateOperationsInputObjectSchema as StringFieldUpdateOperationsInputObjectSchema } from './StringFieldUpdateOperationsInput.schema';
import { BoolFieldUpdateOperationsInputObjectSchema as BoolFieldUpdateOperationsInputObjectSchema } from './BoolFieldUpdateOperationsInput.schema'
const makeSchema = () => z.object({
apiKey: z.union([z.string(), z.lazy(() => StringFieldUpdateOperationsInputObjectSchema)]).optional()
apiKey: z.union([z.string(), z.lazy(() => StringFieldUpdateOperationsInputObjectSchema)]).optional(),
afterHoursEnabled: z.union([z.boolean(), z.lazy(() => BoolFieldUpdateOperationsInputObjectSchema)]).optional()
}).strict();
export const AiSettingsUpdateManyMutationInputObjectSchema: z.ZodType<Prisma.AiSettingsUpdateManyMutationInput> = makeSchema() as unknown as z.ZodType<Prisma.AiSettingsUpdateManyMutationInput>;
export const AiSettingsUpdateManyMutationInputObjectZodSchema = makeSchema();

6
packages/db/shared/schemas/objects/AiSettingsUpdateWithoutUserInput.schema.ts
View File

@@ -1,9 +1,11 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { StringFieldUpdateOperationsInputObjectSchema as StringFieldUpdateOperationsInputObjectSchema } from './StringFieldUpdateOperationsInput.schema'
import { StringFieldUpdateOperationsInputObjectSchema as StringFieldUpdateOperationsInputObjectSchema } from './StringFieldUpdateOperationsInput.schema';
import { BoolFieldUpdateOperationsInputObjectSchema as BoolFieldUpdateOperationsInputObjectSchema } from './BoolFieldUpdateOperationsInput.schema'
const makeSchema = () => z.object({
apiKey: z.union([z.string(), z.lazy(() => StringFieldUpdateOperationsInputObjectSchema)]).optional()
apiKey: z.union([z.string(), z.lazy(() => StringFieldUpdateOperationsInputObjectSchema)]).optional(),
afterHoursEnabled: z.union([z.boolean(), z.lazy(() => BoolFieldUpdateOperationsInputObjectSchema)]).optional()
}).strict();
export const AiSettingsUpdateWithoutUserInputObjectSchema: z.ZodType<Prisma.AiSettingsUpdateWithoutUserInput> = makeSchema() as unknown as z.ZodType<Prisma.AiSettingsUpdateWithoutUserInput>;
export const AiSettingsUpdateWithoutUserInputObjectZodSchema = makeSchema();

2
packages/db/shared/schemas/objects/AiSettingsWhereInput.schema.ts
View File

@@ -2,6 +2,7 @@ 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 { BoolFilterObjectSchema as BoolFilterObjectSchema } from './BoolFilter.schema';
import { UserScalarRelationFilterObjectSchema as UserScalarRelationFilterObjectSchema } from './UserScalarRelationFilter.schema';
import { UserWhereInputObjectSchema as UserWhereInputObjectSchema } from './UserWhereInput.schema'
@@ -12,6 +13,7 @@ const aisettingswhereinputSchema = z.object({
id: z.union([z.lazy(() => IntFilterObjectSchema), z.number().int()]).optional(),
userId: z.union([z.lazy(() => IntFilterObjectSchema), z.number().int()]).optional(),
apiKey: z.union([z.lazy(() => StringFilterObjectSchema), z.string()]).optional(),
afterHoursEnabled: z.union([z.lazy(() => BoolFilterObjectSchema), z.boolean()]).optional(),
user: z.union([z.lazy(() => UserScalarRelationFilterObjectSchema), z.lazy(() => UserWhereInputObjectSchema)]).optional()
}).strict();
export const AiSettingsWhereInputObjectSchema: z.ZodType<Prisma.AiSettingsWhereInput> = aisettingswhereinputSchema as unknown as z.ZodType<Prisma.AiSettingsWhereInput>;

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

@@ -0,0 +1,11 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { PatientConversationSelectObjectSchema as PatientConversationSelectObjectSchema } from './PatientConversationSelect.schema';
import { PatientConversationIncludeObjectSchema as PatientConversationIncludeObjectSchema } from './PatientConversationInclude.schema'
const makeSchema = () => z.object({
select: z.lazy(() => PatientConversationSelectObjectSchema).optional(),
include: z.lazy(() => PatientConversationIncludeObjectSchema).optional()
}).strict();
export const PatientConversationArgsObjectSchema = makeSchema();
export const PatientConversationArgsObjectZodSchema = makeSchema();

11
packages/db/shared/schemas/objects/PatientConversationAvgAggregateInput.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({
id: z.literal(true).optional(),
patientId: z.literal(true).optional(),
userId: z.literal(true).optional()
}).strict();
export const PatientConversationAvgAggregateInputObjectSchema: z.ZodType<Prisma.PatientConversationAvgAggregateInputType> = makeSchema() as unknown as z.ZodType<Prisma.PatientConversationAvgAggregateInputType>;
export const PatientConversationAvgAggregateInputObjectZodSchema = makeSchema();

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

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

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

@@ -0,0 +1,15 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
const makeSchema = () => z.object({
id: z.literal(true).optional(),
patientId: z.literal(true).optional(),
userId: z.literal(true).optional(),
stage: z.literal(true).optional(),
aiHandoff: z.literal(true).optional(),
updatedAt: z.literal(true).optional(),
_all: z.literal(true).optional()
}).strict();
export const PatientConversationCountAggregateInputObjectSchema: z.ZodType<Prisma.PatientConversationCountAggregateInputType> = makeSchema() as unknown as z.ZodType<Prisma.PatientConversationCountAggregateInputType>;
export const PatientConversationCountAggregateInputObjectZodSchema = makeSchema();

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

@@ -0,0 +1,14 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { SortOrderSchema } from '../enums/SortOrder.schema'
const makeSchema = () => z.object({
id: SortOrderSchema.optional(),
patientId: SortOrderSchema.optional(),
userId: SortOrderSchema.optional(),
stage: SortOrderSchema.optional(),
aiHandoff: SortOrderSchema.optional(),
updatedAt: SortOrderSchema.optional()
}).strict();
export const PatientConversationCountOrderByAggregateInputObjectSchema: z.ZodType<Prisma.PatientConversationCountOrderByAggregateInput> = makeSchema() as unknown as z.ZodType<Prisma.PatientConversationCountOrderByAggregateInput>;
export const PatientConversationCountOrderByAggregateInputObjectZodSchema = makeSchema();

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

@@ -0,0 +1,13 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { PatientCreateNestedOneWithoutConversationInputObjectSchema as PatientCreateNestedOneWithoutConversationInputObjectSchema } from './PatientCreateNestedOneWithoutConversationInput.schema';
import { UserCreateNestedOneWithoutPatientConversationsInputObjectSchema as UserCreateNestedOneWithoutPatientConversationsInputObjectSchema } from './UserCreateNestedOneWithoutPatientConversationsInput.schema'
const makeSchema = () => z.object({
stage: z.string().optional(),
aiHandoff: z.boolean().optional(),
patient: z.lazy(() => PatientCreateNestedOneWithoutConversationInputObjectSchema),
user: z.lazy(() => UserCreateNestedOneWithoutPatientConversationsInputObjectSchema)
}).strict();
export const PatientConversationCreateInputObjectSchema: z.ZodType<Prisma.PatientConversationCreateInput> = makeSchema() as unknown as z.ZodType<Prisma.PatientConversationCreateInput>;
export const PatientConversationCreateInputObjectZodSchema = makeSchema();

14
packages/db/shared/schemas/objects/PatientConversationCreateManyInput.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.number().int().optional(),
patientId: z.number().int(),
userId: z.number().int(),
stage: z.string().optional(),
aiHandoff: z.boolean().optional(),
updatedAt: z.coerce.date().optional()
}).strict();
export const PatientConversationCreateManyInputObjectSchema: z.ZodType<Prisma.PatientConversationCreateManyInput> = makeSchema() as unknown as z.ZodType<Prisma.PatientConversationCreateManyInput>;
export const PatientConversationCreateManyInputObjectZodSchema = makeSchema();

13
packages/db/shared/schemas/objects/PatientConversationCreateManyUserInput.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(),
patientId: z.number().int(),
stage: z.string().optional(),
aiHandoff: z.boolean().optional(),
updatedAt: z.coerce.date().optional()
}).strict();
export const PatientConversationCreateManyUserInputObjectSchema: z.ZodType<Prisma.PatientConversationCreateManyUserInput> = makeSchema() as unknown as z.ZodType<Prisma.PatientConversationCreateManyUserInput>;
export const PatientConversationCreateManyUserInputObjectZodSchema = makeSchema();

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

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

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

@@ -0,0 +1,16 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { PatientConversationCreateWithoutUserInputObjectSchema as PatientConversationCreateWithoutUserInputObjectSchema } from './PatientConversationCreateWithoutUserInput.schema';
import { PatientConversationUncheckedCreateWithoutUserInputObjectSchema as PatientConversationUncheckedCreateWithoutUserInputObjectSchema } from './PatientConversationUncheckedCreateWithoutUserInput.schema';
import { PatientConversationCreateOrConnectWithoutUserInputObjectSchema as PatientConversationCreateOrConnectWithoutUserInputObjectSchema } from './PatientConversationCreateOrConnectWithoutUserInput.schema';
import { PatientConversationCreateManyUserInputEnvelopeObjectSchema as PatientConversationCreateManyUserInputEnvelopeObjectSchema } from './PatientConversationCreateManyUserInputEnvelope.schema';
import { PatientConversationWhereUniqueInputObjectSchema as PatientConversationWhereUniqueInputObjectSchema } from './PatientConversationWhereUniqueInput.schema'
const makeSchema = () => z.object({
create: z.union([z.lazy(() => PatientConversationCreateWithoutUserInputObjectSchema), z.lazy(() => PatientConversationCreateWithoutUserInputObjectSchema).array(), z.lazy(() => PatientConversationUncheckedCreateWithoutUserInputObjectSchema), z.lazy(() => PatientConversationUncheckedCreateWithoutUserInputObjectSchema).array()]).optional(),
connectOrCreate: z.union([z.lazy(() => PatientConversationCreateOrConnectWithoutUserInputObjectSchema), z.lazy(() => PatientConversationCreateOrConnectWithoutUserInputObjectSchema).array()]).optional(),
createMany: z.lazy(() => PatientConversationCreateManyUserInputEnvelopeObjectSchema).optional(),
connect: z.union([z.lazy(() => PatientConversationWhereUniqueInputObjectSchema), z.lazy(() => PatientConversationWhereUniqueInputObjectSchema).array()]).optional()
}).strict();
export const PatientConversationCreateNestedManyWithoutUserInputObjectSchema: z.ZodType<Prisma.PatientConversationCreateNestedManyWithoutUserInput> = makeSchema() as unknown as z.ZodType<Prisma.PatientConversationCreateNestedManyWithoutUserInput>;
export const PatientConversationCreateNestedManyWithoutUserInputObjectZodSchema = makeSchema();

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

@@ -0,0 +1,14 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { PatientConversationCreateWithoutPatientInputObjectSchema as PatientConversationCreateWithoutPatientInputObjectSchema } from './PatientConversationCreateWithoutPatientInput.schema';
import { PatientConversationUncheckedCreateWithoutPatientInputObjectSchema as PatientConversationUncheckedCreateWithoutPatientInputObjectSchema } from './PatientConversationUncheckedCreateWithoutPatientInput.schema';
import { PatientConversationCreateOrConnectWithoutPatientInputObjectSchema as PatientConversationCreateOrConnectWithoutPatientInputObjectSchema } from './PatientConversationCreateOrConnectWithoutPatientInput.schema';
import { PatientConversationWhereUniqueInputObjectSchema as PatientConversationWhereUniqueInputObjectSchema } from './PatientConversationWhereUniqueInput.schema'
const makeSchema = () => z.object({
create: z.union([z.lazy(() => PatientConversationCreateWithoutPatientInputObjectSchema), z.lazy(() => PatientConversationUncheckedCreateWithoutPatientInputObjectSchema)]).optional(),
connectOrCreate: z.lazy(() => PatientConversationCreateOrConnectWithoutPatientInputObjectSchema).optional(),
connect: z.lazy(() => PatientConversationWhereUniqueInputObjectSchema).optional()
}).strict();
export const PatientConversationCreateNestedOneWithoutPatientInputObjectSchema: z.ZodType<Prisma.PatientConversationCreateNestedOneWithoutPatientInput> = makeSchema() as unknown as z.ZodType<Prisma.PatientConversationCreateNestedOneWithoutPatientInput>;
export const PatientConversationCreateNestedOneWithoutPatientInputObjectZodSchema = makeSchema();

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

@@ -0,0 +1,12 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { PatientConversationWhereUniqueInputObjectSchema as PatientConversationWhereUniqueInputObjectSchema } from './PatientConversationWhereUniqueInput.schema';
import { PatientConversationCreateWithoutPatientInputObjectSchema as PatientConversationCreateWithoutPatientInputObjectSchema } from './PatientConversationCreateWithoutPatientInput.schema';
import { PatientConversationUncheckedCreateWithoutPatientInputObjectSchema as PatientConversationUncheckedCreateWithoutPatientInputObjectSchema } from './PatientConversationUncheckedCreateWithoutPatientInput.schema'
const makeSchema = () => z.object({
where: z.lazy(() => PatientConversationWhereUniqueInputObjectSchema),
create: z.union([z.lazy(() => PatientConversationCreateWithoutPatientInputObjectSchema), z.lazy(() => PatientConversationUncheckedCreateWithoutPatientInputObjectSchema)])
}).strict();
export const PatientConversationCreateOrConnectWithoutPatientInputObjectSchema: z.ZodType<Prisma.PatientConversationCreateOrConnectWithoutPatientInput> = makeSchema() as unknown as z.ZodType<Prisma.PatientConversationCreateOrConnectWithoutPatientInput>;
export const PatientConversationCreateOrConnectWithoutPatientInputObjectZodSchema = makeSchema();

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

@@ -0,0 +1,12 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { PatientConversationWhereUniqueInputObjectSchema as PatientConversationWhereUniqueInputObjectSchema } from './PatientConversationWhereUniqueInput.schema';
import { PatientConversationCreateWithoutUserInputObjectSchema as PatientConversationCreateWithoutUserInputObjectSchema } from './PatientConversationCreateWithoutUserInput.schema';
import { PatientConversationUncheckedCreateWithoutUserInputObjectSchema as PatientConversationUncheckedCreateWithoutUserInputObjectSchema } from './PatientConversationUncheckedCreateWithoutUserInput.schema'
const makeSchema = () => z.object({
where: z.lazy(() => PatientConversationWhereUniqueInputObjectSchema),
create: z.union([z.lazy(() => PatientConversationCreateWithoutUserInputObjectSchema), z.lazy(() => PatientConversationUncheckedCreateWithoutUserInputObjectSchema)])
}).strict();
export const PatientConversationCreateOrConnectWithoutUserInputObjectSchema: z.ZodType<Prisma.PatientConversationCreateOrConnectWithoutUserInput> = makeSchema() as unknown as z.ZodType<Prisma.PatientConversationCreateOrConnectWithoutUserInput>;
export const PatientConversationCreateOrConnectWithoutUserInputObjectZodSchema = makeSchema();

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

@@ -0,0 +1,12 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { UserCreateNestedOneWithoutPatientConversationsInputObjectSchema as UserCreateNestedOneWithoutPatientConversationsInputObjectSchema } from './UserCreateNestedOneWithoutPatientConversationsInput.schema'
const makeSchema = () => z.object({
stage: z.string().optional(),
aiHandoff: z.boolean().optional(),
updatedAt: z.coerce.date().optional(),
user: z.lazy(() => UserCreateNestedOneWithoutPatientConversationsInputObjectSchema)
}).strict();
export const PatientConversationCreateWithoutPatientInputObjectSchema: z.ZodType<Prisma.PatientConversationCreateWithoutPatientInput> = makeSchema() as unknown as z.ZodType<Prisma.PatientConversationCreateWithoutPatientInput>;
export const PatientConversationCreateWithoutPatientInputObjectZodSchema = makeSchema();

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

@@ -0,0 +1,12 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { PatientCreateNestedOneWithoutConversationInputObjectSchema as PatientCreateNestedOneWithoutConversationInputObjectSchema } from './PatientCreateNestedOneWithoutConversationInput.schema'
const makeSchema = () => z.object({
stage: z.string().optional(),
aiHandoff: z.boolean().optional(),
updatedAt: z.coerce.date().optional(),
patient: z.lazy(() => PatientCreateNestedOneWithoutConversationInputObjectSchema)
}).strict();
export const PatientConversationCreateWithoutUserInputObjectSchema: z.ZodType<Prisma.PatientConversationCreateWithoutUserInput> = makeSchema() as unknown as z.ZodType<Prisma.PatientConversationCreateWithoutUserInput>;
export const PatientConversationCreateWithoutUserInputObjectZodSchema = makeSchema();

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

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

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

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

14
packages/db/shared/schemas/objects/PatientConversationMaxAggregateInput.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(),
patientId: z.literal(true).optional(),
userId: z.literal(true).optional(),
stage: z.literal(true).optional(),
aiHandoff: z.literal(true).optional(),
updatedAt: z.literal(true).optional()
}).strict();
export const PatientConversationMaxAggregateInputObjectSchema: z.ZodType<Prisma.PatientConversationMaxAggregateInputType> = makeSchema() as unknown as z.ZodType<Prisma.PatientConversationMaxAggregateInputType>;
export const PatientConversationMaxAggregateInputObjectZodSchema = makeSchema();

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

@@ -0,0 +1,14 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { SortOrderSchema } from '../enums/SortOrder.schema'
const makeSchema = () => z.object({
id: SortOrderSchema.optional(),
patientId: SortOrderSchema.optional(),
userId: SortOrderSchema.optional(),
stage: SortOrderSchema.optional(),
aiHandoff: SortOrderSchema.optional(),
updatedAt: SortOrderSchema.optional()
}).strict();
export const PatientConversationMaxOrderByAggregateInputObjectSchema: z.ZodType<Prisma.PatientConversationMaxOrderByAggregateInput> = makeSchema() as unknown as z.ZodType<Prisma.PatientConversationMaxOrderByAggregateInput>;
export const PatientConversationMaxOrderByAggregateInputObjectZodSchema = makeSchema();

14
packages/db/shared/schemas/objects/PatientConversationMinAggregateInput.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(),
patientId: z.literal(true).optional(),
userId: z.literal(true).optional(),
stage: z.literal(true).optional(),
aiHandoff: z.literal(true).optional(),
updatedAt: z.literal(true).optional()
}).strict();
export const PatientConversationMinAggregateInputObjectSchema: z.ZodType<Prisma.PatientConversationMinAggregateInputType> = makeSchema() as unknown as z.ZodType<Prisma.PatientConversationMinAggregateInputType>;
export const PatientConversationMinAggregateInputObjectZodSchema = makeSchema();

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

@@ -0,0 +1,14 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { SortOrderSchema } from '../enums/SortOrder.schema'
const makeSchema = () => z.object({
id: SortOrderSchema.optional(),
patientId: SortOrderSchema.optional(),
userId: SortOrderSchema.optional(),
stage: SortOrderSchema.optional(),
aiHandoff: SortOrderSchema.optional(),
updatedAt: SortOrderSchema.optional()
}).strict();
export const PatientConversationMinOrderByAggregateInputObjectSchema: z.ZodType<Prisma.PatientConversationMinOrderByAggregateInput> = makeSchema() as unknown as z.ZodType<Prisma.PatientConversationMinOrderByAggregateInput>;
export const PatientConversationMinOrderByAggregateInputObjectZodSchema = makeSchema();

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

@@ -0,0 +1,10 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { PatientConversationWhereInputObjectSchema as PatientConversationWhereInputObjectSchema } from './PatientConversationWhereInput.schema'
const makeSchema = () => z.object({
is: z.lazy(() => PatientConversationWhereInputObjectSchema).optional().nullable(),
isNot: z.lazy(() => PatientConversationWhereInputObjectSchema).optional().nullable()
}).strict();
export const PatientConversationNullableScalarRelationFilterObjectSchema: z.ZodType<Prisma.PatientConversationNullableScalarRelationFilter> = makeSchema() as unknown as z.ZodType<Prisma.PatientConversationNullableScalarRelationFilter>;
export const PatientConversationNullableScalarRelationFilterObjectZodSchema = makeSchema();

9
packages/db/shared/schemas/objects/PatientConversationOrderByRelationAggregateInput.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 PatientConversationOrderByRelationAggregateInputObjectSchema: z.ZodType<Prisma.PatientConversationOrderByRelationAggregateInput> = makeSchema() as unknown as z.ZodType<Prisma.PatientConversationOrderByRelationAggregateInput>;
export const PatientConversationOrderByRelationAggregateInputObjectZodSchema = makeSchema();

24
packages/db/shared/schemas/objects/PatientConversationOrderByWithAggregationInput.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 { PatientConversationCountOrderByAggregateInputObjectSchema as PatientConversationCountOrderByAggregateInputObjectSchema } from './PatientConversationCountOrderByAggregateInput.schema';
import { PatientConversationAvgOrderByAggregateInputObjectSchema as PatientConversationAvgOrderByAggregateInputObjectSchema } from './PatientConversationAvgOrderByAggregateInput.schema';
import { PatientConversationMaxOrderByAggregateInputObjectSchema as PatientConversationMaxOrderByAggregateInputObjectSchema } from './PatientConversationMaxOrderByAggregateInput.schema';
import { PatientConversationMinOrderByAggregateInputObjectSchema as PatientConversationMinOrderByAggregateInputObjectSchema } from './PatientConversationMinOrderByAggregateInput.schema';
import { PatientConversationSumOrderByAggregateInputObjectSchema as PatientConversationSumOrderByAggregateInputObjectSchema } from './PatientConversationSumOrderByAggregateInput.schema'
const makeSchema = () => z.object({
id: SortOrderSchema.optional(),
patientId: SortOrderSchema.optional(),
userId: SortOrderSchema.optional(),
stage: SortOrderSchema.optional(),
aiHandoff: SortOrderSchema.optional(),
updatedAt: SortOrderSchema.optional(),
_count: z.lazy(() => PatientConversationCountOrderByAggregateInputObjectSchema).optional(),
_avg: z.lazy(() => PatientConversationAvgOrderByAggregateInputObjectSchema).optional(),
_max: z.lazy(() => PatientConversationMaxOrderByAggregateInputObjectSchema).optional(),
_min: z.lazy(() => PatientConversationMinOrderByAggregateInputObjectSchema).optional(),
_sum: z.lazy(() => PatientConversationSumOrderByAggregateInputObjectSchema).optional()
}).strict();
export const PatientConversationOrderByWithAggregationInputObjectSchema: z.ZodType<Prisma.PatientConversationOrderByWithAggregationInput> = makeSchema() as unknown as z.ZodType<Prisma.PatientConversationOrderByWithAggregationInput>;
export const PatientConversationOrderByWithAggregationInputObjectZodSchema = makeSchema();

18
packages/db/shared/schemas/objects/PatientConversationOrderByWithRelationInput.schema.ts Normal file
View File

@@ -0,0 +1,18 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { SortOrderSchema } from '../enums/SortOrder.schema';
import { PatientOrderByWithRelationInputObjectSchema as PatientOrderByWithRelationInputObjectSchema } from './PatientOrderByWithRelationInput.schema';
import { UserOrderByWithRelationInputObjectSchema as UserOrderByWithRelationInputObjectSchema } from './UserOrderByWithRelationInput.schema'
const makeSchema = () => z.object({
id: SortOrderSchema.optional(),
patientId: SortOrderSchema.optional(),
userId: SortOrderSchema.optional(),
stage: SortOrderSchema.optional(),
aiHandoff: SortOrderSchema.optional(),
updatedAt: SortOrderSchema.optional(),
patient: z.lazy(() => PatientOrderByWithRelationInputObjectSchema).optional(),
user: z.lazy(() => UserOrderByWithRelationInputObjectSchema).optional()
}).strict();
export const PatientConversationOrderByWithRelationInputObjectSchema: z.ZodType<Prisma.PatientConversationOrderByWithRelationInput> = makeSchema() as unknown as z.ZodType<Prisma.PatientConversationOrderByWithRelationInput>;
export const PatientConversationOrderByWithRelationInputObjectZodSchema = makeSchema();

20
packages/db/shared/schemas/objects/PatientConversationScalarWhereInput.schema.ts Normal file
View File

@@ -0,0 +1,20 @@
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 { BoolFilterObjectSchema as BoolFilterObjectSchema } from './BoolFilter.schema';
import { DateTimeFilterObjectSchema as DateTimeFilterObjectSchema } from './DateTimeFilter.schema'
const patientconversationscalarwhereinputSchema = z.object({
AND: z.union([z.lazy(() => PatientConversationScalarWhereInputObjectSchema), z.lazy(() => PatientConversationScalarWhereInputObjectSchema).array()]).optional(),
OR: z.lazy(() => PatientConversationScalarWhereInputObjectSchema).array().optional(),
NOT: z.union([z.lazy(() => PatientConversationScalarWhereInputObjectSchema), z.lazy(() => PatientConversationScalarWhereInputObjectSchema).array()]).optional(),
id: z.union([z.lazy(() => IntFilterObjectSchema), z.number().int()]).optional(),
patientId: z.union([z.lazy(() => IntFilterObjectSchema), z.number().int()]).optional(),
userId: z.union([z.lazy(() => IntFilterObjectSchema), z.number().int()]).optional(),
stage: z.union([z.lazy(() => StringFilterObjectSchema), z.string()]).optional(),
aiHandoff: z.union([z.lazy(() => BoolFilterObjectSchema), z.boolean()]).optional(),
updatedAt: z.union([z.lazy(() => DateTimeFilterObjectSchema), z.coerce.date()]).optional()
}).strict();
export const PatientConversationScalarWhereInputObjectSchema: z.ZodType<Prisma.PatientConversationScalarWhereInput> = patientconversationscalarwhereinputSchema as unknown as z.ZodType<Prisma.PatientConversationScalarWhereInput>;
export const PatientConversationScalarWhereInputObjectZodSchema = patientconversationscalarwhereinputSchema;

20
packages/db/shared/schemas/objects/PatientConversationScalarWhereWithAggregatesInput.schema.ts Normal file
View File

@@ -0,0 +1,20 @@
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 { BoolWithAggregatesFilterObjectSchema as BoolWithAggregatesFilterObjectSchema } from './BoolWithAggregatesFilter.schema';
import { DateTimeWithAggregatesFilterObjectSchema as DateTimeWithAggregatesFilterObjectSchema } from './DateTimeWithAggregatesFilter.schema'
const patientconversationscalarwherewithaggregatesinputSchema = z.object({
AND: z.union([z.lazy(() => PatientConversationScalarWhereWithAggregatesInputObjectSchema), z.lazy(() => PatientConversationScalarWhereWithAggregatesInputObjectSchema).array()]).optional(),
OR: z.lazy(() => PatientConversationScalarWhereWithAggregatesInputObjectSchema).array().optional(),
NOT: z.union([z.lazy(() => PatientConversationScalarWhereWithAggregatesInputObjectSchema), z.lazy(() => PatientConversationScalarWhereWithAggregatesInputObjectSchema).array()]).optional(),
id: z.union([z.lazy(() => IntWithAggregatesFilterObjectSchema), z.number().int()]).optional(),
patientId: z.union([z.lazy(() => IntWithAggregatesFilterObjectSchema), z.number().int()]).optional(),
userId: z.union([z.lazy(() => IntWithAggregatesFilterObjectSchema), z.number().int()]).optional(),
stage: z.union([z.lazy(() => StringWithAggregatesFilterObjectSchema), z.string()]).optional(),
aiHandoff: z.union([z.lazy(() => BoolWithAggregatesFilterObjectSchema), z.boolean()]).optional(),
updatedAt: z.union([z.lazy(() => DateTimeWithAggregatesFilterObjectSchema), z.coerce.date()]).optional()
}).strict();
export const PatientConversationScalarWhereWithAggregatesInputObjectSchema: z.ZodType<Prisma.PatientConversationScalarWhereWithAggregatesInput> = patientconversationscalarwherewithaggregatesinputSchema as unknown as z.ZodType<Prisma.PatientConversationScalarWhereWithAggregatesInput>;
export const PatientConversationScalarWhereWithAggregatesInputObjectZodSchema = patientconversationscalarwherewithaggregatesinputSchema;

17
packages/db/shared/schemas/objects/PatientConversationSelect.schema.ts Normal file
View File

@@ -0,0 +1,17 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { PatientArgsObjectSchema as PatientArgsObjectSchema } from './PatientArgs.schema';
import { UserArgsObjectSchema as UserArgsObjectSchema } from './UserArgs.schema'
const makeSchema = () => z.object({
id: z.boolean().optional(),
patientId: z.boolean().optional(),
userId: z.boolean().optional(),
stage: z.boolean().optional(),
aiHandoff: z.boolean().optional(),
updatedAt: z.boolean().optional(),
patient: z.union([z.boolean(), z.lazy(() => PatientArgsObjectSchema)]).optional(),
user: z.union([z.boolean(), z.lazy(() => UserArgsObjectSchema)]).optional()
}).strict();
export const PatientConversationSelectObjectSchema: z.ZodType<Prisma.PatientConversationSelect> = makeSchema() as unknown as z.ZodType<Prisma.PatientConversationSelect>;
export const PatientConversationSelectObjectZodSchema = makeSchema();

11
packages/db/shared/schemas/objects/PatientConversationSumAggregateInput.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({
id: z.literal(true).optional(),
patientId: z.literal(true).optional(),
userId: z.literal(true).optional()
}).strict();
export const PatientConversationSumAggregateInputObjectSchema: z.ZodType<Prisma.PatientConversationSumAggregateInputType> = makeSchema() as unknown as z.ZodType<Prisma.PatientConversationSumAggregateInputType>;
export const PatientConversationSumAggregateInputObjectZodSchema = makeSchema();

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

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

13
packages/db/shared/schemas/objects/PatientConversationUncheckedCreateInput.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(),
patientId: z.number().int(),
userId: z.number().int(),
stage: z.string().optional(),
aiHandoff: z.boolean().optional()
}).strict();
export const PatientConversationUncheckedCreateInputObjectSchema: z.ZodType<Prisma.PatientConversationUncheckedCreateInput> = makeSchema() as unknown as z.ZodType<Prisma.PatientConversationUncheckedCreateInput>;
export const PatientConversationUncheckedCreateInputObjectZodSchema = makeSchema();

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

@@ -0,0 +1,16 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { PatientConversationCreateWithoutUserInputObjectSchema as PatientConversationCreateWithoutUserInputObjectSchema } from './PatientConversationCreateWithoutUserInput.schema';
import { PatientConversationUncheckedCreateWithoutUserInputObjectSchema as PatientConversationUncheckedCreateWithoutUserInputObjectSchema } from './PatientConversationUncheckedCreateWithoutUserInput.schema';
import { PatientConversationCreateOrConnectWithoutUserInputObjectSchema as PatientConversationCreateOrConnectWithoutUserInputObjectSchema } from './PatientConversationCreateOrConnectWithoutUserInput.schema';
import { PatientConversationCreateManyUserInputEnvelopeObjectSchema as PatientConversationCreateManyUserInputEnvelopeObjectSchema } from './PatientConversationCreateManyUserInputEnvelope.schema';
import { PatientConversationWhereUniqueInputObjectSchema as PatientConversationWhereUniqueInputObjectSchema } from './PatientConversationWhereUniqueInput.schema'
const makeSchema = () => z.object({
create: z.union([z.lazy(() => PatientConversationCreateWithoutUserInputObjectSchema), z.lazy(() => PatientConversationCreateWithoutUserInputObjectSchema).array(), z.lazy(() => PatientConversationUncheckedCreateWithoutUserInputObjectSchema), z.lazy(() => PatientConversationUncheckedCreateWithoutUserInputObjectSchema).array()]).optional(),
connectOrCreate: z.union([z.lazy(() => PatientConversationCreateOrConnectWithoutUserInputObjectSchema), z.lazy(() => PatientConversationCreateOrConnectWithoutUserInputObjectSchema).array()]).optional(),
createMany: z.lazy(() => PatientConversationCreateManyUserInputEnvelopeObjectSchema).optional(),
connect: z.union([z.lazy(() => PatientConversationWhereUniqueInputObjectSchema), z.lazy(() => PatientConversationWhereUniqueInputObjectSchema).array()]).optional()
}).strict();
export const PatientConversationUncheckedCreateNestedManyWithoutUserInputObjectSchema: z.ZodType<Prisma.PatientConversationUncheckedCreateNestedManyWithoutUserInput> = makeSchema() as unknown as z.ZodType<Prisma.PatientConversationUncheckedCreateNestedManyWithoutUserInput>;
export const PatientConversationUncheckedCreateNestedManyWithoutUserInputObjectZodSchema = makeSchema();

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

@@ -0,0 +1,14 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { PatientConversationCreateWithoutPatientInputObjectSchema as PatientConversationCreateWithoutPatientInputObjectSchema } from './PatientConversationCreateWithoutPatientInput.schema';
import { PatientConversationUncheckedCreateWithoutPatientInputObjectSchema as PatientConversationUncheckedCreateWithoutPatientInputObjectSchema } from './PatientConversationUncheckedCreateWithoutPatientInput.schema';
import { PatientConversationCreateOrConnectWithoutPatientInputObjectSchema as PatientConversationCreateOrConnectWithoutPatientInputObjectSchema } from './PatientConversationCreateOrConnectWithoutPatientInput.schema';
import { PatientConversationWhereUniqueInputObjectSchema as PatientConversationWhereUniqueInputObjectSchema } from './PatientConversationWhereUniqueInput.schema'
const makeSchema = () => z.object({
create: z.union([z.lazy(() => PatientConversationCreateWithoutPatientInputObjectSchema), z.lazy(() => PatientConversationUncheckedCreateWithoutPatientInputObjectSchema)]).optional(),
connectOrCreate: z.lazy(() => PatientConversationCreateOrConnectWithoutPatientInputObjectSchema).optional(),
connect: z.lazy(() => PatientConversationWhereUniqueInputObjectSchema).optional()
}).strict();
export const PatientConversationUncheckedCreateNestedOneWithoutPatientInputObjectSchema: z.ZodType<Prisma.PatientConversationUncheckedCreateNestedOneWithoutPatientInput> = makeSchema() as unknown as z.ZodType<Prisma.PatientConversationUncheckedCreateNestedOneWithoutPatientInput>;
export const PatientConversationUncheckedCreateNestedOneWithoutPatientInputObjectZodSchema = makeSchema();

13
packages/db/shared/schemas/objects/PatientConversationUncheckedCreateWithoutPatientInput.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(),
stage: z.string().optional(),
aiHandoff: z.boolean().optional(),
updatedAt: z.coerce.date().optional()
}).strict();
export const PatientConversationUncheckedCreateWithoutPatientInputObjectSchema: z.ZodType<Prisma.PatientConversationUncheckedCreateWithoutPatientInput> = makeSchema() as unknown as z.ZodType<Prisma.PatientConversationUncheckedCreateWithoutPatientInput>;
export const PatientConversationUncheckedCreateWithoutPatientInputObjectZodSchema = makeSchema();

13
packages/db/shared/schemas/objects/PatientConversationUncheckedCreateWithoutUserInput.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(),
patientId: z.number().int(),
stage: z.string().optional(),
aiHandoff: z.boolean().optional(),
updatedAt: z.coerce.date().optional()
}).strict();
export const PatientConversationUncheckedCreateWithoutUserInputObjectSchema: z.ZodType<Prisma.PatientConversationUncheckedCreateWithoutUserInput> = makeSchema() as unknown as z.ZodType<Prisma.PatientConversationUncheckedCreateWithoutUserInput>;
export const PatientConversationUncheckedCreateWithoutUserInputObjectZodSchema = makeSchema();

17
packages/db/shared/schemas/objects/PatientConversationUncheckedUpdateInput.schema.ts Normal file
View File

@@ -0,0 +1,17 @@
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 { BoolFieldUpdateOperationsInputObjectSchema as BoolFieldUpdateOperationsInputObjectSchema } from './BoolFieldUpdateOperationsInput.schema';
import { DateTimeFieldUpdateOperationsInputObjectSchema as DateTimeFieldUpdateOperationsInputObjectSchema } from './DateTimeFieldUpdateOperationsInput.schema'
const makeSchema = () => z.object({
id: z.union([z.number().int(), z.lazy(() => IntFieldUpdateOperationsInputObjectSchema)]).optional(),
patientId: z.union([z.number().int(), z.lazy(() => IntFieldUpdateOperationsInputObjectSchema)]).optional(),
userId: z.union([z.number().int(), z.lazy(() => IntFieldUpdateOperationsInputObjectSchema)]).optional(),
stage: z.union([z.string(), z.lazy(() => StringFieldUpdateOperationsInputObjectSchema)]).optional(),
aiHandoff: z.union([z.boolean(), z.lazy(() => BoolFieldUpdateOperationsInputObjectSchema)]).optional(),
updatedAt: z.union([z.coerce.date(), z.lazy(() => DateTimeFieldUpdateOperationsInputObjectSchema)]).optional()
}).strict();
export const PatientConversationUncheckedUpdateInputObjectSchema: z.ZodType<Prisma.PatientConversationUncheckedUpdateInput> = makeSchema() as unknown as z.ZodType<Prisma.PatientConversationUncheckedUpdateInput>;
export const PatientConversationUncheckedUpdateInputObjectZodSchema = makeSchema();

17
packages/db/shared/schemas/objects/PatientConversationUncheckedUpdateManyInput.schema.ts Normal file
View File

@@ -0,0 +1,17 @@
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 { BoolFieldUpdateOperationsInputObjectSchema as BoolFieldUpdateOperationsInputObjectSchema } from './BoolFieldUpdateOperationsInput.schema';
import { DateTimeFieldUpdateOperationsInputObjectSchema as DateTimeFieldUpdateOperationsInputObjectSchema } from './DateTimeFieldUpdateOperationsInput.schema'
const makeSchema = () => z.object({
id: z.union([z.number().int(), z.lazy(() => IntFieldUpdateOperationsInputObjectSchema)]).optional(),
patientId: z.union([z.number().int(), z.lazy(() => IntFieldUpdateOperationsInputObjectSchema)]).optional(),
userId: z.union([z.number().int(), z.lazy(() => IntFieldUpdateOperationsInputObjectSchema)]).optional(),
stage: z.union([z.string(), z.lazy(() => StringFieldUpdateOperationsInputObjectSchema)]).optional(),
aiHandoff: z.union([z.boolean(), z.lazy(() => BoolFieldUpdateOperationsInputObjectSchema)]).optional(),
updatedAt: z.union([z.coerce.date(), z.lazy(() => DateTimeFieldUpdateOperationsInputObjectSchema)]).optional()
}).strict();
export const PatientConversationUncheckedUpdateManyInputObjectSchema: z.ZodType<Prisma.PatientConversationUncheckedUpdateManyInput> = makeSchema() as unknown as z.ZodType<Prisma.PatientConversationUncheckedUpdateManyInput>;
export const PatientConversationUncheckedUpdateManyInputObjectZodSchema = makeSchema();

16
packages/db/shared/schemas/objects/PatientConversationUncheckedUpdateManyWithoutUserInput.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 { BoolFieldUpdateOperationsInputObjectSchema as BoolFieldUpdateOperationsInputObjectSchema } from './BoolFieldUpdateOperationsInput.schema';
import { DateTimeFieldUpdateOperationsInputObjectSchema as DateTimeFieldUpdateOperationsInputObjectSchema } from './DateTimeFieldUpdateOperationsInput.schema'
const makeSchema = () => z.object({
id: z.union([z.number().int(), z.lazy(() => IntFieldUpdateOperationsInputObjectSchema)]).optional(),
patientId: z.union([z.number().int(), z.lazy(() => IntFieldUpdateOperationsInputObjectSchema)]).optional(),
stage: z.union([z.string(), z.lazy(() => StringFieldUpdateOperationsInputObjectSchema)]).optional(),
aiHandoff: z.union([z.boolean(), z.lazy(() => BoolFieldUpdateOperationsInputObjectSchema)]).optional(),
updatedAt: z.union([z.coerce.date(), z.lazy(() => DateTimeFieldUpdateOperationsInputObjectSchema)]).optional()
}).strict();
export const PatientConversationUncheckedUpdateManyWithoutUserInputObjectSchema: z.ZodType<Prisma.PatientConversationUncheckedUpdateManyWithoutUserInput> = makeSchema() as unknown as z.ZodType<Prisma.PatientConversationUncheckedUpdateManyWithoutUserInput>;
export const PatientConversationUncheckedUpdateManyWithoutUserInputObjectZodSchema = makeSchema();

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

@@ -0,0 +1,27 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { PatientConversationCreateWithoutUserInputObjectSchema as PatientConversationCreateWithoutUserInputObjectSchema } from './PatientConversationCreateWithoutUserInput.schema';
import { PatientConversationUncheckedCreateWithoutUserInputObjectSchema as PatientConversationUncheckedCreateWithoutUserInputObjectSchema } from './PatientConversationUncheckedCreateWithoutUserInput.schema';
import { PatientConversationCreateOrConnectWithoutUserInputObjectSchema as PatientConversationCreateOrConnectWithoutUserInputObjectSchema } from './PatientConversationCreateOrConnectWithoutUserInput.schema';
import { PatientConversationUpsertWithWhereUniqueWithoutUserInputObjectSchema as PatientConversationUpsertWithWhereUniqueWithoutUserInputObjectSchema } from './PatientConversationUpsertWithWhereUniqueWithoutUserInput.schema';
import { PatientConversationCreateManyUserInputEnvelopeObjectSchema as PatientConversationCreateManyUserInputEnvelopeObjectSchema } from './PatientConversationCreateManyUserInputEnvelope.schema';
import { PatientConversationWhereUniqueInputObjectSchema as PatientConversationWhereUniqueInputObjectSchema } from './PatientConversationWhereUniqueInput.schema';
import { PatientConversationUpdateWithWhereUniqueWithoutUserInputObjectSchema as PatientConversationUpdateWithWhereUniqueWithoutUserInputObjectSchema } from './PatientConversationUpdateWithWhereUniqueWithoutUserInput.schema';
import { PatientConversationUpdateManyWithWhereWithoutUserInputObjectSchema as PatientConversationUpdateManyWithWhereWithoutUserInputObjectSchema } from './PatientConversationUpdateManyWithWhereWithoutUserInput.schema';
import { PatientConversationScalarWhereInputObjectSchema as PatientConversationScalarWhereInputObjectSchema } from './PatientConversationScalarWhereInput.schema'
const makeSchema = () => z.object({
create: z.union([z.lazy(() => PatientConversationCreateWithoutUserInputObjectSchema), z.lazy(() => PatientConversationCreateWithoutUserInputObjectSchema).array(), z.lazy(() => PatientConversationUncheckedCreateWithoutUserInputObjectSchema), z.lazy(() => PatientConversationUncheckedCreateWithoutUserInputObjectSchema).array()]).optional(),
connectOrCreate: z.union([z.lazy(() => PatientConversationCreateOrConnectWithoutUserInputObjectSchema), z.lazy(() => PatientConversationCreateOrConnectWithoutUserInputObjectSchema).array()]).optional(),
upsert: z.union([z.lazy(() => PatientConversationUpsertWithWhereUniqueWithoutUserInputObjectSchema), z.lazy(() => PatientConversationUpsertWithWhereUniqueWithoutUserInputObjectSchema).array()]).optional(),
createMany: z.lazy(() => PatientConversationCreateManyUserInputEnvelopeObjectSchema).optional(),
set: z.union([z.lazy(() => PatientConversationWhereUniqueInputObjectSchema), z.lazy(() => PatientConversationWhereUniqueInputObjectSchema).array()]).optional(),
disconnect: z.union([z.lazy(() => PatientConversationWhereUniqueInputObjectSchema), z.lazy(() => PatientConversationWhereUniqueInputObjectSchema).array()]).optional(),
delete: z.union([z.lazy(() => PatientConversationWhereUniqueInputObjectSchema), z.lazy(() => PatientConversationWhereUniqueInputObjectSchema).array()]).optional(),
connect: z.union([z.lazy(() => PatientConversationWhereUniqueInputObjectSchema), z.lazy(() => PatientConversationWhereUniqueInputObjectSchema).array()]).optional(),
update: z.union([z.lazy(() => PatientConversationUpdateWithWhereUniqueWithoutUserInputObjectSchema), z.lazy(() => PatientConversationUpdateWithWhereUniqueWithoutUserInputObjectSchema).array()]).optional(),
updateMany: z.union([z.lazy(() => PatientConversationUpdateManyWithWhereWithoutUserInputObjectSchema), z.lazy(() => PatientConversationUpdateManyWithWhereWithoutUserInputObjectSchema).array()]).optional(),
deleteMany: z.union([z.lazy(() => PatientConversationScalarWhereInputObjectSchema), z.lazy(() => PatientConversationScalarWhereInputObjectSchema).array()]).optional()
}).strict();
export const PatientConversationUncheckedUpdateManyWithoutUserNestedInputObjectSchema: z.ZodType<Prisma.PatientConversationUncheckedUpdateManyWithoutUserNestedInput> = makeSchema() as unknown as z.ZodType<Prisma.PatientConversationUncheckedUpdateManyWithoutUserNestedInput>;
export const PatientConversationUncheckedUpdateManyWithoutUserNestedInputObjectZodSchema = makeSchema();

23
packages/db/shared/schemas/objects/PatientConversationUncheckedUpdateOneWithoutPatientNestedInput.schema.ts Normal file
View File

@@ -0,0 +1,23 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { PatientConversationCreateWithoutPatientInputObjectSchema as PatientConversationCreateWithoutPatientInputObjectSchema } from './PatientConversationCreateWithoutPatientInput.schema';
import { PatientConversationUncheckedCreateWithoutPatientInputObjectSchema as PatientConversationUncheckedCreateWithoutPatientInputObjectSchema } from './PatientConversationUncheckedCreateWithoutPatientInput.schema';
import { PatientConversationCreateOrConnectWithoutPatientInputObjectSchema as PatientConversationCreateOrConnectWithoutPatientInputObjectSchema } from './PatientConversationCreateOrConnectWithoutPatientInput.schema';
import { PatientConversationUpsertWithoutPatientInputObjectSchema as PatientConversationUpsertWithoutPatientInputObjectSchema } from './PatientConversationUpsertWithoutPatientInput.schema';
import { PatientConversationWhereInputObjectSchema as PatientConversationWhereInputObjectSchema } from './PatientConversationWhereInput.schema';
import { PatientConversationWhereUniqueInputObjectSchema as PatientConversationWhereUniqueInputObjectSchema } from './PatientConversationWhereUniqueInput.schema';
import { PatientConversationUpdateToOneWithWhereWithoutPatientInputObjectSchema as PatientConversationUpdateToOneWithWhereWithoutPatientInputObjectSchema } from './PatientConversationUpdateToOneWithWhereWithoutPatientInput.schema';
import { PatientConversationUpdateWithoutPatientInputObjectSchema as PatientConversationUpdateWithoutPatientInputObjectSchema } from './PatientConversationUpdateWithoutPatientInput.schema';
import { PatientConversationUncheckedUpdateWithoutPatientInputObjectSchema as PatientConversationUncheckedUpdateWithoutPatientInputObjectSchema } from './PatientConversationUncheckedUpdateWithoutPatientInput.schema'
const makeSchema = () => z.object({
create: z.union([z.lazy(() => PatientConversationCreateWithoutPatientInputObjectSchema), z.lazy(() => PatientConversationUncheckedCreateWithoutPatientInputObjectSchema)]).optional(),
connectOrCreate: z.lazy(() => PatientConversationCreateOrConnectWithoutPatientInputObjectSchema).optional(),
upsert: z.lazy(() => PatientConversationUpsertWithoutPatientInputObjectSchema).optional(),
disconnect: z.union([z.boolean(), z.lazy(() => PatientConversationWhereInputObjectSchema)]).optional(),
delete: z.union([z.boolean(), z.lazy(() => PatientConversationWhereInputObjectSchema)]).optional(),
connect: z.lazy(() => PatientConversationWhereUniqueInputObjectSchema).optional(),
update: z.union([z.lazy(() => PatientConversationUpdateToOneWithWhereWithoutPatientInputObjectSchema), z.lazy(() => PatientConversationUpdateWithoutPatientInputObjectSchema), z.lazy(() => PatientConversationUncheckedUpdateWithoutPatientInputObjectSchema)]).optional()
}).strict();
export const PatientConversationUncheckedUpdateOneWithoutPatientNestedInputObjectSchema: z.ZodType<Prisma.PatientConversationUncheckedUpdateOneWithoutPatientNestedInput> = makeSchema() as unknown as z.ZodType<Prisma.PatientConversationUncheckedUpdateOneWithoutPatientNestedInput>;
export const PatientConversationUncheckedUpdateOneWithoutPatientNestedInputObjectZodSchema = makeSchema();

16
packages/db/shared/schemas/objects/PatientConversationUncheckedUpdateWithoutPatientInput.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 { BoolFieldUpdateOperationsInputObjectSchema as BoolFieldUpdateOperationsInputObjectSchema } from './BoolFieldUpdateOperationsInput.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(),
stage: z.union([z.string(), z.lazy(() => StringFieldUpdateOperationsInputObjectSchema)]).optional(),
aiHandoff: z.union([z.boolean(), z.lazy(() => BoolFieldUpdateOperationsInputObjectSchema)]).optional(),
updatedAt: z.union([z.coerce.date(), z.lazy(() => DateTimeFieldUpdateOperationsInputObjectSchema)]).optional()
}).strict();
export const PatientConversationUncheckedUpdateWithoutPatientInputObjectSchema: z.ZodType<Prisma.PatientConversationUncheckedUpdateWithoutPatientInput> = makeSchema() as unknown as z.ZodType<Prisma.PatientConversationUncheckedUpdateWithoutPatientInput>;
export const PatientConversationUncheckedUpdateWithoutPatientInputObjectZodSchema = makeSchema();

16
packages/db/shared/schemas/objects/PatientConversationUncheckedUpdateWithoutUserInput.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 { BoolFieldUpdateOperationsInputObjectSchema as BoolFieldUpdateOperationsInputObjectSchema } from './BoolFieldUpdateOperationsInput.schema';
import { DateTimeFieldUpdateOperationsInputObjectSchema as DateTimeFieldUpdateOperationsInputObjectSchema } from './DateTimeFieldUpdateOperationsInput.schema'
const makeSchema = () => z.object({
id: z.union([z.number().int(), z.lazy(() => IntFieldUpdateOperationsInputObjectSchema)]).optional(),
patientId: z.union([z.number().int(), z.lazy(() => IntFieldUpdateOperationsInputObjectSchema)]).optional(),
stage: z.union([z.string(), z.lazy(() => StringFieldUpdateOperationsInputObjectSchema)]).optional(),
aiHandoff: z.union([z.boolean(), z.lazy(() => BoolFieldUpdateOperationsInputObjectSchema)]).optional(),
updatedAt: z.union([z.coerce.date(), z.lazy(() => DateTimeFieldUpdateOperationsInputObjectSchema)]).optional()
}).strict();
export const PatientConversationUncheckedUpdateWithoutUserInputObjectSchema: z.ZodType<Prisma.PatientConversationUncheckedUpdateWithoutUserInput> = makeSchema() as unknown as z.ZodType<Prisma.PatientConversationUncheckedUpdateWithoutUserInput>;
export const PatientConversationUncheckedUpdateWithoutUserInputObjectZodSchema = makeSchema();

17
packages/db/shared/schemas/objects/PatientConversationUpdateInput.schema.ts Normal file
View File

@@ -0,0 +1,17 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { StringFieldUpdateOperationsInputObjectSchema as StringFieldUpdateOperationsInputObjectSchema } from './StringFieldUpdateOperationsInput.schema';
import { BoolFieldUpdateOperationsInputObjectSchema as BoolFieldUpdateOperationsInputObjectSchema } from './BoolFieldUpdateOperationsInput.schema';
import { DateTimeFieldUpdateOperationsInputObjectSchema as DateTimeFieldUpdateOperationsInputObjectSchema } from './DateTimeFieldUpdateOperationsInput.schema';
import { PatientUpdateOneRequiredWithoutConversationNestedInputObjectSchema as PatientUpdateOneRequiredWithoutConversationNestedInputObjectSchema } from './PatientUpdateOneRequiredWithoutConversationNestedInput.schema';
import { UserUpdateOneRequiredWithoutPatientConversationsNestedInputObjectSchema as UserUpdateOneRequiredWithoutPatientConversationsNestedInputObjectSchema } from './UserUpdateOneRequiredWithoutPatientConversationsNestedInput.schema'
const makeSchema = () => z.object({
stage: z.union([z.string(), z.lazy(() => StringFieldUpdateOperationsInputObjectSchema)]).optional(),
aiHandoff: z.union([z.boolean(), z.lazy(() => BoolFieldUpdateOperationsInputObjectSchema)]).optional(),
updatedAt: z.union([z.coerce.date(), z.lazy(() => DateTimeFieldUpdateOperationsInputObjectSchema)]).optional(),
patient: z.lazy(() => PatientUpdateOneRequiredWithoutConversationNestedInputObjectSchema).optional(),
user: z.lazy(() => UserUpdateOneRequiredWithoutPatientConversationsNestedInputObjectSchema).optional()
}).strict();
export const PatientConversationUpdateInputObjectSchema: z.ZodType<Prisma.PatientConversationUpdateInput> = makeSchema() as unknown as z.ZodType<Prisma.PatientConversationUpdateInput>;
export const PatientConversationUpdateInputObjectZodSchema = makeSchema();

13
packages/db/shared/schemas/objects/PatientConversationUpdateManyMutationInput.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 { BoolFieldUpdateOperationsInputObjectSchema as BoolFieldUpdateOperationsInputObjectSchema } from './BoolFieldUpdateOperationsInput.schema';
import { DateTimeFieldUpdateOperationsInputObjectSchema as DateTimeFieldUpdateOperationsInputObjectSchema } from './DateTimeFieldUpdateOperationsInput.schema'
const makeSchema = () => z.object({
stage: z.union([z.string(), z.lazy(() => StringFieldUpdateOperationsInputObjectSchema)]).optional(),
aiHandoff: z.union([z.boolean(), z.lazy(() => BoolFieldUpdateOperationsInputObjectSchema)]).optional(),
updatedAt: z.union([z.coerce.date(), z.lazy(() => DateTimeFieldUpdateOperationsInputObjectSchema)]).optional()
}).strict();
export const PatientConversationUpdateManyMutationInputObjectSchema: z.ZodType<Prisma.PatientConversationUpdateManyMutationInput> = makeSchema() as unknown as z.ZodType<Prisma.PatientConversationUpdateManyMutationInput>;
export const PatientConversationUpdateManyMutationInputObjectZodSchema = makeSchema();

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

@@ -0,0 +1,12 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { PatientConversationScalarWhereInputObjectSchema as PatientConversationScalarWhereInputObjectSchema } from './PatientConversationScalarWhereInput.schema';
import { PatientConversationUpdateManyMutationInputObjectSchema as PatientConversationUpdateManyMutationInputObjectSchema } from './PatientConversationUpdateManyMutationInput.schema';
import { PatientConversationUncheckedUpdateManyWithoutUserInputObjectSchema as PatientConversationUncheckedUpdateManyWithoutUserInputObjectSchema } from './PatientConversationUncheckedUpdateManyWithoutUserInput.schema'
const makeSchema = () => z.object({
where: z.lazy(() => PatientConversationScalarWhereInputObjectSchema),
data: z.union([z.lazy(() => PatientConversationUpdateManyMutationInputObjectSchema), z.lazy(() => PatientConversationUncheckedUpdateManyWithoutUserInputObjectSchema)])
}).strict();
export const PatientConversationUpdateManyWithWhereWithoutUserInputObjectSchema: z.ZodType<Prisma.PatientConversationUpdateManyWithWhereWithoutUserInput> = makeSchema() as unknown as z.ZodType<Prisma.PatientConversationUpdateManyWithWhereWithoutUserInput>;
export const PatientConversationUpdateManyWithWhereWithoutUserInputObjectZodSchema = makeSchema();

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

@@ -0,0 +1,27 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { PatientConversationCreateWithoutUserInputObjectSchema as PatientConversationCreateWithoutUserInputObjectSchema } from './PatientConversationCreateWithoutUserInput.schema';
import { PatientConversationUncheckedCreateWithoutUserInputObjectSchema as PatientConversationUncheckedCreateWithoutUserInputObjectSchema } from './PatientConversationUncheckedCreateWithoutUserInput.schema';
import { PatientConversationCreateOrConnectWithoutUserInputObjectSchema as PatientConversationCreateOrConnectWithoutUserInputObjectSchema } from './PatientConversationCreateOrConnectWithoutUserInput.schema';
import { PatientConversationUpsertWithWhereUniqueWithoutUserInputObjectSchema as PatientConversationUpsertWithWhereUniqueWithoutUserInputObjectSchema } from './PatientConversationUpsertWithWhereUniqueWithoutUserInput.schema';
import { PatientConversationCreateManyUserInputEnvelopeObjectSchema as PatientConversationCreateManyUserInputEnvelopeObjectSchema } from './PatientConversationCreateManyUserInputEnvelope.schema';
import { PatientConversationWhereUniqueInputObjectSchema as PatientConversationWhereUniqueInputObjectSchema } from './PatientConversationWhereUniqueInput.schema';
import { PatientConversationUpdateWithWhereUniqueWithoutUserInputObjectSchema as PatientConversationUpdateWithWhereUniqueWithoutUserInputObjectSchema } from './PatientConversationUpdateWithWhereUniqueWithoutUserInput.schema';
import { PatientConversationUpdateManyWithWhereWithoutUserInputObjectSchema as PatientConversationUpdateManyWithWhereWithoutUserInputObjectSchema } from './PatientConversationUpdateManyWithWhereWithoutUserInput.schema';
import { PatientConversationScalarWhereInputObjectSchema as PatientConversationScalarWhereInputObjectSchema } from './PatientConversationScalarWhereInput.schema'
const makeSchema = () => z.object({
create: z.union([z.lazy(() => PatientConversationCreateWithoutUserInputObjectSchema), z.lazy(() => PatientConversationCreateWithoutUserInputObjectSchema).array(), z.lazy(() => PatientConversationUncheckedCreateWithoutUserInputObjectSchema), z.lazy(() => PatientConversationUncheckedCreateWithoutUserInputObjectSchema).array()]).optional(),
connectOrCreate: z.union([z.lazy(() => PatientConversationCreateOrConnectWithoutUserInputObjectSchema), z.lazy(() => PatientConversationCreateOrConnectWithoutUserInputObjectSchema).array()]).optional(),
upsert: z.union([z.lazy(() => PatientConversationUpsertWithWhereUniqueWithoutUserInputObjectSchema), z.lazy(() => PatientConversationUpsertWithWhereUniqueWithoutUserInputObjectSchema).array()]).optional(),
createMany: z.lazy(() => PatientConversationCreateManyUserInputEnvelopeObjectSchema).optional(),
set: z.union([z.lazy(() => PatientConversationWhereUniqueInputObjectSchema), z.lazy(() => PatientConversationWhereUniqueInputObjectSchema).array()]).optional(),
disconnect: z.union([z.lazy(() => PatientConversationWhereUniqueInputObjectSchema), z.lazy(() => PatientConversationWhereUniqueInputObjectSchema).array()]).optional(),
delete: z.union([z.lazy(() => PatientConversationWhereUniqueInputObjectSchema), z.lazy(() => PatientConversationWhereUniqueInputObjectSchema).array()]).optional(),
connect: z.union([z.lazy(() => PatientConversationWhereUniqueInputObjectSchema), z.lazy(() => PatientConversationWhereUniqueInputObjectSchema).array()]).optional(),
update: z.union([z.lazy(() => PatientConversationUpdateWithWhereUniqueWithoutUserInputObjectSchema), z.lazy(() => PatientConversationUpdateWithWhereUniqueWithoutUserInputObjectSchema).array()]).optional(),
updateMany: z.union([z.lazy(() => PatientConversationUpdateManyWithWhereWithoutUserInputObjectSchema), z.lazy(() => PatientConversationUpdateManyWithWhereWithoutUserInputObjectSchema).array()]).optional(),
deleteMany: z.union([z.lazy(() => PatientConversationScalarWhereInputObjectSchema), z.lazy(() => PatientConversationScalarWhereInputObjectSchema).array()]).optional()
}).strict();
export const PatientConversationUpdateManyWithoutUserNestedInputObjectSchema: z.ZodType<Prisma.PatientConversationUpdateManyWithoutUserNestedInput> = makeSchema() as unknown as z.ZodType<Prisma.PatientConversationUpdateManyWithoutUserNestedInput>;
export const PatientConversationUpdateManyWithoutUserNestedInputObjectZodSchema = makeSchema();

23
packages/db/shared/schemas/objects/PatientConversationUpdateOneWithoutPatientNestedInput.schema.ts Normal file
View File

@@ -0,0 +1,23 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { PatientConversationCreateWithoutPatientInputObjectSchema as PatientConversationCreateWithoutPatientInputObjectSchema } from './PatientConversationCreateWithoutPatientInput.schema';
import { PatientConversationUncheckedCreateWithoutPatientInputObjectSchema as PatientConversationUncheckedCreateWithoutPatientInputObjectSchema } from './PatientConversationUncheckedCreateWithoutPatientInput.schema';
import { PatientConversationCreateOrConnectWithoutPatientInputObjectSchema as PatientConversationCreateOrConnectWithoutPatientInputObjectSchema } from './PatientConversationCreateOrConnectWithoutPatientInput.schema';
import { PatientConversationUpsertWithoutPatientInputObjectSchema as PatientConversationUpsertWithoutPatientInputObjectSchema } from './PatientConversationUpsertWithoutPatientInput.schema';
import { PatientConversationWhereInputObjectSchema as PatientConversationWhereInputObjectSchema } from './PatientConversationWhereInput.schema';
import { PatientConversationWhereUniqueInputObjectSchema as PatientConversationWhereUniqueInputObjectSchema } from './PatientConversationWhereUniqueInput.schema';
import { PatientConversationUpdateToOneWithWhereWithoutPatientInputObjectSchema as PatientConversationUpdateToOneWithWhereWithoutPatientInputObjectSchema } from './PatientConversationUpdateToOneWithWhereWithoutPatientInput.schema';
import { PatientConversationUpdateWithoutPatientInputObjectSchema as PatientConversationUpdateWithoutPatientInputObjectSchema } from './PatientConversationUpdateWithoutPatientInput.schema';
import { PatientConversationUncheckedUpdateWithoutPatientInputObjectSchema as PatientConversationUncheckedUpdateWithoutPatientInputObjectSchema } from './PatientConversationUncheckedUpdateWithoutPatientInput.schema'
const makeSchema = () => z.object({
create: z.union([z.lazy(() => PatientConversationCreateWithoutPatientInputObjectSchema), z.lazy(() => PatientConversationUncheckedCreateWithoutPatientInputObjectSchema)]).optional(),
connectOrCreate: z.lazy(() => PatientConversationCreateOrConnectWithoutPatientInputObjectSchema).optional(),
upsert: z.lazy(() => PatientConversationUpsertWithoutPatientInputObjectSchema).optional(),
disconnect: z.union([z.boolean(), z.lazy(() => PatientConversationWhereInputObjectSchema)]).optional(),
delete: z.union([z.boolean(), z.lazy(() => PatientConversationWhereInputObjectSchema)]).optional(),
connect: z.lazy(() => PatientConversationWhereUniqueInputObjectSchema).optional(),
update: z.union([z.lazy(() => PatientConversationUpdateToOneWithWhereWithoutPatientInputObjectSchema), z.lazy(() => PatientConversationUpdateWithoutPatientInputObjectSchema), z.lazy(() => PatientConversationUncheckedUpdateWithoutPatientInputObjectSchema)]).optional()
}).strict();
export const PatientConversationUpdateOneWithoutPatientNestedInputObjectSchema: z.ZodType<Prisma.PatientConversationUpdateOneWithoutPatientNestedInput> = makeSchema() as unknown as z.ZodType<Prisma.PatientConversationUpdateOneWithoutPatientNestedInput>;
export const PatientConversationUpdateOneWithoutPatientNestedInputObjectZodSchema = makeSchema();

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

@@ -0,0 +1,12 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { PatientConversationWhereInputObjectSchema as PatientConversationWhereInputObjectSchema } from './PatientConversationWhereInput.schema';
import { PatientConversationUpdateWithoutPatientInputObjectSchema as PatientConversationUpdateWithoutPatientInputObjectSchema } from './PatientConversationUpdateWithoutPatientInput.schema';
import { PatientConversationUncheckedUpdateWithoutPatientInputObjectSchema as PatientConversationUncheckedUpdateWithoutPatientInputObjectSchema } from './PatientConversationUncheckedUpdateWithoutPatientInput.schema'
const makeSchema = () => z.object({
where: z.lazy(() => PatientConversationWhereInputObjectSchema).optional(),
data: z.union([z.lazy(() => PatientConversationUpdateWithoutPatientInputObjectSchema), z.lazy(() => PatientConversationUncheckedUpdateWithoutPatientInputObjectSchema)])
}).strict();
export const PatientConversationUpdateToOneWithWhereWithoutPatientInputObjectSchema: z.ZodType<Prisma.PatientConversationUpdateToOneWithWhereWithoutPatientInput> = makeSchema() as unknown as z.ZodType<Prisma.PatientConversationUpdateToOneWithWhereWithoutPatientInput>;
export const PatientConversationUpdateToOneWithWhereWithoutPatientInputObjectZodSchema = makeSchema();

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

@@ -0,0 +1,12 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { PatientConversationWhereUniqueInputObjectSchema as PatientConversationWhereUniqueInputObjectSchema } from './PatientConversationWhereUniqueInput.schema';
import { PatientConversationUpdateWithoutUserInputObjectSchema as PatientConversationUpdateWithoutUserInputObjectSchema } from './PatientConversationUpdateWithoutUserInput.schema';
import { PatientConversationUncheckedUpdateWithoutUserInputObjectSchema as PatientConversationUncheckedUpdateWithoutUserInputObjectSchema } from './PatientConversationUncheckedUpdateWithoutUserInput.schema'
const makeSchema = () => z.object({
where: z.lazy(() => PatientConversationWhereUniqueInputObjectSchema),
data: z.union([z.lazy(() => PatientConversationUpdateWithoutUserInputObjectSchema), z.lazy(() => PatientConversationUncheckedUpdateWithoutUserInputObjectSchema)])
}).strict();
export const PatientConversationUpdateWithWhereUniqueWithoutUserInputObjectSchema: z.ZodType<Prisma.PatientConversationUpdateWithWhereUniqueWithoutUserInput> = makeSchema() as unknown as z.ZodType<Prisma.PatientConversationUpdateWithWhereUniqueWithoutUserInput>;
export const PatientConversationUpdateWithWhereUniqueWithoutUserInputObjectZodSchema = makeSchema();

15
packages/db/shared/schemas/objects/PatientConversationUpdateWithoutPatientInput.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 { BoolFieldUpdateOperationsInputObjectSchema as BoolFieldUpdateOperationsInputObjectSchema } from './BoolFieldUpdateOperationsInput.schema';
import { DateTimeFieldUpdateOperationsInputObjectSchema as DateTimeFieldUpdateOperationsInputObjectSchema } from './DateTimeFieldUpdateOperationsInput.schema';
import { UserUpdateOneRequiredWithoutPatientConversationsNestedInputObjectSchema as UserUpdateOneRequiredWithoutPatientConversationsNestedInputObjectSchema } from './UserUpdateOneRequiredWithoutPatientConversationsNestedInput.schema'
const makeSchema = () => z.object({
stage: z.union([z.string(), z.lazy(() => StringFieldUpdateOperationsInputObjectSchema)]).optional(),
aiHandoff: z.union([z.boolean(), z.lazy(() => BoolFieldUpdateOperationsInputObjectSchema)]).optional(),
updatedAt: z.union([z.coerce.date(), z.lazy(() => DateTimeFieldUpdateOperationsInputObjectSchema)]).optional(),
user: z.lazy(() => UserUpdateOneRequiredWithoutPatientConversationsNestedInputObjectSchema).optional()
}).strict();
export const PatientConversationUpdateWithoutPatientInputObjectSchema: z.ZodType<Prisma.PatientConversationUpdateWithoutPatientInput> = makeSchema() as unknown as z.ZodType<Prisma.PatientConversationUpdateWithoutPatientInput>;
export const PatientConversationUpdateWithoutPatientInputObjectZodSchema = makeSchema();

15
packages/db/shared/schemas/objects/PatientConversationUpdateWithoutUserInput.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 { BoolFieldUpdateOperationsInputObjectSchema as BoolFieldUpdateOperationsInputObjectSchema } from './BoolFieldUpdateOperationsInput.schema';
import { DateTimeFieldUpdateOperationsInputObjectSchema as DateTimeFieldUpdateOperationsInputObjectSchema } from './DateTimeFieldUpdateOperationsInput.schema';
import { PatientUpdateOneRequiredWithoutConversationNestedInputObjectSchema as PatientUpdateOneRequiredWithoutConversationNestedInputObjectSchema } from './PatientUpdateOneRequiredWithoutConversationNestedInput.schema'
const makeSchema = () => z.object({
stage: z.union([z.string(), z.lazy(() => StringFieldUpdateOperationsInputObjectSchema)]).optional(),
aiHandoff: z.union([z.boolean(), z.lazy(() => BoolFieldUpdateOperationsInputObjectSchema)]).optional(),
updatedAt: z.union([z.coerce.date(), z.lazy(() => DateTimeFieldUpdateOperationsInputObjectSchema)]).optional(),
patient: z.lazy(() => PatientUpdateOneRequiredWithoutConversationNestedInputObjectSchema).optional()
}).strict();
export const PatientConversationUpdateWithoutUserInputObjectSchema: z.ZodType<Prisma.PatientConversationUpdateWithoutUserInput> = makeSchema() as unknown as z.ZodType<Prisma.PatientConversationUpdateWithoutUserInput>;
export const PatientConversationUpdateWithoutUserInputObjectZodSchema = makeSchema();

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

@@ -0,0 +1,15 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { PatientConversationWhereUniqueInputObjectSchema as PatientConversationWhereUniqueInputObjectSchema } from './PatientConversationWhereUniqueInput.schema';
import { PatientConversationUpdateWithoutUserInputObjectSchema as PatientConversationUpdateWithoutUserInputObjectSchema } from './PatientConversationUpdateWithoutUserInput.schema';
import { PatientConversationUncheckedUpdateWithoutUserInputObjectSchema as PatientConversationUncheckedUpdateWithoutUserInputObjectSchema } from './PatientConversationUncheckedUpdateWithoutUserInput.schema';
import { PatientConversationCreateWithoutUserInputObjectSchema as PatientConversationCreateWithoutUserInputObjectSchema } from './PatientConversationCreateWithoutUserInput.schema';
import { PatientConversationUncheckedCreateWithoutUserInputObjectSchema as PatientConversationUncheckedCreateWithoutUserInputObjectSchema } from './PatientConversationUncheckedCreateWithoutUserInput.schema'
const makeSchema = () => z.object({
where: z.lazy(() => PatientConversationWhereUniqueInputObjectSchema),
update: z.union([z.lazy(() => PatientConversationUpdateWithoutUserInputObjectSchema), z.lazy(() => PatientConversationUncheckedUpdateWithoutUserInputObjectSchema)]),
create: z.union([z.lazy(() => PatientConversationCreateWithoutUserInputObjectSchema), z.lazy(() => PatientConversationUncheckedCreateWithoutUserInputObjectSchema)])
}).strict();
export const PatientConversationUpsertWithWhereUniqueWithoutUserInputObjectSchema: z.ZodType<Prisma.PatientConversationUpsertWithWhereUniqueWithoutUserInput> = makeSchema() as unknown as z.ZodType<Prisma.PatientConversationUpsertWithWhereUniqueWithoutUserInput>;
export const PatientConversationUpsertWithWhereUniqueWithoutUserInputObjectZodSchema = makeSchema();

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

@@ -0,0 +1,15 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { PatientConversationUpdateWithoutPatientInputObjectSchema as PatientConversationUpdateWithoutPatientInputObjectSchema } from './PatientConversationUpdateWithoutPatientInput.schema';
import { PatientConversationUncheckedUpdateWithoutPatientInputObjectSchema as PatientConversationUncheckedUpdateWithoutPatientInputObjectSchema } from './PatientConversationUncheckedUpdateWithoutPatientInput.schema';
import { PatientConversationCreateWithoutPatientInputObjectSchema as PatientConversationCreateWithoutPatientInputObjectSchema } from './PatientConversationCreateWithoutPatientInput.schema';
import { PatientConversationUncheckedCreateWithoutPatientInputObjectSchema as PatientConversationUncheckedCreateWithoutPatientInputObjectSchema } from './PatientConversationUncheckedCreateWithoutPatientInput.schema';
import { PatientConversationWhereInputObjectSchema as PatientConversationWhereInputObjectSchema } from './PatientConversationWhereInput.schema'
const makeSchema = () => z.object({
update: z.union([z.lazy(() => PatientConversationUpdateWithoutPatientInputObjectSchema), z.lazy(() => PatientConversationUncheckedUpdateWithoutPatientInputObjectSchema)]),
create: z.union([z.lazy(() => PatientConversationCreateWithoutPatientInputObjectSchema), z.lazy(() => PatientConversationUncheckedCreateWithoutPatientInputObjectSchema)]),
where: z.lazy(() => PatientConversationWhereInputObjectSchema).optional()
}).strict();
export const PatientConversationUpsertWithoutPatientInputObjectSchema: z.ZodType<Prisma.PatientConversationUpsertWithoutPatientInput> = makeSchema() as unknown as z.ZodType<Prisma.PatientConversationUpsertWithoutPatientInput>;
export const PatientConversationUpsertWithoutPatientInputObjectZodSchema = makeSchema();

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