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

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();

26
packages/db/shared/schemas/objects/PatientConversationWhereInput.schema.ts Normal file
View File

@@ -0,0 +1,26 @@
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';
import { PatientScalarRelationFilterObjectSchema as PatientScalarRelationFilterObjectSchema } from './PatientScalarRelationFilter.schema';
import { PatientWhereInputObjectSchema as PatientWhereInputObjectSchema } from './PatientWhereInput.schema';
import { UserScalarRelationFilterObjectSchema as UserScalarRelationFilterObjectSchema } from './UserScalarRelationFilter.schema';
import { UserWhereInputObjectSchema as UserWhereInputObjectSchema } from './UserWhereInput.schema'
const patientconversationwhereinputSchema = z.object({
AND: z.union([z.lazy(() => PatientConversationWhereInputObjectSchema), z.lazy(() => PatientConversationWhereInputObjectSchema).array()]).optional(),
OR: z.lazy(() => PatientConversationWhereInputObjectSchema).array().optional(),
NOT: z.union([z.lazy(() => PatientConversationWhereInputObjectSchema), z.lazy(() => PatientConversationWhereInputObjectSchema).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(),
patient: z.union([z.lazy(() => PatientScalarRelationFilterObjectSchema), z.lazy(() => PatientWhereInputObjectSchema)]).optional(),
user: z.union([z.lazy(() => UserScalarRelationFilterObjectSchema), z.lazy(() => UserWhereInputObjectSchema)]).optional()
}).strict();
export const PatientConversationWhereInputObjectSchema: z.ZodType<Prisma.PatientConversationWhereInput> = patientconversationwhereinputSchema as unknown as z.ZodType<Prisma.PatientConversationWhereInput>;
export const PatientConversationWhereInputObjectZodSchema = patientconversationwhereinputSchema;

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

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

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

@@ -8,7 +8,8 @@ import { ClaimCreateNestedManyWithoutPatientInputObjectSchema as ClaimCreateNest
import { PdfGroupCreateNestedManyWithoutPatientInputObjectSchema as PdfGroupCreateNestedManyWithoutPatientInputObjectSchema } from './PdfGroupCreateNestedManyWithoutPatientInput.schema';
import { PaymentCreateNestedManyWithoutPatientInputObjectSchema as PaymentCreateNestedManyWithoutPatientInputObjectSchema } from './PaymentCreateNestedManyWithoutPatientInput.schema';
import { CommunicationCreateNestedManyWithoutPatientInputObjectSchema as CommunicationCreateNestedManyWithoutPatientInputObjectSchema } from './CommunicationCreateNestedManyWithoutPatientInput.schema';
import { PatientDocumentCreateNestedManyWithoutPatientInputObjectSchema as PatientDocumentCreateNestedManyWithoutPatientInputObjectSchema } from './PatientDocumentCreateNestedManyWithoutPatientInput.schema'
import { PatientDocumentCreateNestedManyWithoutPatientInputObjectSchema as PatientDocumentCreateNestedManyWithoutPatientInputObjectSchema } from './PatientDocumentCreateNestedManyWithoutPatientInput.schema';
import { PatientConversationCreateNestedOneWithoutPatientInputObjectSchema as PatientConversationCreateNestedOneWithoutPatientInputObjectSchema } from './PatientConversationCreateNestedOneWithoutPatientInput.schema'
const makeSchema = () => z.object({
firstName: z.string(),
@@ -36,7 +37,8 @@ const makeSchema = () => z.object({
groups: z.lazy(() => PdfGroupCreateNestedManyWithoutPatientInputObjectSchema).optional(),
payment: z.lazy(() => PaymentCreateNestedManyWithoutPatientInputObjectSchema).optional(),
communications: z.lazy(() => CommunicationCreateNestedManyWithoutPatientInputObjectSchema).optional(),
documents: z.lazy(() => PatientDocumentCreateNestedManyWithoutPatientInputObjectSchema).optional()
documents: z.lazy(() => PatientDocumentCreateNestedManyWithoutPatientInputObjectSchema).optional(),
conversation: z.lazy(() => PatientConversationCreateNestedOneWithoutPatientInputObjectSchema).optional()
}).strict();
export const PatientCreateInputObjectSchema: z.ZodType<Prisma.PatientCreateInput> = makeSchema() as unknown as z.ZodType<Prisma.PatientCreateInput>;
export const PatientCreateInputObjectZodSchema = makeSchema();

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

@@ -0,0 +1,14 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { PatientCreateWithoutConversationInputObjectSchema as PatientCreateWithoutConversationInputObjectSchema } from './PatientCreateWithoutConversationInput.schema';
import { PatientUncheckedCreateWithoutConversationInputObjectSchema as PatientUncheckedCreateWithoutConversationInputObjectSchema } from './PatientUncheckedCreateWithoutConversationInput.schema';
import { PatientCreateOrConnectWithoutConversationInputObjectSchema as PatientCreateOrConnectWithoutConversationInputObjectSchema } from './PatientCreateOrConnectWithoutConversationInput.schema';
import { PatientWhereUniqueInputObjectSchema as PatientWhereUniqueInputObjectSchema } from './PatientWhereUniqueInput.schema'
const makeSchema = () => z.object({
create: z.union([z.lazy(() => PatientCreateWithoutConversationInputObjectSchema), z.lazy(() => PatientUncheckedCreateWithoutConversationInputObjectSchema)]).optional(),
connectOrCreate: z.lazy(() => PatientCreateOrConnectWithoutConversationInputObjectSchema).optional(),
connect: z.lazy(() => PatientWhereUniqueInputObjectSchema).optional()
}).strict();
export const PatientCreateNestedOneWithoutConversationInputObjectSchema: z.ZodType<Prisma.PatientCreateNestedOneWithoutConversationInput> = makeSchema() as unknown as z.ZodType<Prisma.PatientCreateNestedOneWithoutConversationInput>;
export const PatientCreateNestedOneWithoutConversationInputObjectZodSchema = makeSchema();

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

@@ -0,0 +1,12 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { PatientWhereUniqueInputObjectSchema as PatientWhereUniqueInputObjectSchema } from './PatientWhereUniqueInput.schema';
import { PatientCreateWithoutConversationInputObjectSchema as PatientCreateWithoutConversationInputObjectSchema } from './PatientCreateWithoutConversationInput.schema';
import { PatientUncheckedCreateWithoutConversationInputObjectSchema as PatientUncheckedCreateWithoutConversationInputObjectSchema } from './PatientUncheckedCreateWithoutConversationInput.schema'
const makeSchema = () => z.object({
where: z.lazy(() => PatientWhereUniqueInputObjectSchema),
create: z.union([z.lazy(() => PatientCreateWithoutConversationInputObjectSchema), z.lazy(() => PatientUncheckedCreateWithoutConversationInputObjectSchema)])
}).strict();
export const PatientCreateOrConnectWithoutConversationInputObjectSchema: z.ZodType<Prisma.PatientCreateOrConnectWithoutConversationInput> = makeSchema() as unknown as z.ZodType<Prisma.PatientCreateOrConnectWithoutConversationInput>;
export const PatientCreateOrConnectWithoutConversationInputObjectZodSchema = makeSchema();

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

@@ -7,7 +7,8 @@ import { ClaimCreateNestedManyWithoutPatientInputObjectSchema as ClaimCreateNest
import { PdfGroupCreateNestedManyWithoutPatientInputObjectSchema as PdfGroupCreateNestedManyWithoutPatientInputObjectSchema } from './PdfGroupCreateNestedManyWithoutPatientInput.schema';
import { PaymentCreateNestedManyWithoutPatientInputObjectSchema as PaymentCreateNestedManyWithoutPatientInputObjectSchema } from './PaymentCreateNestedManyWithoutPatientInput.schema';
import { CommunicationCreateNestedManyWithoutPatientInputObjectSchema as CommunicationCreateNestedManyWithoutPatientInputObjectSchema } from './CommunicationCreateNestedManyWithoutPatientInput.schema';
import { PatientDocumentCreateNestedManyWithoutPatientInputObjectSchema as PatientDocumentCreateNestedManyWithoutPatientInputObjectSchema } from './PatientDocumentCreateNestedManyWithoutPatientInput.schema'
import { PatientDocumentCreateNestedManyWithoutPatientInputObjectSchema as PatientDocumentCreateNestedManyWithoutPatientInputObjectSchema } from './PatientDocumentCreateNestedManyWithoutPatientInput.schema';
import { PatientConversationCreateNestedOneWithoutPatientInputObjectSchema as PatientConversationCreateNestedOneWithoutPatientInputObjectSchema } from './PatientConversationCreateNestedOneWithoutPatientInput.schema'
const makeSchema = () => z.object({
firstName: z.string(),
@@ -35,7 +36,8 @@ const makeSchema = () => z.object({
groups: z.lazy(() => PdfGroupCreateNestedManyWithoutPatientInputObjectSchema).optional(),
payment: z.lazy(() => PaymentCreateNestedManyWithoutPatientInputObjectSchema).optional(),
communications: z.lazy(() => CommunicationCreateNestedManyWithoutPatientInputObjectSchema).optional(),
documents: z.lazy(() => PatientDocumentCreateNestedManyWithoutPatientInputObjectSchema).optional()
documents: z.lazy(() => PatientDocumentCreateNestedManyWithoutPatientInputObjectSchema).optional(),
conversation: z.lazy(() => PatientConversationCreateNestedOneWithoutPatientInputObjectSchema).optional()
}).strict();
export const PatientCreateWithoutAppointmentsInputObjectSchema: z.ZodType<Prisma.PatientCreateWithoutAppointmentsInput> = makeSchema() as unknown as z.ZodType<Prisma.PatientCreateWithoutAppointmentsInput>;
export const PatientCreateWithoutAppointmentsInputObjectZodSchema = makeSchema();

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

@@ -7,7 +7,8 @@ import { AppointmentProcedureCreateNestedManyWithoutPatientInputObjectSchema as
import { PdfGroupCreateNestedManyWithoutPatientInputObjectSchema as PdfGroupCreateNestedManyWithoutPatientInputObjectSchema } from './PdfGroupCreateNestedManyWithoutPatientInput.schema';
import { PaymentCreateNestedManyWithoutPatientInputObjectSchema as PaymentCreateNestedManyWithoutPatientInputObjectSchema } from './PaymentCreateNestedManyWithoutPatientInput.schema';
import { CommunicationCreateNestedManyWithoutPatientInputObjectSchema as CommunicationCreateNestedManyWithoutPatientInputObjectSchema } from './CommunicationCreateNestedManyWithoutPatientInput.schema';
import { PatientDocumentCreateNestedManyWithoutPatientInputObjectSchema as PatientDocumentCreateNestedManyWithoutPatientInputObjectSchema } from './PatientDocumentCreateNestedManyWithoutPatientInput.schema'
import { PatientDocumentCreateNestedManyWithoutPatientInputObjectSchema as PatientDocumentCreateNestedManyWithoutPatientInputObjectSchema } from './PatientDocumentCreateNestedManyWithoutPatientInput.schema';
import { PatientConversationCreateNestedOneWithoutPatientInputObjectSchema as PatientConversationCreateNestedOneWithoutPatientInputObjectSchema } from './PatientConversationCreateNestedOneWithoutPatientInput.schema'
const makeSchema = () => z.object({
firstName: z.string(),
@@ -35,7 +36,8 @@ const makeSchema = () => z.object({
groups: z.lazy(() => PdfGroupCreateNestedManyWithoutPatientInputObjectSchema).optional(),
payment: z.lazy(() => PaymentCreateNestedManyWithoutPatientInputObjectSchema).optional(),
communications: z.lazy(() => CommunicationCreateNestedManyWithoutPatientInputObjectSchema).optional(),
documents: z.lazy(() => PatientDocumentCreateNestedManyWithoutPatientInputObjectSchema).optional()
documents: z.lazy(() => PatientDocumentCreateNestedManyWithoutPatientInputObjectSchema).optional(),
conversation: z.lazy(() => PatientConversationCreateNestedOneWithoutPatientInputObjectSchema).optional()
}).strict();
export const PatientCreateWithoutClaimsInputObjectSchema: z.ZodType<Prisma.PatientCreateWithoutClaimsInput> = makeSchema() as unknown as z.ZodType<Prisma.PatientCreateWithoutClaimsInput>;
export const PatientCreateWithoutClaimsInputObjectZodSchema = makeSchema();

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

@@ -7,7 +7,8 @@ import { AppointmentProcedureCreateNestedManyWithoutPatientInputObjectSchema as
import { ClaimCreateNestedManyWithoutPatientInputObjectSchema as ClaimCreateNestedManyWithoutPatientInputObjectSchema } from './ClaimCreateNestedManyWithoutPatientInput.schema';
import { PdfGroupCreateNestedManyWithoutPatientInputObjectSchema as PdfGroupCreateNestedManyWithoutPatientInputObjectSchema } from './PdfGroupCreateNestedManyWithoutPatientInput.schema';
import { PaymentCreateNestedManyWithoutPatientInputObjectSchema as PaymentCreateNestedManyWithoutPatientInputObjectSchema } from './PaymentCreateNestedManyWithoutPatientInput.schema';
import { PatientDocumentCreateNestedManyWithoutPatientInputObjectSchema as PatientDocumentCreateNestedManyWithoutPatientInputObjectSchema } from './PatientDocumentCreateNestedManyWithoutPatientInput.schema'
import { PatientDocumentCreateNestedManyWithoutPatientInputObjectSchema as PatientDocumentCreateNestedManyWithoutPatientInputObjectSchema } from './PatientDocumentCreateNestedManyWithoutPatientInput.schema';
import { PatientConversationCreateNestedOneWithoutPatientInputObjectSchema as PatientConversationCreateNestedOneWithoutPatientInputObjectSchema } from './PatientConversationCreateNestedOneWithoutPatientInput.schema'
const makeSchema = () => z.object({
firstName: z.string(),
@@ -35,7 +36,8 @@ const makeSchema = () => z.object({
claims: z.lazy(() => ClaimCreateNestedManyWithoutPatientInputObjectSchema).optional(),
groups: z.lazy(() => PdfGroupCreateNestedManyWithoutPatientInputObjectSchema).optional(),
payment: z.lazy(() => PaymentCreateNestedManyWithoutPatientInputObjectSchema).optional(),
documents: z.lazy(() => PatientDocumentCreateNestedManyWithoutPatientInputObjectSchema).optional()
documents: z.lazy(() => PatientDocumentCreateNestedManyWithoutPatientInputObjectSchema).optional(),
conversation: z.lazy(() => PatientConversationCreateNestedOneWithoutPatientInputObjectSchema).optional()
}).strict();
export const PatientCreateWithoutCommunicationsInputObjectSchema: z.ZodType<Prisma.PatientCreateWithoutCommunicationsInput> = makeSchema() as unknown as z.ZodType<Prisma.PatientCreateWithoutCommunicationsInput>;
export const PatientCreateWithoutCommunicationsInputObjectZodSchema = makeSchema();

43
packages/db/shared/schemas/objects/PatientCreateWithoutConversationInput.schema.ts Normal file
View File

@@ -0,0 +1,43 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { PatientStatusSchema } from '../enums/PatientStatus.schema';
import { UserCreateNestedOneWithoutPatientsInputObjectSchema as UserCreateNestedOneWithoutPatientsInputObjectSchema } from './UserCreateNestedOneWithoutPatientsInput.schema';
import { AppointmentCreateNestedManyWithoutPatientInputObjectSchema as AppointmentCreateNestedManyWithoutPatientInputObjectSchema } from './AppointmentCreateNestedManyWithoutPatientInput.schema';
import { AppointmentProcedureCreateNestedManyWithoutPatientInputObjectSchema as AppointmentProcedureCreateNestedManyWithoutPatientInputObjectSchema } from './AppointmentProcedureCreateNestedManyWithoutPatientInput.schema';
import { ClaimCreateNestedManyWithoutPatientInputObjectSchema as ClaimCreateNestedManyWithoutPatientInputObjectSchema } from './ClaimCreateNestedManyWithoutPatientInput.schema';
import { PdfGroupCreateNestedManyWithoutPatientInputObjectSchema as PdfGroupCreateNestedManyWithoutPatientInputObjectSchema } from './PdfGroupCreateNestedManyWithoutPatientInput.schema';
import { PaymentCreateNestedManyWithoutPatientInputObjectSchema as PaymentCreateNestedManyWithoutPatientInputObjectSchema } from './PaymentCreateNestedManyWithoutPatientInput.schema';
import { CommunicationCreateNestedManyWithoutPatientInputObjectSchema as CommunicationCreateNestedManyWithoutPatientInputObjectSchema } from './CommunicationCreateNestedManyWithoutPatientInput.schema';
import { PatientDocumentCreateNestedManyWithoutPatientInputObjectSchema as PatientDocumentCreateNestedManyWithoutPatientInputObjectSchema } from './PatientDocumentCreateNestedManyWithoutPatientInput.schema'
const makeSchema = () => z.object({
firstName: z.string(),
lastName: z.string(),
dateOfBirth: z.coerce.date().optional().nullable(),
gender: z.string(),
phone: z.string(),
email: z.string().optional().nullable(),
address: z.string().optional().nullable(),
city: z.string().optional().nullable(),
zipCode: z.string().optional().nullable(),
insuranceProvider: z.string().optional().nullable(),
insuranceId: z.string().optional().nullable(),
groupNumber: z.string().optional().nullable(),
policyHolder: z.string().optional().nullable(),
allergies: z.string().optional().nullable(),
medicalConditions: z.string().optional().nullable(),
preferredLanguage: z.string().optional().nullable(),
status: PatientStatusSchema.optional(),
createdAt: z.coerce.date().optional(),
updatedAt: z.coerce.date().optional(),
user: z.lazy(() => UserCreateNestedOneWithoutPatientsInputObjectSchema),
appointments: z.lazy(() => AppointmentCreateNestedManyWithoutPatientInputObjectSchema).optional(),
procedures: z.lazy(() => AppointmentProcedureCreateNestedManyWithoutPatientInputObjectSchema).optional(),
claims: z.lazy(() => ClaimCreateNestedManyWithoutPatientInputObjectSchema).optional(),
groups: z.lazy(() => PdfGroupCreateNestedManyWithoutPatientInputObjectSchema).optional(),
payment: z.lazy(() => PaymentCreateNestedManyWithoutPatientInputObjectSchema).optional(),
communications: z.lazy(() => CommunicationCreateNestedManyWithoutPatientInputObjectSchema).optional(),
documents: z.lazy(() => PatientDocumentCreateNestedManyWithoutPatientInputObjectSchema).optional()
}).strict();
export const PatientCreateWithoutConversationInputObjectSchema: z.ZodType<Prisma.PatientCreateWithoutConversationInput> = makeSchema() as unknown as z.ZodType<Prisma.PatientCreateWithoutConversationInput>;
export const PatientCreateWithoutConversationInputObjectZodSchema = makeSchema();

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

@@ -7,7 +7,8 @@ import { AppointmentProcedureCreateNestedManyWithoutPatientInputObjectSchema as
import { ClaimCreateNestedManyWithoutPatientInputObjectSchema as ClaimCreateNestedManyWithoutPatientInputObjectSchema } from './ClaimCreateNestedManyWithoutPatientInput.schema';
import { PdfGroupCreateNestedManyWithoutPatientInputObjectSchema as PdfGroupCreateNestedManyWithoutPatientInputObjectSchema } from './PdfGroupCreateNestedManyWithoutPatientInput.schema';
import { PaymentCreateNestedManyWithoutPatientInputObjectSchema as PaymentCreateNestedManyWithoutPatientInputObjectSchema } from './PaymentCreateNestedManyWithoutPatientInput.schema';
import { CommunicationCreateNestedManyWithoutPatientInputObjectSchema as CommunicationCreateNestedManyWithoutPatientInputObjectSchema } from './CommunicationCreateNestedManyWithoutPatientInput.schema'
import { CommunicationCreateNestedManyWithoutPatientInputObjectSchema as CommunicationCreateNestedManyWithoutPatientInputObjectSchema } from './CommunicationCreateNestedManyWithoutPatientInput.schema';
import { PatientConversationCreateNestedOneWithoutPatientInputObjectSchema as PatientConversationCreateNestedOneWithoutPatientInputObjectSchema } from './PatientConversationCreateNestedOneWithoutPatientInput.schema'
const makeSchema = () => z.object({
firstName: z.string(),
@@ -35,7 +36,8 @@ const makeSchema = () => z.object({
claims: z.lazy(() => ClaimCreateNestedManyWithoutPatientInputObjectSchema).optional(),
groups: z.lazy(() => PdfGroupCreateNestedManyWithoutPatientInputObjectSchema).optional(),
payment: z.lazy(() => PaymentCreateNestedManyWithoutPatientInputObjectSchema).optional(),
communications: z.lazy(() => CommunicationCreateNestedManyWithoutPatientInputObjectSchema).optional()
communications: z.lazy(() => CommunicationCreateNestedManyWithoutPatientInputObjectSchema).optional(),
conversation: z.lazy(() => PatientConversationCreateNestedOneWithoutPatientInputObjectSchema).optional()
}).strict();
export const PatientCreateWithoutDocumentsInputObjectSchema: z.ZodType<Prisma.PatientCreateWithoutDocumentsInput> = makeSchema() as unknown as z.ZodType<Prisma.PatientCreateWithoutDocumentsInput>;
export const PatientCreateWithoutDocumentsInputObjectZodSchema = makeSchema();

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

@@ -7,7 +7,8 @@ import { AppointmentProcedureCreateNestedManyWithoutPatientInputObjectSchema as
import { ClaimCreateNestedManyWithoutPatientInputObjectSchema as ClaimCreateNestedManyWithoutPatientInputObjectSchema } from './ClaimCreateNestedManyWithoutPatientInput.schema';
import { PaymentCreateNestedManyWithoutPatientInputObjectSchema as PaymentCreateNestedManyWithoutPatientInputObjectSchema } from './PaymentCreateNestedManyWithoutPatientInput.schema';
import { CommunicationCreateNestedManyWithoutPatientInputObjectSchema as CommunicationCreateNestedManyWithoutPatientInputObjectSchema } from './CommunicationCreateNestedManyWithoutPatientInput.schema';
import { PatientDocumentCreateNestedManyWithoutPatientInputObjectSchema as PatientDocumentCreateNestedManyWithoutPatientInputObjectSchema } from './PatientDocumentCreateNestedManyWithoutPatientInput.schema'
import { PatientDocumentCreateNestedManyWithoutPatientInputObjectSchema as PatientDocumentCreateNestedManyWithoutPatientInputObjectSchema } from './PatientDocumentCreateNestedManyWithoutPatientInput.schema';
import { PatientConversationCreateNestedOneWithoutPatientInputObjectSchema as PatientConversationCreateNestedOneWithoutPatientInputObjectSchema } from './PatientConversationCreateNestedOneWithoutPatientInput.schema'
const makeSchema = () => z.object({
firstName: z.string(),
@@ -35,7 +36,8 @@ const makeSchema = () => z.object({
claims: z.lazy(() => ClaimCreateNestedManyWithoutPatientInputObjectSchema).optional(),
payment: z.lazy(() => PaymentCreateNestedManyWithoutPatientInputObjectSchema).optional(),
communications: z.lazy(() => CommunicationCreateNestedManyWithoutPatientInputObjectSchema).optional(),
documents: z.lazy(() => PatientDocumentCreateNestedManyWithoutPatientInputObjectSchema).optional()
documents: z.lazy(() => PatientDocumentCreateNestedManyWithoutPatientInputObjectSchema).optional(),
conversation: z.lazy(() => PatientConversationCreateNestedOneWithoutPatientInputObjectSchema).optional()
}).strict();
export const PatientCreateWithoutGroupsInputObjectSchema: z.ZodType<Prisma.PatientCreateWithoutGroupsInput> = makeSchema() as unknown as z.ZodType<Prisma.PatientCreateWithoutGroupsInput>;
export const PatientCreateWithoutGroupsInputObjectZodSchema = makeSchema();

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

@@ -7,7 +7,8 @@ import { AppointmentProcedureCreateNestedManyWithoutPatientInputObjectSchema as
import { ClaimCreateNestedManyWithoutPatientInputObjectSchema as ClaimCreateNestedManyWithoutPatientInputObjectSchema } from './ClaimCreateNestedManyWithoutPatientInput.schema';
import { PdfGroupCreateNestedManyWithoutPatientInputObjectSchema as PdfGroupCreateNestedManyWithoutPatientInputObjectSchema } from './PdfGroupCreateNestedManyWithoutPatientInput.schema';
import { CommunicationCreateNestedManyWithoutPatientInputObjectSchema as CommunicationCreateNestedManyWithoutPatientInputObjectSchema } from './CommunicationCreateNestedManyWithoutPatientInput.schema';
import { PatientDocumentCreateNestedManyWithoutPatientInputObjectSchema as PatientDocumentCreateNestedManyWithoutPatientInputObjectSchema } from './PatientDocumentCreateNestedManyWithoutPatientInput.schema'
import { PatientDocumentCreateNestedManyWithoutPatientInputObjectSchema as PatientDocumentCreateNestedManyWithoutPatientInputObjectSchema } from './PatientDocumentCreateNestedManyWithoutPatientInput.schema';
import { PatientConversationCreateNestedOneWithoutPatientInputObjectSchema as PatientConversationCreateNestedOneWithoutPatientInputObjectSchema } from './PatientConversationCreateNestedOneWithoutPatientInput.schema'
const makeSchema = () => z.object({
firstName: z.string(),
@@ -35,7 +36,8 @@ const makeSchema = () => z.object({
claims: z.lazy(() => ClaimCreateNestedManyWithoutPatientInputObjectSchema).optional(),
groups: z.lazy(() => PdfGroupCreateNestedManyWithoutPatientInputObjectSchema).optional(),
communications: z.lazy(() => CommunicationCreateNestedManyWithoutPatientInputObjectSchema).optional(),
documents: z.lazy(() => PatientDocumentCreateNestedManyWithoutPatientInputObjectSchema).optional()
documents: z.lazy(() => PatientDocumentCreateNestedManyWithoutPatientInputObjectSchema).optional(),
conversation: z.lazy(() => PatientConversationCreateNestedOneWithoutPatientInputObjectSchema).optional()
}).strict();
export const PatientCreateWithoutPaymentInputObjectSchema: z.ZodType<Prisma.PatientCreateWithoutPaymentInput> = makeSchema() as unknown as z.ZodType<Prisma.PatientCreateWithoutPaymentInput>;
export const PatientCreateWithoutPaymentInputObjectZodSchema = makeSchema();

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

@@ -7,7 +7,8 @@ import { ClaimCreateNestedManyWithoutPatientInputObjectSchema as ClaimCreateNest
import { PdfGroupCreateNestedManyWithoutPatientInputObjectSchema as PdfGroupCreateNestedManyWithoutPatientInputObjectSchema } from './PdfGroupCreateNestedManyWithoutPatientInput.schema';
import { PaymentCreateNestedManyWithoutPatientInputObjectSchema as PaymentCreateNestedManyWithoutPatientInputObjectSchema } from './PaymentCreateNestedManyWithoutPatientInput.schema';
import { CommunicationCreateNestedManyWithoutPatientInputObjectSchema as CommunicationCreateNestedManyWithoutPatientInputObjectSchema } from './CommunicationCreateNestedManyWithoutPatientInput.schema';
import { PatientDocumentCreateNestedManyWithoutPatientInputObjectSchema as PatientDocumentCreateNestedManyWithoutPatientInputObjectSchema } from './PatientDocumentCreateNestedManyWithoutPatientInput.schema'
import { PatientDocumentCreateNestedManyWithoutPatientInputObjectSchema as PatientDocumentCreateNestedManyWithoutPatientInputObjectSchema } from './PatientDocumentCreateNestedManyWithoutPatientInput.schema';
import { PatientConversationCreateNestedOneWithoutPatientInputObjectSchema as PatientConversationCreateNestedOneWithoutPatientInputObjectSchema } from './PatientConversationCreateNestedOneWithoutPatientInput.schema'
const makeSchema = () => z.object({
firstName: z.string(),
@@ -35,7 +36,8 @@ const makeSchema = () => z.object({
groups: z.lazy(() => PdfGroupCreateNestedManyWithoutPatientInputObjectSchema).optional(),
payment: z.lazy(() => PaymentCreateNestedManyWithoutPatientInputObjectSchema).optional(),
communications: z.lazy(() => CommunicationCreateNestedManyWithoutPatientInputObjectSchema).optional(),
documents: z.lazy(() => PatientDocumentCreateNestedManyWithoutPatientInputObjectSchema).optional()
documents: z.lazy(() => PatientDocumentCreateNestedManyWithoutPatientInputObjectSchema).optional(),
conversation: z.lazy(() => PatientConversationCreateNestedOneWithoutPatientInputObjectSchema).optional()
}).strict();
export const PatientCreateWithoutProceduresInputObjectSchema: z.ZodType<Prisma.PatientCreateWithoutProceduresInput> = makeSchema() as unknown as z.ZodType<Prisma.PatientCreateWithoutProceduresInput>;
export const PatientCreateWithoutProceduresInputObjectZodSchema = makeSchema();

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

@@ -7,7 +7,8 @@ import { ClaimCreateNestedManyWithoutPatientInputObjectSchema as ClaimCreateNest
import { PdfGroupCreateNestedManyWithoutPatientInputObjectSchema as PdfGroupCreateNestedManyWithoutPatientInputObjectSchema } from './PdfGroupCreateNestedManyWithoutPatientInput.schema';
import { PaymentCreateNestedManyWithoutPatientInputObjectSchema as PaymentCreateNestedManyWithoutPatientInputObjectSchema } from './PaymentCreateNestedManyWithoutPatientInput.schema';
import { CommunicationCreateNestedManyWithoutPatientInputObjectSchema as CommunicationCreateNestedManyWithoutPatientInputObjectSchema } from './CommunicationCreateNestedManyWithoutPatientInput.schema';
import { PatientDocumentCreateNestedManyWithoutPatientInputObjectSchema as PatientDocumentCreateNestedManyWithoutPatientInputObjectSchema } from './PatientDocumentCreateNestedManyWithoutPatientInput.schema'
import { PatientDocumentCreateNestedManyWithoutPatientInputObjectSchema as PatientDocumentCreateNestedManyWithoutPatientInputObjectSchema } from './PatientDocumentCreateNestedManyWithoutPatientInput.schema';
import { PatientConversationCreateNestedOneWithoutPatientInputObjectSchema as PatientConversationCreateNestedOneWithoutPatientInputObjectSchema } from './PatientConversationCreateNestedOneWithoutPatientInput.schema'
const makeSchema = () => z.object({
firstName: z.string(),
@@ -35,7 +36,8 @@ const makeSchema = () => z.object({
groups: z.lazy(() => PdfGroupCreateNestedManyWithoutPatientInputObjectSchema).optional(),
payment: z.lazy(() => PaymentCreateNestedManyWithoutPatientInputObjectSchema).optional(),
communications: z.lazy(() => CommunicationCreateNestedManyWithoutPatientInputObjectSchema).optional(),
documents: z.lazy(() => PatientDocumentCreateNestedManyWithoutPatientInputObjectSchema).optional()
documents: z.lazy(() => PatientDocumentCreateNestedManyWithoutPatientInputObjectSchema).optional(),
conversation: z.lazy(() => PatientConversationCreateNestedOneWithoutPatientInputObjectSchema).optional()
}).strict();
export const PatientCreateWithoutUserInputObjectSchema: z.ZodType<Prisma.PatientCreateWithoutUserInput> = makeSchema() as unknown as z.ZodType<Prisma.PatientCreateWithoutUserInput>;
export const PatientCreateWithoutUserInputObjectZodSchema = makeSchema();

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

@@ -8,6 +8,7 @@ import { PdfGroupFindManySchema as PdfGroupFindManySchema } from '../findManyPdf
import { PaymentFindManySchema as PaymentFindManySchema } from '../findManyPayment.schema';
import { CommunicationFindManySchema as CommunicationFindManySchema } from '../findManyCommunication.schema';
import { PatientDocumentFindManySchema as PatientDocumentFindManySchema } from '../findManyPatientDocument.schema';
import { PatientConversationArgsObjectSchema as PatientConversationArgsObjectSchema } from './PatientConversationArgs.schema';
import { PatientCountOutputTypeArgsObjectSchema as PatientCountOutputTypeArgsObjectSchema } from './PatientCountOutputTypeArgs.schema'
const makeSchema = () => z.object({
@@ -19,6 +20,7 @@ const makeSchema = () => z.object({
payment: z.union([z.boolean(), z.lazy(() => PaymentFindManySchema)]).optional(),
communications: z.union([z.boolean(), z.lazy(() => CommunicationFindManySchema)]).optional(),
documents: z.union([z.boolean(), z.lazy(() => PatientDocumentFindManySchema)]).optional(),
conversation: z.union([z.boolean(), z.lazy(() => PatientConversationArgsObjectSchema)]).optional(),
_count: z.union([z.boolean(), z.lazy(() => PatientCountOutputTypeArgsObjectSchema)]).optional()
}).strict();
export const PatientIncludeObjectSchema: z.ZodType<Prisma.PatientInclude> = makeSchema() as unknown as z.ZodType<Prisma.PatientInclude>;

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

@@ -9,7 +9,8 @@ import { ClaimOrderByRelationAggregateInputObjectSchema as ClaimOrderByRelationA
import { PdfGroupOrderByRelationAggregateInputObjectSchema as PdfGroupOrderByRelationAggregateInputObjectSchema } from './PdfGroupOrderByRelationAggregateInput.schema';
import { PaymentOrderByRelationAggregateInputObjectSchema as PaymentOrderByRelationAggregateInputObjectSchema } from './PaymentOrderByRelationAggregateInput.schema';
import { CommunicationOrderByRelationAggregateInputObjectSchema as CommunicationOrderByRelationAggregateInputObjectSchema } from './CommunicationOrderByRelationAggregateInput.schema';
import { PatientDocumentOrderByRelationAggregateInputObjectSchema as PatientDocumentOrderByRelationAggregateInputObjectSchema } from './PatientDocumentOrderByRelationAggregateInput.schema'
import { PatientDocumentOrderByRelationAggregateInputObjectSchema as PatientDocumentOrderByRelationAggregateInputObjectSchema } from './PatientDocumentOrderByRelationAggregateInput.schema';
import { PatientConversationOrderByWithRelationInputObjectSchema as PatientConversationOrderByWithRelationInputObjectSchema } from './PatientConversationOrderByWithRelationInput.schema'
const makeSchema = () => z.object({
id: SortOrderSchema.optional(),
@@ -40,7 +41,8 @@ const makeSchema = () => z.object({
groups: z.lazy(() => PdfGroupOrderByRelationAggregateInputObjectSchema).optional(),
payment: z.lazy(() => PaymentOrderByRelationAggregateInputObjectSchema).optional(),
communications: z.lazy(() => CommunicationOrderByRelationAggregateInputObjectSchema).optional(),
documents: z.lazy(() => PatientDocumentOrderByRelationAggregateInputObjectSchema).optional()
documents: z.lazy(() => PatientDocumentOrderByRelationAggregateInputObjectSchema).optional(),
conversation: z.lazy(() => PatientConversationOrderByWithRelationInputObjectSchema).optional()
}).strict();
export const PatientOrderByWithRelationInputObjectSchema: z.ZodType<Prisma.PatientOrderByWithRelationInput> = makeSchema() as unknown as z.ZodType<Prisma.PatientOrderByWithRelationInput>;
export const PatientOrderByWithRelationInputObjectZodSchema = makeSchema();

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

@@ -8,6 +8,7 @@ import { PdfGroupFindManySchema as PdfGroupFindManySchema } from '../findManyPdf
import { PaymentFindManySchema as PaymentFindManySchema } from '../findManyPayment.schema';
import { CommunicationFindManySchema as CommunicationFindManySchema } from '../findManyCommunication.schema';
import { PatientDocumentFindManySchema as PatientDocumentFindManySchema } from '../findManyPatientDocument.schema';
import { PatientConversationArgsObjectSchema as PatientConversationArgsObjectSchema } from './PatientConversationArgs.schema';
import { PatientCountOutputTypeArgsObjectSchema as PatientCountOutputTypeArgsObjectSchema } from './PatientCountOutputTypeArgs.schema'
const makeSchema = () => z.object({
@@ -40,6 +41,7 @@ const makeSchema = () => z.object({
payment: z.union([z.boolean(), z.lazy(() => PaymentFindManySchema)]).optional(),
communications: z.union([z.boolean(), z.lazy(() => CommunicationFindManySchema)]).optional(),
documents: z.union([z.boolean(), z.lazy(() => PatientDocumentFindManySchema)]).optional(),
conversation: z.union([z.boolean(), z.lazy(() => PatientConversationArgsObjectSchema)]).optional(),
_count: z.union([z.boolean(), z.lazy(() => PatientCountOutputTypeArgsObjectSchema)]).optional()
}).strict();
export const PatientSelectObjectSchema: z.ZodType<Prisma.PatientSelect> = makeSchema() as unknown as z.ZodType<Prisma.PatientSelect>;

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

@@ -7,7 +7,8 @@ import { ClaimUncheckedCreateNestedManyWithoutPatientInputObjectSchema as ClaimU
import { PdfGroupUncheckedCreateNestedManyWithoutPatientInputObjectSchema as PdfGroupUncheckedCreateNestedManyWithoutPatientInputObjectSchema } from './PdfGroupUncheckedCreateNestedManyWithoutPatientInput.schema';
import { PaymentUncheckedCreateNestedManyWithoutPatientInputObjectSchema as PaymentUncheckedCreateNestedManyWithoutPatientInputObjectSchema } from './PaymentUncheckedCreateNestedManyWithoutPatientInput.schema';
import { CommunicationUncheckedCreateNestedManyWithoutPatientInputObjectSchema as CommunicationUncheckedCreateNestedManyWithoutPatientInputObjectSchema } from './CommunicationUncheckedCreateNestedManyWithoutPatientInput.schema';
import { PatientDocumentUncheckedCreateNestedManyWithoutPatientInputObjectSchema as PatientDocumentUncheckedCreateNestedManyWithoutPatientInputObjectSchema } from './PatientDocumentUncheckedCreateNestedManyWithoutPatientInput.schema'
import { PatientDocumentUncheckedCreateNestedManyWithoutPatientInputObjectSchema as PatientDocumentUncheckedCreateNestedManyWithoutPatientInputObjectSchema } from './PatientDocumentUncheckedCreateNestedManyWithoutPatientInput.schema';
import { PatientConversationUncheckedCreateNestedOneWithoutPatientInputObjectSchema as PatientConversationUncheckedCreateNestedOneWithoutPatientInputObjectSchema } from './PatientConversationUncheckedCreateNestedOneWithoutPatientInput.schema'
const makeSchema = () => z.object({
id: z.number().int().optional(),
@@ -36,7 +37,8 @@ const makeSchema = () => z.object({
groups: z.lazy(() => PdfGroupUncheckedCreateNestedManyWithoutPatientInputObjectSchema).optional(),
payment: z.lazy(() => PaymentUncheckedCreateNestedManyWithoutPatientInputObjectSchema).optional(),
communications: z.lazy(() => CommunicationUncheckedCreateNestedManyWithoutPatientInputObjectSchema).optional(),
documents: z.lazy(() => PatientDocumentUncheckedCreateNestedManyWithoutPatientInputObjectSchema).optional()
documents: z.lazy(() => PatientDocumentUncheckedCreateNestedManyWithoutPatientInputObjectSchema).optional(),
conversation: z.lazy(() => PatientConversationUncheckedCreateNestedOneWithoutPatientInputObjectSchema).optional()
}).strict();
export const PatientUncheckedCreateInputObjectSchema: z.ZodType<Prisma.PatientUncheckedCreateInput> = makeSchema() as unknown as z.ZodType<Prisma.PatientUncheckedCreateInput>;
export const PatientUncheckedCreateInputObjectZodSchema = makeSchema();

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

@@ -6,7 +6,8 @@ import { ClaimUncheckedCreateNestedManyWithoutPatientInputObjectSchema as ClaimU
import { PdfGroupUncheckedCreateNestedManyWithoutPatientInputObjectSchema as PdfGroupUncheckedCreateNestedManyWithoutPatientInputObjectSchema } from './PdfGroupUncheckedCreateNestedManyWithoutPatientInput.schema';
import { PaymentUncheckedCreateNestedManyWithoutPatientInputObjectSchema as PaymentUncheckedCreateNestedManyWithoutPatientInputObjectSchema } from './PaymentUncheckedCreateNestedManyWithoutPatientInput.schema';
import { CommunicationUncheckedCreateNestedManyWithoutPatientInputObjectSchema as CommunicationUncheckedCreateNestedManyWithoutPatientInputObjectSchema } from './CommunicationUncheckedCreateNestedManyWithoutPatientInput.schema';
import { PatientDocumentUncheckedCreateNestedManyWithoutPatientInputObjectSchema as PatientDocumentUncheckedCreateNestedManyWithoutPatientInputObjectSchema } from './PatientDocumentUncheckedCreateNestedManyWithoutPatientInput.schema'
import { PatientDocumentUncheckedCreateNestedManyWithoutPatientInputObjectSchema as PatientDocumentUncheckedCreateNestedManyWithoutPatientInputObjectSchema } from './PatientDocumentUncheckedCreateNestedManyWithoutPatientInput.schema';
import { PatientConversationUncheckedCreateNestedOneWithoutPatientInputObjectSchema as PatientConversationUncheckedCreateNestedOneWithoutPatientInputObjectSchema } from './PatientConversationUncheckedCreateNestedOneWithoutPatientInput.schema'
const makeSchema = () => z.object({
id: z.number().int().optional(),
@@ -35,7 +36,8 @@ const makeSchema = () => z.object({
groups: z.lazy(() => PdfGroupUncheckedCreateNestedManyWithoutPatientInputObjectSchema).optional(),
payment: z.lazy(() => PaymentUncheckedCreateNestedManyWithoutPatientInputObjectSchema).optional(),
communications: z.lazy(() => CommunicationUncheckedCreateNestedManyWithoutPatientInputObjectSchema).optional(),
documents: z.lazy(() => PatientDocumentUncheckedCreateNestedManyWithoutPatientInputObjectSchema).optional()
documents: z.lazy(() => PatientDocumentUncheckedCreateNestedManyWithoutPatientInputObjectSchema).optional(),
conversation: z.lazy(() => PatientConversationUncheckedCreateNestedOneWithoutPatientInputObjectSchema).optional()
}).strict();
export const PatientUncheckedCreateWithoutAppointmentsInputObjectSchema: z.ZodType<Prisma.PatientUncheckedCreateWithoutAppointmentsInput> = makeSchema() as unknown as z.ZodType<Prisma.PatientUncheckedCreateWithoutAppointmentsInput>;
export const PatientUncheckedCreateWithoutAppointmentsInputObjectZodSchema = makeSchema();

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

@@ -6,7 +6,8 @@ import { AppointmentProcedureUncheckedCreateNestedManyWithoutPatientInputObjectS
import { PdfGroupUncheckedCreateNestedManyWithoutPatientInputObjectSchema as PdfGroupUncheckedCreateNestedManyWithoutPatientInputObjectSchema } from './PdfGroupUncheckedCreateNestedManyWithoutPatientInput.schema';
import { PaymentUncheckedCreateNestedManyWithoutPatientInputObjectSchema as PaymentUncheckedCreateNestedManyWithoutPatientInputObjectSchema } from './PaymentUncheckedCreateNestedManyWithoutPatientInput.schema';
import { CommunicationUncheckedCreateNestedManyWithoutPatientInputObjectSchema as CommunicationUncheckedCreateNestedManyWithoutPatientInputObjectSchema } from './CommunicationUncheckedCreateNestedManyWithoutPatientInput.schema';
import { PatientDocumentUncheckedCreateNestedManyWithoutPatientInputObjectSchema as PatientDocumentUncheckedCreateNestedManyWithoutPatientInputObjectSchema } from './PatientDocumentUncheckedCreateNestedManyWithoutPatientInput.schema'
import { PatientDocumentUncheckedCreateNestedManyWithoutPatientInputObjectSchema as PatientDocumentUncheckedCreateNestedManyWithoutPatientInputObjectSchema } from './PatientDocumentUncheckedCreateNestedManyWithoutPatientInput.schema';
import { PatientConversationUncheckedCreateNestedOneWithoutPatientInputObjectSchema as PatientConversationUncheckedCreateNestedOneWithoutPatientInputObjectSchema } from './PatientConversationUncheckedCreateNestedOneWithoutPatientInput.schema'
const makeSchema = () => z.object({
id: z.number().int().optional(),
@@ -35,7 +36,8 @@ const makeSchema = () => z.object({
groups: z.lazy(() => PdfGroupUncheckedCreateNestedManyWithoutPatientInputObjectSchema).optional(),
payment: z.lazy(() => PaymentUncheckedCreateNestedManyWithoutPatientInputObjectSchema).optional(),
communications: z.lazy(() => CommunicationUncheckedCreateNestedManyWithoutPatientInputObjectSchema).optional(),
documents: z.lazy(() => PatientDocumentUncheckedCreateNestedManyWithoutPatientInputObjectSchema).optional()
documents: z.lazy(() => PatientDocumentUncheckedCreateNestedManyWithoutPatientInputObjectSchema).optional(),
conversation: z.lazy(() => PatientConversationUncheckedCreateNestedOneWithoutPatientInputObjectSchema).optional()
}).strict();
export const PatientUncheckedCreateWithoutClaimsInputObjectSchema: z.ZodType<Prisma.PatientUncheckedCreateWithoutClaimsInput> = makeSchema() as unknown as z.ZodType<Prisma.PatientUncheckedCreateWithoutClaimsInput>;
export const PatientUncheckedCreateWithoutClaimsInputObjectZodSchema = makeSchema();

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

@@ -6,7 +6,8 @@ import { AppointmentProcedureUncheckedCreateNestedManyWithoutPatientInputObjectS
import { ClaimUncheckedCreateNestedManyWithoutPatientInputObjectSchema as ClaimUncheckedCreateNestedManyWithoutPatientInputObjectSchema } from './ClaimUncheckedCreateNestedManyWithoutPatientInput.schema';
import { PdfGroupUncheckedCreateNestedManyWithoutPatientInputObjectSchema as PdfGroupUncheckedCreateNestedManyWithoutPatientInputObjectSchema } from './PdfGroupUncheckedCreateNestedManyWithoutPatientInput.schema';
import { PaymentUncheckedCreateNestedManyWithoutPatientInputObjectSchema as PaymentUncheckedCreateNestedManyWithoutPatientInputObjectSchema } from './PaymentUncheckedCreateNestedManyWithoutPatientInput.schema';
import { PatientDocumentUncheckedCreateNestedManyWithoutPatientInputObjectSchema as PatientDocumentUncheckedCreateNestedManyWithoutPatientInputObjectSchema } from './PatientDocumentUncheckedCreateNestedManyWithoutPatientInput.schema'
import { PatientDocumentUncheckedCreateNestedManyWithoutPatientInputObjectSchema as PatientDocumentUncheckedCreateNestedManyWithoutPatientInputObjectSchema } from './PatientDocumentUncheckedCreateNestedManyWithoutPatientInput.schema';
import { PatientConversationUncheckedCreateNestedOneWithoutPatientInputObjectSchema as PatientConversationUncheckedCreateNestedOneWithoutPatientInputObjectSchema } from './PatientConversationUncheckedCreateNestedOneWithoutPatientInput.schema'
const makeSchema = () => z.object({
id: z.number().int().optional(),
@@ -35,7 +36,8 @@ const makeSchema = () => z.object({
claims: z.lazy(() => ClaimUncheckedCreateNestedManyWithoutPatientInputObjectSchema).optional(),
groups: z.lazy(() => PdfGroupUncheckedCreateNestedManyWithoutPatientInputObjectSchema).optional(),
payment: z.lazy(() => PaymentUncheckedCreateNestedManyWithoutPatientInputObjectSchema).optional(),
documents: z.lazy(() => PatientDocumentUncheckedCreateNestedManyWithoutPatientInputObjectSchema).optional()
documents: z.lazy(() => PatientDocumentUncheckedCreateNestedManyWithoutPatientInputObjectSchema).optional(),
conversation: z.lazy(() => PatientConversationUncheckedCreateNestedOneWithoutPatientInputObjectSchema).optional()
}).strict();
export const PatientUncheckedCreateWithoutCommunicationsInputObjectSchema: z.ZodType<Prisma.PatientUncheckedCreateWithoutCommunicationsInput> = makeSchema() as unknown as z.ZodType<Prisma.PatientUncheckedCreateWithoutCommunicationsInput>;
export const PatientUncheckedCreateWithoutCommunicationsInputObjectZodSchema = makeSchema();

43
packages/db/shared/schemas/objects/PatientUncheckedCreateWithoutConversationInput.schema.ts Normal file
View File

@@ -0,0 +1,43 @@
import * as z from 'zod';
import type { Prisma } from '../../../generated/prisma';
import { PatientStatusSchema } from '../enums/PatientStatus.schema';
import { AppointmentUncheckedCreateNestedManyWithoutPatientInputObjectSchema as AppointmentUncheckedCreateNestedManyWithoutPatientInputObjectSchema } from './AppointmentUncheckedCreateNestedManyWithoutPatientInput.schema';
import { AppointmentProcedureUncheckedCreateNestedManyWithoutPatientInputObjectSchema as AppointmentProcedureUncheckedCreateNestedManyWithoutPatientInputObjectSchema } from './AppointmentProcedureUncheckedCreateNestedManyWithoutPatientInput.schema';
import { ClaimUncheckedCreateNestedManyWithoutPatientInputObjectSchema as ClaimUncheckedCreateNestedManyWithoutPatientInputObjectSchema } from './ClaimUncheckedCreateNestedManyWithoutPatientInput.schema';
import { PdfGroupUncheckedCreateNestedManyWithoutPatientInputObjectSchema as PdfGroupUncheckedCreateNestedManyWithoutPatientInputObjectSchema } from './PdfGroupUncheckedCreateNestedManyWithoutPatientInput.schema';
import { PaymentUncheckedCreateNestedManyWithoutPatientInputObjectSchema as PaymentUncheckedCreateNestedManyWithoutPatientInputObjectSchema } from './PaymentUncheckedCreateNestedManyWithoutPatientInput.schema';
import { CommunicationUncheckedCreateNestedManyWithoutPatientInputObjectSchema as CommunicationUncheckedCreateNestedManyWithoutPatientInputObjectSchema } from './CommunicationUncheckedCreateNestedManyWithoutPatientInput.schema';
import { PatientDocumentUncheckedCreateNestedManyWithoutPatientInputObjectSchema as PatientDocumentUncheckedCreateNestedManyWithoutPatientInputObjectSchema } from './PatientDocumentUncheckedCreateNestedManyWithoutPatientInput.schema'
const makeSchema = () => z.object({
id: z.number().int().optional(),
firstName: z.string(),
lastName: z.string(),
dateOfBirth: z.coerce.date().optional().nullable(),
gender: z.string(),
phone: z.string(),
email: z.string().optional().nullable(),
address: z.string().optional().nullable(),
city: z.string().optional().nullable(),
zipCode: z.string().optional().nullable(),
insuranceProvider: z.string().optional().nullable(),
insuranceId: z.string().optional().nullable(),
groupNumber: z.string().optional().nullable(),
policyHolder: z.string().optional().nullable(),
allergies: z.string().optional().nullable(),
medicalConditions: z.string().optional().nullable(),
preferredLanguage: z.string().optional().nullable(),
status: PatientStatusSchema.optional(),
userId: z.number().int(),
createdAt: z.coerce.date().optional(),
updatedAt: z.coerce.date().optional(),
appointments: z.lazy(() => AppointmentUncheckedCreateNestedManyWithoutPatientInputObjectSchema).optional(),
procedures: z.lazy(() => AppointmentProcedureUncheckedCreateNestedManyWithoutPatientInputObjectSchema).optional(),
claims: z.lazy(() => ClaimUncheckedCreateNestedManyWithoutPatientInputObjectSchema).optional(),
groups: z.lazy(() => PdfGroupUncheckedCreateNestedManyWithoutPatientInputObjectSchema).optional(),
payment: z.lazy(() => PaymentUncheckedCreateNestedManyWithoutPatientInputObjectSchema).optional(),
communications: z.lazy(() => CommunicationUncheckedCreateNestedManyWithoutPatientInputObjectSchema).optional(),
documents: z.lazy(() => PatientDocumentUncheckedCreateNestedManyWithoutPatientInputObjectSchema).optional()
}).strict();
export const PatientUncheckedCreateWithoutConversationInputObjectSchema: z.ZodType<Prisma.PatientUncheckedCreateWithoutConversationInput> = makeSchema() as unknown as z.ZodType<Prisma.PatientUncheckedCreateWithoutConversationInput>;
export const PatientUncheckedCreateWithoutConversationInputObjectZodSchema = makeSchema();

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

@@ -6,7 +6,8 @@ import { AppointmentProcedureUncheckedCreateNestedManyWithoutPatientInputObjectS
import { ClaimUncheckedCreateNestedManyWithoutPatientInputObjectSchema as ClaimUncheckedCreateNestedManyWithoutPatientInputObjectSchema } from './ClaimUncheckedCreateNestedManyWithoutPatientInput.schema';
import { PdfGroupUncheckedCreateNestedManyWithoutPatientInputObjectSchema as PdfGroupUncheckedCreateNestedManyWithoutPatientInputObjectSchema } from './PdfGroupUncheckedCreateNestedManyWithoutPatientInput.schema';
import { PaymentUncheckedCreateNestedManyWithoutPatientInputObjectSchema as PaymentUncheckedCreateNestedManyWithoutPatientInputObjectSchema } from './PaymentUncheckedCreateNestedManyWithoutPatientInput.schema';
import { CommunicationUncheckedCreateNestedManyWithoutPatientInputObjectSchema as CommunicationUncheckedCreateNestedManyWithoutPatientInputObjectSchema } from './CommunicationUncheckedCreateNestedManyWithoutPatientInput.schema'
import { CommunicationUncheckedCreateNestedManyWithoutPatientInputObjectSchema as CommunicationUncheckedCreateNestedManyWithoutPatientInputObjectSchema } from './CommunicationUncheckedCreateNestedManyWithoutPatientInput.schema';
import { PatientConversationUncheckedCreateNestedOneWithoutPatientInputObjectSchema as PatientConversationUncheckedCreateNestedOneWithoutPatientInputObjectSchema } from './PatientConversationUncheckedCreateNestedOneWithoutPatientInput.schema'
const makeSchema = () => z.object({
id: z.number().int().optional(),
@@ -35,7 +36,8 @@ const makeSchema = () => z.object({
claims: z.lazy(() => ClaimUncheckedCreateNestedManyWithoutPatientInputObjectSchema).optional(),
groups: z.lazy(() => PdfGroupUncheckedCreateNestedManyWithoutPatientInputObjectSchema).optional(),
payment: z.lazy(() => PaymentUncheckedCreateNestedManyWithoutPatientInputObjectSchema).optional(),
communications: z.lazy(() => CommunicationUncheckedCreateNestedManyWithoutPatientInputObjectSchema).optional()
communications: z.lazy(() => CommunicationUncheckedCreateNestedManyWithoutPatientInputObjectSchema).optional(),
conversation: z.lazy(() => PatientConversationUncheckedCreateNestedOneWithoutPatientInputObjectSchema).optional()
}).strict();
export const PatientUncheckedCreateWithoutDocumentsInputObjectSchema: z.ZodType<Prisma.PatientUncheckedCreateWithoutDocumentsInput> = makeSchema() as unknown as z.ZodType<Prisma.PatientUncheckedCreateWithoutDocumentsInput>;
export const PatientUncheckedCreateWithoutDocumentsInputObjectZodSchema = makeSchema();

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

@@ -6,7 +6,8 @@ import { AppointmentProcedureUncheckedCreateNestedManyWithoutPatientInputObjectS
import { ClaimUncheckedCreateNestedManyWithoutPatientInputObjectSchema as ClaimUncheckedCreateNestedManyWithoutPatientInputObjectSchema } from './ClaimUncheckedCreateNestedManyWithoutPatientInput.schema';
import { PaymentUncheckedCreateNestedManyWithoutPatientInputObjectSchema as PaymentUncheckedCreateNestedManyWithoutPatientInputObjectSchema } from './PaymentUncheckedCreateNestedManyWithoutPatientInput.schema';
import { CommunicationUncheckedCreateNestedManyWithoutPatientInputObjectSchema as CommunicationUncheckedCreateNestedManyWithoutPatientInputObjectSchema } from './CommunicationUncheckedCreateNestedManyWithoutPatientInput.schema';
import { PatientDocumentUncheckedCreateNestedManyWithoutPatientInputObjectSchema as PatientDocumentUncheckedCreateNestedManyWithoutPatientInputObjectSchema } from './PatientDocumentUncheckedCreateNestedManyWithoutPatientInput.schema'
import { PatientDocumentUncheckedCreateNestedManyWithoutPatientInputObjectSchema as PatientDocumentUncheckedCreateNestedManyWithoutPatientInputObjectSchema } from './PatientDocumentUncheckedCreateNestedManyWithoutPatientInput.schema';
import { PatientConversationUncheckedCreateNestedOneWithoutPatientInputObjectSchema as PatientConversationUncheckedCreateNestedOneWithoutPatientInputObjectSchema } from './PatientConversationUncheckedCreateNestedOneWithoutPatientInput.schema'
const makeSchema = () => z.object({
id: z.number().int().optional(),
@@ -35,7 +36,8 @@ const makeSchema = () => z.object({
claims: z.lazy(() => ClaimUncheckedCreateNestedManyWithoutPatientInputObjectSchema).optional(),
payment: z.lazy(() => PaymentUncheckedCreateNestedManyWithoutPatientInputObjectSchema).optional(),
communications: z.lazy(() => CommunicationUncheckedCreateNestedManyWithoutPatientInputObjectSchema).optional(),
documents: z.lazy(() => PatientDocumentUncheckedCreateNestedManyWithoutPatientInputObjectSchema).optional()
documents: z.lazy(() => PatientDocumentUncheckedCreateNestedManyWithoutPatientInputObjectSchema).optional(),
conversation: z.lazy(() => PatientConversationUncheckedCreateNestedOneWithoutPatientInputObjectSchema).optional()
}).strict();
export const PatientUncheckedCreateWithoutGroupsInputObjectSchema: z.ZodType<Prisma.PatientUncheckedCreateWithoutGroupsInput> = makeSchema() as unknown as z.ZodType<Prisma.PatientUncheckedCreateWithoutGroupsInput>;
export const PatientUncheckedCreateWithoutGroupsInputObjectZodSchema = makeSchema();

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

@@ -6,7 +6,8 @@ import { AppointmentProcedureUncheckedCreateNestedManyWithoutPatientInputObjectS
import { ClaimUncheckedCreateNestedManyWithoutPatientInputObjectSchema as ClaimUncheckedCreateNestedManyWithoutPatientInputObjectSchema } from './ClaimUncheckedCreateNestedManyWithoutPatientInput.schema';
import { PdfGroupUncheckedCreateNestedManyWithoutPatientInputObjectSchema as PdfGroupUncheckedCreateNestedManyWithoutPatientInputObjectSchema } from './PdfGroupUncheckedCreateNestedManyWithoutPatientInput.schema';
import { CommunicationUncheckedCreateNestedManyWithoutPatientInputObjectSchema as CommunicationUncheckedCreateNestedManyWithoutPatientInputObjectSchema } from './CommunicationUncheckedCreateNestedManyWithoutPatientInput.schema';
import { PatientDocumentUncheckedCreateNestedManyWithoutPatientInputObjectSchema as PatientDocumentUncheckedCreateNestedManyWithoutPatientInputObjectSchema } from './PatientDocumentUncheckedCreateNestedManyWithoutPatientInput.schema'
import { PatientDocumentUncheckedCreateNestedManyWithoutPatientInputObjectSchema as PatientDocumentUncheckedCreateNestedManyWithoutPatientInputObjectSchema } from './PatientDocumentUncheckedCreateNestedManyWithoutPatientInput.schema';
import { PatientConversationUncheckedCreateNestedOneWithoutPatientInputObjectSchema as PatientConversationUncheckedCreateNestedOneWithoutPatientInputObjectSchema } from './PatientConversationUncheckedCreateNestedOneWithoutPatientInput.schema'
const makeSchema = () => z.object({
id: z.number().int().optional(),
@@ -35,7 +36,8 @@ const makeSchema = () => z.object({
claims: z.lazy(() => ClaimUncheckedCreateNestedManyWithoutPatientInputObjectSchema).optional(),
groups: z.lazy(() => PdfGroupUncheckedCreateNestedManyWithoutPatientInputObjectSchema).optional(),
communications: z.lazy(() => CommunicationUncheckedCreateNestedManyWithoutPatientInputObjectSchema).optional(),
documents: z.lazy(() => PatientDocumentUncheckedCreateNestedManyWithoutPatientInputObjectSchema).optional()
documents: z.lazy(() => PatientDocumentUncheckedCreateNestedManyWithoutPatientInputObjectSchema).optional(),
conversation: z.lazy(() => PatientConversationUncheckedCreateNestedOneWithoutPatientInputObjectSchema).optional()
}).strict();
export const PatientUncheckedCreateWithoutPaymentInputObjectSchema: z.ZodType<Prisma.PatientUncheckedCreateWithoutPaymentInput> = makeSchema() as unknown as z.ZodType<Prisma.PatientUncheckedCreateWithoutPaymentInput>;
export const PatientUncheckedCreateWithoutPaymentInputObjectZodSchema = makeSchema();

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