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

first commit

Browse Source
This commit is contained in:
Vishnu
2025-05-08 21:27:29 +05:30
commit 230d5c89f0
343 changed files with 42391 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -0,0 +1,13 @@
import { z } from 'zod';
import type { Prisma } from '../../../generated/prisma';
const Schema: z.ZodType<Prisma.AppointmentAvgAggregateInputType> = z
.object({
id: z.literal(true).optional(),
patientId: z.literal(true).optional(),
userId: z.literal(true).optional(),
})
.strict();
export const AppointmentAvgAggregateInputObjectSchema = Schema;

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

@@ -0,0 +1,14 @@
import { z } from 'zod';
import { SortOrderSchema } from '../enums/SortOrder.schema';
import type { Prisma } from '../../../generated/prisma';
const Schema: z.ZodType<Prisma.AppointmentAvgOrderByAggregateInput> = z
.object({
id: z.lazy(() => SortOrderSchema).optional(),
patientId: z.lazy(() => SortOrderSchema).optional(),
userId: z.lazy(() => SortOrderSchema).optional(),
})
.strict();
export const AppointmentAvgOrderByAggregateInputObjectSchema = Schema;

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

@@ -0,0 +1,22 @@
import { z } from 'zod';
import type { Prisma } from '../../../generated/prisma';
const Schema: z.ZodType<Prisma.AppointmentCountAggregateInputType> = z
.object({
id: z.literal(true).optional(),
patientId: z.literal(true).optional(),
userId: z.literal(true).optional(),
title: z.literal(true).optional(),
date: z.literal(true).optional(),
startTime: z.literal(true).optional(),
endTime: z.literal(true).optional(),
type: z.literal(true).optional(),
notes: z.literal(true).optional(),
status: z.literal(true).optional(),
createdAt: z.literal(true).optional(),
_all: z.literal(true).optional(),
})
.strict();
export const AppointmentCountAggregateInputObjectSchema = Schema;

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

@@ -0,0 +1,22 @@
import { z } from 'zod';
import { SortOrderSchema } from '../enums/SortOrder.schema';
import type { Prisma } from '../../../generated/prisma';
const Schema: z.ZodType<Prisma.AppointmentCountOrderByAggregateInput> = z
.object({
id: z.lazy(() => SortOrderSchema).optional(),
patientId: z.lazy(() => SortOrderSchema).optional(),
userId: z.lazy(() => SortOrderSchema).optional(),
title: z.lazy(() => SortOrderSchema).optional(),
date: z.lazy(() => SortOrderSchema).optional(),
startTime: z.lazy(() => SortOrderSchema).optional(),
endTime: z.lazy(() => SortOrderSchema).optional(),
type: z.lazy(() => SortOrderSchema).optional(),
notes: z.lazy(() => SortOrderSchema).optional(),
status: z.lazy(() => SortOrderSchema).optional(),
createdAt: z.lazy(() => SortOrderSchema).optional(),
})
.strict();
export const AppointmentCountOrderByAggregateInputObjectSchema = Schema;

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

@@ -0,0 +1,24 @@
import { z } from 'zod';
import { PatientCreateNestedOneWithoutAppointmentsInputObjectSchema } from './PatientCreateNestedOneWithoutAppointmentsInput.schema';
import { UserCreateNestedOneWithoutAppointmentsInputObjectSchema } from './UserCreateNestedOneWithoutAppointmentsInput.schema';
import type { Prisma } from '../../../generated/prisma';
const Schema: z.ZodType<Prisma.AppointmentCreateInput> = z
.object({
title: z.string(),
date: z.coerce.date(),
startTime: z.coerce.date(),
endTime: z.coerce.date(),
type: z.string(),
notes: z.string().optional().nullable(),
status: z.string().optional(),
createdAt: z.coerce.date().optional(),
patient: z.lazy(
() => PatientCreateNestedOneWithoutAppointmentsInputObjectSchema,
),
user: z.lazy(() => UserCreateNestedOneWithoutAppointmentsInputObjectSchema),
})
.strict();
export const AppointmentCreateInputObjectSchema = Schema;

21
packages/db/shared/schemas/objects/AppointmentCreateManyInput.schema.ts Normal file
View File

@@ -0,0 +1,21 @@
import { z } from 'zod';
import type { Prisma } from '../../../generated/prisma';
const Schema: z.ZodType<Prisma.AppointmentCreateManyInput> = z
.object({
id: z.number().optional(),
patientId: z.number(),
userId: z.number(),
title: z.string(),
date: z.coerce.date(),
startTime: z.coerce.date(),
endTime: z.coerce.date(),
type: z.string(),
notes: z.string().optional().nullable(),
status: z.string().optional(),
createdAt: z.coerce.date().optional(),
})
.strict();
export const AppointmentCreateManyInputObjectSchema = Schema;

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

@@ -0,0 +1,20 @@
import { z } from 'zod';
import type { Prisma } from '../../../generated/prisma';
const Schema: z.ZodType<Prisma.AppointmentCreateManyPatientInput> = z
.object({
id: z.number().optional(),
userId: z.number(),
title: z.string(),
date: z.coerce.date(),
startTime: z.coerce.date(),
endTime: z.coerce.date(),
type: z.string(),
notes: z.string().optional().nullable(),
status: z.string().optional(),
createdAt: z.coerce.date().optional(),
})
.strict();
export const AppointmentCreateManyPatientInputObjectSchema = Schema;

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

@@ -0,0 +1,16 @@
import { z } from 'zod';
import { AppointmentCreateManyPatientInputObjectSchema } from './AppointmentCreateManyPatientInput.schema';
import type { Prisma } from '../../../generated/prisma';
const Schema: z.ZodType<Prisma.AppointmentCreateManyPatientInputEnvelope> = z
.object({
data: z.union([
z.lazy(() => AppointmentCreateManyPatientInputObjectSchema),
z.lazy(() => AppointmentCreateManyPatientInputObjectSchema).array(),
]),
skipDuplicates: z.boolean().optional(),
})
.strict();
export const AppointmentCreateManyPatientInputEnvelopeObjectSchema = Schema;

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

@@ -0,0 +1,20 @@
import { z } from 'zod';
import type { Prisma } from '../../../generated/prisma';
const Schema: z.ZodType<Prisma.AppointmentCreateManyUserInput> = z
.object({
id: z.number().optional(),
patientId: z.number(),
title: z.string(),
date: z.coerce.date(),
startTime: z.coerce.date(),
endTime: z.coerce.date(),
type: z.string(),
notes: z.string().optional().nullable(),
status: z.string().optional(),
createdAt: z.coerce.date().optional(),
})
.strict();
export const AppointmentCreateManyUserInputObjectSchema = Schema;

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

@@ -0,0 +1,16 @@
import { z } from 'zod';
import { AppointmentCreateManyUserInputObjectSchema } from './AppointmentCreateManyUserInput.schema';
import type { Prisma } from '../../../generated/prisma';
const Schema: z.ZodType<Prisma.AppointmentCreateManyUserInputEnvelope> = z
.object({
data: z.union([
z.lazy(() => AppointmentCreateManyUserInputObjectSchema),
z.lazy(() => AppointmentCreateManyUserInputObjectSchema).array(),
]),
skipDuplicates: z.boolean().optional(),
})
.strict();
export const AppointmentCreateManyUserInputEnvelopeObjectSchema = Schema;

54
packages/db/shared/schemas/objects/AppointmentCreateNestedManyWithoutPatientInput.schema.ts Normal file
View File

@@ -0,0 +1,54 @@
import { z } from 'zod';
import { AppointmentCreateWithoutPatientInputObjectSchema } from './AppointmentCreateWithoutPatientInput.schema';
import { AppointmentUncheckedCreateWithoutPatientInputObjectSchema } from './AppointmentUncheckedCreateWithoutPatientInput.schema';
import { AppointmentCreateOrConnectWithoutPatientInputObjectSchema } from './AppointmentCreateOrConnectWithoutPatientInput.schema';
import { AppointmentCreateManyPatientInputEnvelopeObjectSchema } from './AppointmentCreateManyPatientInputEnvelope.schema';
import { AppointmentWhereUniqueInputObjectSchema } from './AppointmentWhereUniqueInput.schema';
import type { Prisma } from '../../../generated/prisma';
const Schema: z.ZodType<Prisma.AppointmentCreateNestedManyWithoutPatientInput> =
z
.object({
create: z
.union([
z.lazy(() => AppointmentCreateWithoutPatientInputObjectSchema),
z
.lazy(() => AppointmentCreateWithoutPatientInputObjectSchema)
.array(),
z.lazy(
() => AppointmentUncheckedCreateWithoutPatientInputObjectSchema,
),
z
.lazy(
() => AppointmentUncheckedCreateWithoutPatientInputObjectSchema,
)
.array(),
])
.optional(),
connectOrCreate: z
.union([
z.lazy(
() => AppointmentCreateOrConnectWithoutPatientInputObjectSchema,
),
z
.lazy(
() => AppointmentCreateOrConnectWithoutPatientInputObjectSchema,
)
.array(),
])
.optional(),
createMany: z
.lazy(() => AppointmentCreateManyPatientInputEnvelopeObjectSchema)
.optional(),
connect: z
.union([
z.lazy(() => AppointmentWhereUniqueInputObjectSchema),
z.lazy(() => AppointmentWhereUniqueInputObjectSchema).array(),
])
.optional(),
})
.strict();
export const AppointmentCreateNestedManyWithoutPatientInputObjectSchema =
Schema;

42
packages/db/shared/schemas/objects/AppointmentCreateNestedManyWithoutUserInput.schema.ts Normal file
View File

@@ -0,0 +1,42 @@
import { z } from 'zod';
import { AppointmentCreateWithoutUserInputObjectSchema } from './AppointmentCreateWithoutUserInput.schema';
import { AppointmentUncheckedCreateWithoutUserInputObjectSchema } from './AppointmentUncheckedCreateWithoutUserInput.schema';
import { AppointmentCreateOrConnectWithoutUserInputObjectSchema } from './AppointmentCreateOrConnectWithoutUserInput.schema';
import { AppointmentCreateManyUserInputEnvelopeObjectSchema } from './AppointmentCreateManyUserInputEnvelope.schema';
import { AppointmentWhereUniqueInputObjectSchema } from './AppointmentWhereUniqueInput.schema';
import type { Prisma } from '../../../generated/prisma';
const Schema: z.ZodType<Prisma.AppointmentCreateNestedManyWithoutUserInput> = z
.object({
create: z
.union([
z.lazy(() => AppointmentCreateWithoutUserInputObjectSchema),
z.lazy(() => AppointmentCreateWithoutUserInputObjectSchema).array(),
z.lazy(() => AppointmentUncheckedCreateWithoutUserInputObjectSchema),
z
.lazy(() => AppointmentUncheckedCreateWithoutUserInputObjectSchema)
.array(),
])
.optional(),
connectOrCreate: z
.union([
z.lazy(() => AppointmentCreateOrConnectWithoutUserInputObjectSchema),
z
.lazy(() => AppointmentCreateOrConnectWithoutUserInputObjectSchema)
.array(),
])
.optional(),
createMany: z
.lazy(() => AppointmentCreateManyUserInputEnvelopeObjectSchema)
.optional(),
connect: z
.union([
z.lazy(() => AppointmentWhereUniqueInputObjectSchema),
z.lazy(() => AppointmentWhereUniqueInputObjectSchema).array(),
])
.optional(),
})
.strict();
export const AppointmentCreateNestedManyWithoutUserInputObjectSchema = Schema;

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

@@ -0,0 +1,19 @@
import { z } from 'zod';
import { AppointmentWhereUniqueInputObjectSchema } from './AppointmentWhereUniqueInput.schema';
import { AppointmentCreateWithoutPatientInputObjectSchema } from './AppointmentCreateWithoutPatientInput.schema';
import { AppointmentUncheckedCreateWithoutPatientInputObjectSchema } from './AppointmentUncheckedCreateWithoutPatientInput.schema';
import type { Prisma } from '../../../generated/prisma';
const Schema: z.ZodType<Prisma.AppointmentCreateOrConnectWithoutPatientInput> =
z
.object({
where: z.lazy(() => AppointmentWhereUniqueInputObjectSchema),
create: z.union([
z.lazy(() => AppointmentCreateWithoutPatientInputObjectSchema),
z.lazy(() => AppointmentUncheckedCreateWithoutPatientInputObjectSchema),
]),
})
.strict();
export const AppointmentCreateOrConnectWithoutPatientInputObjectSchema = Schema;

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

@@ -0,0 +1,18 @@
import { z } from 'zod';
import { AppointmentWhereUniqueInputObjectSchema } from './AppointmentWhereUniqueInput.schema';
import { AppointmentCreateWithoutUserInputObjectSchema } from './AppointmentCreateWithoutUserInput.schema';
import { AppointmentUncheckedCreateWithoutUserInputObjectSchema } from './AppointmentUncheckedCreateWithoutUserInput.schema';
import type { Prisma } from '../../../generated/prisma';
const Schema: z.ZodType<Prisma.AppointmentCreateOrConnectWithoutUserInput> = z
.object({
where: z.lazy(() => AppointmentWhereUniqueInputObjectSchema),
create: z.union([
z.lazy(() => AppointmentCreateWithoutUserInputObjectSchema),
z.lazy(() => AppointmentUncheckedCreateWithoutUserInputObjectSchema),
]),
})
.strict();
export const AppointmentCreateOrConnectWithoutUserInputObjectSchema = Schema;

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

@@ -0,0 +1,20 @@
import { z } from 'zod';
import { UserCreateNestedOneWithoutAppointmentsInputObjectSchema } from './UserCreateNestedOneWithoutAppointmentsInput.schema';
import type { Prisma } from '../../../generated/prisma';
const Schema: z.ZodType<Prisma.AppointmentCreateWithoutPatientInput> = z
.object({
title: z.string(),
date: z.coerce.date(),
startTime: z.coerce.date(),
endTime: z.coerce.date(),
type: z.string(),
notes: z.string().optional().nullable(),
status: z.string().optional(),
createdAt: z.coerce.date().optional(),
user: z.lazy(() => UserCreateNestedOneWithoutAppointmentsInputObjectSchema),
})
.strict();
export const AppointmentCreateWithoutPatientInputObjectSchema = Schema;

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

@@ -0,0 +1,22 @@
import { z } from 'zod';
import { PatientCreateNestedOneWithoutAppointmentsInputObjectSchema } from './PatientCreateNestedOneWithoutAppointmentsInput.schema';
import type { Prisma } from '../../../generated/prisma';
const Schema: z.ZodType<Prisma.AppointmentCreateWithoutUserInput> = z
.object({
title: z.string(),
date: z.coerce.date(),
startTime: z.coerce.date(),
endTime: z.coerce.date(),
type: z.string(),
notes: z.string().optional().nullable(),
status: z.string().optional(),
createdAt: z.coerce.date().optional(),
patient: z.lazy(
() => PatientCreateNestedOneWithoutAppointmentsInputObjectSchema,
),
})
.strict();
export const AppointmentCreateWithoutUserInputObjectSchema = Schema;

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

@@ -0,0 +1,14 @@
import { z } from 'zod';
import { AppointmentWhereInputObjectSchema } from './AppointmentWhereInput.schema';
import type { Prisma } from '../../../generated/prisma';
const Schema: z.ZodType<Prisma.AppointmentListRelationFilter> = z
.object({
every: z.lazy(() => AppointmentWhereInputObjectSchema).optional(),
some: z.lazy(() => AppointmentWhereInputObjectSchema).optional(),
none: z.lazy(() => AppointmentWhereInputObjectSchema).optional(),
})
.strict();
export const AppointmentListRelationFilterObjectSchema = Schema;

21
packages/db/shared/schemas/objects/AppointmentMaxAggregateInput.schema.ts Normal file
View File

@@ -0,0 +1,21 @@
import { z } from 'zod';
import type { Prisma } from '../../../generated/prisma';
const Schema: z.ZodType<Prisma.AppointmentMaxAggregateInputType> = z
.object({
id: z.literal(true).optional(),
patientId: z.literal(true).optional(),
userId: z.literal(true).optional(),
title: z.literal(true).optional(),
date: z.literal(true).optional(),
startTime: z.literal(true).optional(),
endTime: z.literal(true).optional(),
type: z.literal(true).optional(),
notes: z.literal(true).optional(),
status: z.literal(true).optional(),
createdAt: z.literal(true).optional(),
})
.strict();
export const AppointmentMaxAggregateInputObjectSchema = Schema;

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

@@ -0,0 +1,22 @@
import { z } from 'zod';
import { SortOrderSchema } from '../enums/SortOrder.schema';
import type { Prisma } from '../../../generated/prisma';
const Schema: z.ZodType<Prisma.AppointmentMaxOrderByAggregateInput> = z
.object({
id: z.lazy(() => SortOrderSchema).optional(),
patientId: z.lazy(() => SortOrderSchema).optional(),
userId: z.lazy(() => SortOrderSchema).optional(),
title: z.lazy(() => SortOrderSchema).optional(),
date: z.lazy(() => SortOrderSchema).optional(),
startTime: z.lazy(() => SortOrderSchema).optional(),
endTime: z.lazy(() => SortOrderSchema).optional(),
type: z.lazy(() => SortOrderSchema).optional(),
notes: z.lazy(() => SortOrderSchema).optional(),
status: z.lazy(() => SortOrderSchema).optional(),
createdAt: z.lazy(() => SortOrderSchema).optional(),
})
.strict();
export const AppointmentMaxOrderByAggregateInputObjectSchema = Schema;

21
packages/db/shared/schemas/objects/AppointmentMinAggregateInput.schema.ts Normal file
View File

@@ -0,0 +1,21 @@
import { z } from 'zod';
import type { Prisma } from '../../../generated/prisma';
const Schema: z.ZodType<Prisma.AppointmentMinAggregateInputType> = z
.object({
id: z.literal(true).optional(),
patientId: z.literal(true).optional(),
userId: z.literal(true).optional(),
title: z.literal(true).optional(),
date: z.literal(true).optional(),
startTime: z.literal(true).optional(),
endTime: z.literal(true).optional(),
type: z.literal(true).optional(),
notes: z.literal(true).optional(),
status: z.literal(true).optional(),
createdAt: z.literal(true).optional(),
})
.strict();
export const AppointmentMinAggregateInputObjectSchema = Schema;

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

@@ -0,0 +1,22 @@
import { z } from 'zod';
import { SortOrderSchema } from '../enums/SortOrder.schema';
import type { Prisma } from '../../../generated/prisma';
const Schema: z.ZodType<Prisma.AppointmentMinOrderByAggregateInput> = z
.object({
id: z.lazy(() => SortOrderSchema).optional(),
patientId: z.lazy(() => SortOrderSchema).optional(),
userId: z.lazy(() => SortOrderSchema).optional(),
title: z.lazy(() => SortOrderSchema).optional(),
date: z.lazy(() => SortOrderSchema).optional(),
startTime: z.lazy(() => SortOrderSchema).optional(),
endTime: z.lazy(() => SortOrderSchema).optional(),
type: z.lazy(() => SortOrderSchema).optional(),
notes: z.lazy(() => SortOrderSchema).optional(),
status: z.lazy(() => SortOrderSchema).optional(),
createdAt: z.lazy(() => SortOrderSchema).optional(),
})
.strict();
export const AppointmentMinOrderByAggregateInputObjectSchema = Schema;

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

@@ -0,0 +1,12 @@
import { z } from 'zod';
import { SortOrderSchema } from '../enums/SortOrder.schema';
import type { Prisma } from '../../../generated/prisma';
const Schema: z.ZodType<Prisma.AppointmentOrderByRelationAggregateInput> = z
.object({
_count: z.lazy(() => SortOrderSchema).optional(),
})
.strict();
export const AppointmentOrderByRelationAggregateInputObjectSchema = Schema;

48
packages/db/shared/schemas/objects/AppointmentOrderByWithAggregationInput.schema.ts Normal file
View File

@@ -0,0 +1,48 @@
import { z } from 'zod';
import { SortOrderSchema } from '../enums/SortOrder.schema';
import { SortOrderInputObjectSchema } from './SortOrderInput.schema';
import { AppointmentCountOrderByAggregateInputObjectSchema } from './AppointmentCountOrderByAggregateInput.schema';
import { AppointmentAvgOrderByAggregateInputObjectSchema } from './AppointmentAvgOrderByAggregateInput.schema';
import { AppointmentMaxOrderByAggregateInputObjectSchema } from './AppointmentMaxOrderByAggregateInput.schema';
import { AppointmentMinOrderByAggregateInputObjectSchema } from './AppointmentMinOrderByAggregateInput.schema';
import { AppointmentSumOrderByAggregateInputObjectSchema } from './AppointmentSumOrderByAggregateInput.schema';
import type { Prisma } from '../../../generated/prisma';
const Schema: z.ZodType<Prisma.AppointmentOrderByWithAggregationInput> = z
.object({
id: z.lazy(() => SortOrderSchema).optional(),
patientId: z.lazy(() => SortOrderSchema).optional(),
userId: z.lazy(() => SortOrderSchema).optional(),
title: z.lazy(() => SortOrderSchema).optional(),
date: z.lazy(() => SortOrderSchema).optional(),
startTime: z.lazy(() => SortOrderSchema).optional(),
endTime: z.lazy(() => SortOrderSchema).optional(),
type: z.lazy(() => SortOrderSchema).optional(),
notes: z
.union([
z.lazy(() => SortOrderSchema),
z.lazy(() => SortOrderInputObjectSchema),
])
.optional(),
status: z.lazy(() => SortOrderSchema).optional(),
createdAt: z.lazy(() => SortOrderSchema).optional(),
_count: z
.lazy(() => AppointmentCountOrderByAggregateInputObjectSchema)
.optional(),
_avg: z
.lazy(() => AppointmentAvgOrderByAggregateInputObjectSchema)
.optional(),
_max: z
.lazy(() => AppointmentMaxOrderByAggregateInputObjectSchema)
.optional(),
_min: z
.lazy(() => AppointmentMinOrderByAggregateInputObjectSchema)
.optional(),
_sum: z
.lazy(() => AppointmentSumOrderByAggregateInputObjectSchema)
.optional(),
})
.strict();
export const AppointmentOrderByWithAggregationInputObjectSchema = Schema;

34
packages/db/shared/schemas/objects/AppointmentOrderByWithRelationInput.schema.ts Normal file
View File

@@ -0,0 +1,34 @@
import { z } from 'zod';
import { SortOrderSchema } from '../enums/SortOrder.schema';
import { SortOrderInputObjectSchema } from './SortOrderInput.schema';
import { PatientOrderByWithRelationInputObjectSchema } from './PatientOrderByWithRelationInput.schema';
import { UserOrderByWithRelationInputObjectSchema } from './UserOrderByWithRelationInput.schema';
import type { Prisma } from '../../../generated/prisma';
const Schema: z.ZodType<Prisma.AppointmentOrderByWithRelationInput> = z
.object({
id: z.lazy(() => SortOrderSchema).optional(),
patientId: z.lazy(() => SortOrderSchema).optional(),
userId: z.lazy(() => SortOrderSchema).optional(),
title: z.lazy(() => SortOrderSchema).optional(),
date: z.lazy(() => SortOrderSchema).optional(),
startTime: z.lazy(() => SortOrderSchema).optional(),
endTime: z.lazy(() => SortOrderSchema).optional(),
type: z.lazy(() => SortOrderSchema).optional(),
notes: z
.union([
z.lazy(() => SortOrderSchema),
z.lazy(() => SortOrderInputObjectSchema),
])
.optional(),
status: z.lazy(() => SortOrderSchema).optional(),
createdAt: z.lazy(() => SortOrderSchema).optional(),
patient: z
.lazy(() => PatientOrderByWithRelationInputObjectSchema)
.optional(),
user: z.lazy(() => UserOrderByWithRelationInputObjectSchema).optional(),
})
.strict();
export const AppointmentOrderByWithRelationInputObjectSchema = Schema;

62
packages/db/shared/schemas/objects/AppointmentScalarWhereInput.schema.ts Normal file
View File

@@ -0,0 +1,62 @@
import { z } from 'zod';
import { IntFilterObjectSchema } from './IntFilter.schema';
import { StringFilterObjectSchema } from './StringFilter.schema';
import { DateTimeFilterObjectSchema } from './DateTimeFilter.schema';
import { StringNullableFilterObjectSchema } from './StringNullableFilter.schema';
import type { Prisma } from '../../../generated/prisma';
const Schema: z.ZodType<Prisma.AppointmentScalarWhereInput> = z
.object({
AND: z
.union([
z.lazy(() => AppointmentScalarWhereInputObjectSchema),
z.lazy(() => AppointmentScalarWhereInputObjectSchema).array(),
])
.optional(),
OR: z
.lazy(() => AppointmentScalarWhereInputObjectSchema)
.array()
.optional(),
NOT: z
.union([
z.lazy(() => AppointmentScalarWhereInputObjectSchema),
z.lazy(() => AppointmentScalarWhereInputObjectSchema).array(),
])
.optional(),
id: z.union([z.lazy(() => IntFilterObjectSchema), z.number()]).optional(),
patientId: z
.union([z.lazy(() => IntFilterObjectSchema), z.number()])
.optional(),
userId: z
.union([z.lazy(() => IntFilterObjectSchema), z.number()])
.optional(),
title: z
.union([z.lazy(() => StringFilterObjectSchema), z.string()])
.optional(),
date: z
.union([z.lazy(() => DateTimeFilterObjectSchema), z.coerce.date()])
.optional(),
startTime: z
.union([z.lazy(() => DateTimeFilterObjectSchema), z.coerce.date()])
.optional(),
endTime: z
.union([z.lazy(() => DateTimeFilterObjectSchema), z.coerce.date()])
.optional(),
type: z
.union([z.lazy(() => StringFilterObjectSchema), z.string()])
.optional(),
notes: z
.union([z.lazy(() => StringNullableFilterObjectSchema), z.string()])
.optional()
.nullable(),
status: z
.union([z.lazy(() => StringFilterObjectSchema), z.string()])
.optional(),
createdAt: z
.union([z.lazy(() => DateTimeFilterObjectSchema), z.coerce.date()])
.optional(),
})
.strict();
export const AppointmentScalarWhereInputObjectSchema = Schema;

83
packages/db/shared/schemas/objects/AppointmentScalarWhereWithAggregatesInput.schema.ts Normal file
View File

@@ -0,0 +1,83 @@
import { z } from 'zod';
import { IntWithAggregatesFilterObjectSchema } from './IntWithAggregatesFilter.schema';
import { StringWithAggregatesFilterObjectSchema } from './StringWithAggregatesFilter.schema';
import { DateTimeWithAggregatesFilterObjectSchema } from './DateTimeWithAggregatesFilter.schema';
import { StringNullableWithAggregatesFilterObjectSchema } from './StringNullableWithAggregatesFilter.schema';
import type { Prisma } from '../../../generated/prisma';
const Schema: z.ZodType<Prisma.AppointmentScalarWhereWithAggregatesInput> = z
.object({
AND: z
.union([
z.lazy(() => AppointmentScalarWhereWithAggregatesInputObjectSchema),
z
.lazy(() => AppointmentScalarWhereWithAggregatesInputObjectSchema)
.array(),
])
.optional(),
OR: z
.lazy(() => AppointmentScalarWhereWithAggregatesInputObjectSchema)
.array()
.optional(),
NOT: z
.union([
z.lazy(() => AppointmentScalarWhereWithAggregatesInputObjectSchema),
z
.lazy(() => AppointmentScalarWhereWithAggregatesInputObjectSchema)
.array(),
])
.optional(),
id: z
.union([z.lazy(() => IntWithAggregatesFilterObjectSchema), z.number()])
.optional(),
patientId: z
.union([z.lazy(() => IntWithAggregatesFilterObjectSchema), z.number()])
.optional(),
userId: z
.union([z.lazy(() => IntWithAggregatesFilterObjectSchema), z.number()])
.optional(),
title: z
.union([z.lazy(() => StringWithAggregatesFilterObjectSchema), z.string()])
.optional(),
date: z
.union([
z.lazy(() => DateTimeWithAggregatesFilterObjectSchema),
z.coerce.date(),
])
.optional(),
startTime: z
.union([
z.lazy(() => DateTimeWithAggregatesFilterObjectSchema),
z.coerce.date(),
])
.optional(),
endTime: z
.union([
z.lazy(() => DateTimeWithAggregatesFilterObjectSchema),
z.coerce.date(),
])
.optional(),
type: z
.union([z.lazy(() => StringWithAggregatesFilterObjectSchema), z.string()])
.optional(),
notes: z
.union([
z.lazy(() => StringNullableWithAggregatesFilterObjectSchema),
z.string(),
])
.optional()
.nullable(),
status: z
.union([z.lazy(() => StringWithAggregatesFilterObjectSchema), z.string()])
.optional(),
createdAt: z
.union([
z.lazy(() => DateTimeWithAggregatesFilterObjectSchema),
z.coerce.date(),
])
.optional(),
})
.strict();
export const AppointmentScalarWhereWithAggregatesInputObjectSchema = Schema;

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

@@ -0,0 +1,13 @@
import { z } from 'zod';
import type { Prisma } from '../../../generated/prisma';
const Schema: z.ZodType<Prisma.AppointmentSumAggregateInputType> = z
.object({
id: z.literal(true).optional(),
patientId: z.literal(true).optional(),
userId: z.literal(true).optional(),
})
.strict();
export const AppointmentSumAggregateInputObjectSchema = Schema;

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

@@ -0,0 +1,14 @@
import { z } from 'zod';
import { SortOrderSchema } from '../enums/SortOrder.schema';
import type { Prisma } from '../../../generated/prisma';
const Schema: z.ZodType<Prisma.AppointmentSumOrderByAggregateInput> = z
.object({
id: z.lazy(() => SortOrderSchema).optional(),
patientId: z.lazy(() => SortOrderSchema).optional(),
userId: z.lazy(() => SortOrderSchema).optional(),
})
.strict();
export const AppointmentSumOrderByAggregateInputObjectSchema = Schema;

21
packages/db/shared/schemas/objects/AppointmentUncheckedCreateInput.schema.ts Normal file
View File

@@ -0,0 +1,21 @@
import { z } from 'zod';
import type { Prisma } from '../../../generated/prisma';
const Schema: z.ZodType<Prisma.AppointmentUncheckedCreateInput> = z
.object({
id: z.number().optional(),
patientId: z.number(),
userId: z.number(),
title: z.string(),
date: z.coerce.date(),
startTime: z.coerce.date(),
endTime: z.coerce.date(),
type: z.string(),
notes: z.string().optional().nullable(),
status: z.string().optional(),
createdAt: z.coerce.date().optional(),
})
.strict();
export const AppointmentUncheckedCreateInputObjectSchema = Schema;

54
packages/db/shared/schemas/objects/AppointmentUncheckedCreateNestedManyWithoutPatientInput.schema.ts Normal file
View File

@@ -0,0 +1,54 @@
import { z } from 'zod';
import { AppointmentCreateWithoutPatientInputObjectSchema } from './AppointmentCreateWithoutPatientInput.schema';
import { AppointmentUncheckedCreateWithoutPatientInputObjectSchema } from './AppointmentUncheckedCreateWithoutPatientInput.schema';
import { AppointmentCreateOrConnectWithoutPatientInputObjectSchema } from './AppointmentCreateOrConnectWithoutPatientInput.schema';
import { AppointmentCreateManyPatientInputEnvelopeObjectSchema } from './AppointmentCreateManyPatientInputEnvelope.schema';
import { AppointmentWhereUniqueInputObjectSchema } from './AppointmentWhereUniqueInput.schema';
import type { Prisma } from '../../../generated/prisma';
const Schema: z.ZodType<Prisma.AppointmentUncheckedCreateNestedManyWithoutPatientInput> =
z
.object({
create: z
.union([
z.lazy(() => AppointmentCreateWithoutPatientInputObjectSchema),
z
.lazy(() => AppointmentCreateWithoutPatientInputObjectSchema)
.array(),
z.lazy(
() => AppointmentUncheckedCreateWithoutPatientInputObjectSchema,
),
z
.lazy(
() => AppointmentUncheckedCreateWithoutPatientInputObjectSchema,
)
.array(),
])
.optional(),
connectOrCreate: z
.union([
z.lazy(
() => AppointmentCreateOrConnectWithoutPatientInputObjectSchema,
),
z
.lazy(
() => AppointmentCreateOrConnectWithoutPatientInputObjectSchema,
)
.array(),
])
.optional(),
createMany: z
.lazy(() => AppointmentCreateManyPatientInputEnvelopeObjectSchema)
.optional(),
connect: z
.union([
z.lazy(() => AppointmentWhereUniqueInputObjectSchema),
z.lazy(() => AppointmentWhereUniqueInputObjectSchema).array(),
])
.optional(),
})
.strict();
export const AppointmentUncheckedCreateNestedManyWithoutPatientInputObjectSchema =
Schema;

44
packages/db/shared/schemas/objects/AppointmentUncheckedCreateNestedManyWithoutUserInput.schema.ts Normal file
View File

@@ -0,0 +1,44 @@
import { z } from 'zod';
import { AppointmentCreateWithoutUserInputObjectSchema } from './AppointmentCreateWithoutUserInput.schema';
import { AppointmentUncheckedCreateWithoutUserInputObjectSchema } from './AppointmentUncheckedCreateWithoutUserInput.schema';
import { AppointmentCreateOrConnectWithoutUserInputObjectSchema } from './AppointmentCreateOrConnectWithoutUserInput.schema';
import { AppointmentCreateManyUserInputEnvelopeObjectSchema } from './AppointmentCreateManyUserInputEnvelope.schema';
import { AppointmentWhereUniqueInputObjectSchema } from './AppointmentWhereUniqueInput.schema';
import type { Prisma } from '../../../generated/prisma';
const Schema: z.ZodType<Prisma.AppointmentUncheckedCreateNestedManyWithoutUserInput> =
z
.object({
create: z
.union([
z.lazy(() => AppointmentCreateWithoutUserInputObjectSchema),
z.lazy(() => AppointmentCreateWithoutUserInputObjectSchema).array(),
z.lazy(() => AppointmentUncheckedCreateWithoutUserInputObjectSchema),
z
.lazy(() => AppointmentUncheckedCreateWithoutUserInputObjectSchema)
.array(),
])
.optional(),
connectOrCreate: z
.union([
z.lazy(() => AppointmentCreateOrConnectWithoutUserInputObjectSchema),
z
.lazy(() => AppointmentCreateOrConnectWithoutUserInputObjectSchema)
.array(),
])
.optional(),
createMany: z
.lazy(() => AppointmentCreateManyUserInputEnvelopeObjectSchema)
.optional(),
connect: z
.union([
z.lazy(() => AppointmentWhereUniqueInputObjectSchema),
z.lazy(() => AppointmentWhereUniqueInputObjectSchema).array(),
])
.optional(),
})
.strict();
export const AppointmentUncheckedCreateNestedManyWithoutUserInputObjectSchema =
Schema;

21
packages/db/shared/schemas/objects/AppointmentUncheckedCreateWithoutPatientInput.schema.ts Normal file
View File

@@ -0,0 +1,21 @@
import { z } from 'zod';
import type { Prisma } from '../../../generated/prisma';
const Schema: z.ZodType<Prisma.AppointmentUncheckedCreateWithoutPatientInput> =
z
.object({
id: z.number().optional(),
userId: z.number(),
title: z.string(),
date: z.coerce.date(),
startTime: z.coerce.date(),
endTime: z.coerce.date(),
type: z.string(),
notes: z.string().optional().nullable(),
status: z.string().optional(),
createdAt: z.coerce.date().optional(),
})
.strict();
export const AppointmentUncheckedCreateWithoutPatientInputObjectSchema = Schema;

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

@@ -0,0 +1,20 @@
import { z } from 'zod';
import type { Prisma } from '../../../generated/prisma';
const Schema: z.ZodType<Prisma.AppointmentUncheckedCreateWithoutUserInput> = z
.object({
id: z.number().optional(),
patientId: z.number(),
title: z.string(),
date: z.coerce.date(),
startTime: z.coerce.date(),
endTime: z.coerce.date(),
type: z.string(),
notes: z.string().optional().nullable(),
status: z.string().optional(),
createdAt: z.coerce.date().optional(),
})
.strict();
export const AppointmentUncheckedCreateWithoutUserInputObjectSchema = Schema;

81
packages/db/shared/schemas/objects/AppointmentUncheckedUpdateInput.schema.ts Normal file
View File

@@ -0,0 +1,81 @@
import { z } from 'zod';
import { IntFieldUpdateOperationsInputObjectSchema } from './IntFieldUpdateOperationsInput.schema';
import { StringFieldUpdateOperationsInputObjectSchema } from './StringFieldUpdateOperationsInput.schema';
import { DateTimeFieldUpdateOperationsInputObjectSchema } from './DateTimeFieldUpdateOperationsInput.schema';
import { NullableStringFieldUpdateOperationsInputObjectSchema } from './NullableStringFieldUpdateOperationsInput.schema';
import type { Prisma } from '../../../generated/prisma';
const Schema: z.ZodType<Prisma.AppointmentUncheckedUpdateInput> = z
.object({
id: z
.union([
z.number(),
z.lazy(() => IntFieldUpdateOperationsInputObjectSchema),
])
.optional(),
patientId: z
.union([
z.number(),
z.lazy(() => IntFieldUpdateOperationsInputObjectSchema),
])
.optional(),
userId: z
.union([
z.number(),
z.lazy(() => IntFieldUpdateOperationsInputObjectSchema),
])
.optional(),
title: z
.union([
z.string(),
z.lazy(() => StringFieldUpdateOperationsInputObjectSchema),
])
.optional(),
date: z
.union([
z.coerce.date(),
z.lazy(() => DateTimeFieldUpdateOperationsInputObjectSchema),
])
.optional(),
startTime: z
.union([
z.coerce.date(),
z.lazy(() => DateTimeFieldUpdateOperationsInputObjectSchema),
])
.optional(),
endTime: z
.union([
z.coerce.date(),
z.lazy(() => DateTimeFieldUpdateOperationsInputObjectSchema),
])
.optional(),
type: z
.union([
z.string(),
z.lazy(() => StringFieldUpdateOperationsInputObjectSchema),
])
.optional(),
notes: z
.union([
z.string(),
z.lazy(() => NullableStringFieldUpdateOperationsInputObjectSchema),
])
.optional()
.nullable(),
status: z
.union([
z.string(),
z.lazy(() => StringFieldUpdateOperationsInputObjectSchema),
])
.optional(),
createdAt: z
.union([
z.coerce.date(),
z.lazy(() => DateTimeFieldUpdateOperationsInputObjectSchema),
])
.optional(),
})
.strict();
export const AppointmentUncheckedUpdateInputObjectSchema = Schema;

81
packages/db/shared/schemas/objects/AppointmentUncheckedUpdateManyInput.schema.ts Normal file
View File

@@ -0,0 +1,81 @@
import { z } from 'zod';
import { IntFieldUpdateOperationsInputObjectSchema } from './IntFieldUpdateOperationsInput.schema';
import { StringFieldUpdateOperationsInputObjectSchema } from './StringFieldUpdateOperationsInput.schema';
import { DateTimeFieldUpdateOperationsInputObjectSchema } from './DateTimeFieldUpdateOperationsInput.schema';
import { NullableStringFieldUpdateOperationsInputObjectSchema } from './NullableStringFieldUpdateOperationsInput.schema';
import type { Prisma } from '../../../generated/prisma';
const Schema: z.ZodType<Prisma.AppointmentUncheckedUpdateManyInput> = z
.object({
id: z
.union([
z.number(),
z.lazy(() => IntFieldUpdateOperationsInputObjectSchema),
])
.optional(),
patientId: z
.union([
z.number(),
z.lazy(() => IntFieldUpdateOperationsInputObjectSchema),
])
.optional(),
userId: z
.union([
z.number(),
z.lazy(() => IntFieldUpdateOperationsInputObjectSchema),
])
.optional(),
title: z
.union([
z.string(),
z.lazy(() => StringFieldUpdateOperationsInputObjectSchema),
])
.optional(),
date: z
.union([
z.coerce.date(),
z.lazy(() => DateTimeFieldUpdateOperationsInputObjectSchema),
])
.optional(),
startTime: z
.union([
z.coerce.date(),
z.lazy(() => DateTimeFieldUpdateOperationsInputObjectSchema),
])
.optional(),
endTime: z
.union([
z.coerce.date(),
z.lazy(() => DateTimeFieldUpdateOperationsInputObjectSchema),
])
.optional(),
type: z
.union([
z.string(),
z.lazy(() => StringFieldUpdateOperationsInputObjectSchema),
])
.optional(),
notes: z
.union([
z.string(),
z.lazy(() => NullableStringFieldUpdateOperationsInputObjectSchema),
])
.optional()
.nullable(),
status: z
.union([
z.string(),
z.lazy(() => StringFieldUpdateOperationsInputObjectSchema),
])
.optional(),
createdAt: z
.union([
z.coerce.date(),
z.lazy(() => DateTimeFieldUpdateOperationsInputObjectSchema),
])
.optional(),
})
.strict();
export const AppointmentUncheckedUpdateManyInputObjectSchema = Schema;

77
packages/db/shared/schemas/objects/AppointmentUncheckedUpdateManyWithoutAppointmentsInput.schema.ts Normal file
View File

@@ -0,0 +1,77 @@
import { z } from 'zod';
import { IntFieldUpdateOperationsInputObjectSchema } from './IntFieldUpdateOperationsInput.schema';
import { StringFieldUpdateOperationsInputObjectSchema } from './StringFieldUpdateOperationsInput.schema';
import { DateTimeFieldUpdateOperationsInputObjectSchema } from './DateTimeFieldUpdateOperationsInput.schema';
import { NullableStringFieldUpdateOperationsInputObjectSchema } from './NullableStringFieldUpdateOperationsInput.schema';
import type { Prisma } from '../../../generated/prisma';
const Schema: z.ZodType<Prisma.AppointmentUncheckedUpdateManyWithoutAppointmentsInput> =
z
.object({
id: z
.union([
z.number(),
z.lazy(() => IntFieldUpdateOperationsInputObjectSchema),
])
.optional(),
patientId: z
.union([
z.number(),
z.lazy(() => IntFieldUpdateOperationsInputObjectSchema),
])
.optional(),
title: z
.union([
z.string(),
z.lazy(() => StringFieldUpdateOperationsInputObjectSchema),
])
.optional(),
date: z
.union([
z.coerce.date(),
z.lazy(() => DateTimeFieldUpdateOperationsInputObjectSchema),
])
.optional(),
startTime: z
.union([
z.coerce.date(),
z.lazy(() => DateTimeFieldUpdateOperationsInputObjectSchema),
])
.optional(),
endTime: z
.union([
z.coerce.date(),
z.lazy(() => DateTimeFieldUpdateOperationsInputObjectSchema),
])
.optional(),
type: z
.union([
z.string(),
z.lazy(() => StringFieldUpdateOperationsInputObjectSchema),
])
.optional(),
notes: z
.union([
z.string(),
z.lazy(() => NullableStringFieldUpdateOperationsInputObjectSchema),
])
.optional()
.nullable(),
status: z
.union([
z.string(),
z.lazy(() => StringFieldUpdateOperationsInputObjectSchema),
])
.optional(),
createdAt: z
.union([
z.coerce.date(),
z.lazy(() => DateTimeFieldUpdateOperationsInputObjectSchema),
])
.optional(),
})
.strict();
export const AppointmentUncheckedUpdateManyWithoutAppointmentsInputObjectSchema =
Schema;

123
packages/db/shared/schemas/objects/AppointmentUncheckedUpdateManyWithoutPatientNestedInput.schema.ts Normal file
View File

@@ -0,0 +1,123 @@
import { z } from 'zod';
import { AppointmentCreateWithoutPatientInputObjectSchema } from './AppointmentCreateWithoutPatientInput.schema';
import { AppointmentUncheckedCreateWithoutPatientInputObjectSchema } from './AppointmentUncheckedCreateWithoutPatientInput.schema';
import { AppointmentCreateOrConnectWithoutPatientInputObjectSchema } from './AppointmentCreateOrConnectWithoutPatientInput.schema';
import { AppointmentUpsertWithWhereUniqueWithoutPatientInputObjectSchema } from './AppointmentUpsertWithWhereUniqueWithoutPatientInput.schema';
import { AppointmentCreateManyPatientInputEnvelopeObjectSchema } from './AppointmentCreateManyPatientInputEnvelope.schema';
import { AppointmentWhereUniqueInputObjectSchema } from './AppointmentWhereUniqueInput.schema';
import { AppointmentUpdateWithWhereUniqueWithoutPatientInputObjectSchema } from './AppointmentUpdateWithWhereUniqueWithoutPatientInput.schema';
import { AppointmentUpdateManyWithWhereWithoutPatientInputObjectSchema } from './AppointmentUpdateManyWithWhereWithoutPatientInput.schema';
import { AppointmentScalarWhereInputObjectSchema } from './AppointmentScalarWhereInput.schema';
import type { Prisma } from '../../../generated/prisma';
const Schema: z.ZodType<Prisma.AppointmentUncheckedUpdateManyWithoutPatientNestedInput> =
z
.object({
create: z
.union([
z.lazy(() => AppointmentCreateWithoutPatientInputObjectSchema),
z
.lazy(() => AppointmentCreateWithoutPatientInputObjectSchema)
.array(),
z.lazy(
() => AppointmentUncheckedCreateWithoutPatientInputObjectSchema,
),
z
.lazy(
() => AppointmentUncheckedCreateWithoutPatientInputObjectSchema,
)
.array(),
])
.optional(),
connectOrCreate: z
.union([
z.lazy(
() => AppointmentCreateOrConnectWithoutPatientInputObjectSchema,
),
z
.lazy(
() => AppointmentCreateOrConnectWithoutPatientInputObjectSchema,
)
.array(),
])
.optional(),
upsert: z
.union([
z.lazy(
() =>
AppointmentUpsertWithWhereUniqueWithoutPatientInputObjectSchema,
),
z
.lazy(
() =>
AppointmentUpsertWithWhereUniqueWithoutPatientInputObjectSchema,
)
.array(),
])
.optional(),
createMany: z
.lazy(() => AppointmentCreateManyPatientInputEnvelopeObjectSchema)
.optional(),
set: z
.union([
z.lazy(() => AppointmentWhereUniqueInputObjectSchema),
z.lazy(() => AppointmentWhereUniqueInputObjectSchema).array(),
])
.optional(),
disconnect: z
.union([
z.lazy(() => AppointmentWhereUniqueInputObjectSchema),
z.lazy(() => AppointmentWhereUniqueInputObjectSchema).array(),
])
.optional(),
delete: z
.union([
z.lazy(() => AppointmentWhereUniqueInputObjectSchema),
z.lazy(() => AppointmentWhereUniqueInputObjectSchema).array(),
])
.optional(),
connect: z
.union([
z.lazy(() => AppointmentWhereUniqueInputObjectSchema),
z.lazy(() => AppointmentWhereUniqueInputObjectSchema).array(),
])
.optional(),
update: z
.union([
z.lazy(
() =>
AppointmentUpdateWithWhereUniqueWithoutPatientInputObjectSchema,
),
z
.lazy(
() =>
AppointmentUpdateWithWhereUniqueWithoutPatientInputObjectSchema,
)
.array(),
])
.optional(),
updateMany: z
.union([
z.lazy(
() => AppointmentUpdateManyWithWhereWithoutPatientInputObjectSchema,
),
z
.lazy(
() =>
AppointmentUpdateManyWithWhereWithoutPatientInputObjectSchema,
)
.array(),
])
.optional(),
deleteMany: z
.union([
z.lazy(() => AppointmentScalarWhereInputObjectSchema),
z.lazy(() => AppointmentScalarWhereInputObjectSchema).array(),
])
.optional(),
})
.strict();
export const AppointmentUncheckedUpdateManyWithoutPatientNestedInputObjectSchema =
Schema;

110
packages/db/shared/schemas/objects/AppointmentUncheckedUpdateManyWithoutUserNestedInput.schema.ts Normal file
View File

@@ -0,0 +1,110 @@
import { z } from 'zod';
import { AppointmentCreateWithoutUserInputObjectSchema } from './AppointmentCreateWithoutUserInput.schema';
import { AppointmentUncheckedCreateWithoutUserInputObjectSchema } from './AppointmentUncheckedCreateWithoutUserInput.schema';
import { AppointmentCreateOrConnectWithoutUserInputObjectSchema } from './AppointmentCreateOrConnectWithoutUserInput.schema';
import { AppointmentUpsertWithWhereUniqueWithoutUserInputObjectSchema } from './AppointmentUpsertWithWhereUniqueWithoutUserInput.schema';
import { AppointmentCreateManyUserInputEnvelopeObjectSchema } from './AppointmentCreateManyUserInputEnvelope.schema';
import { AppointmentWhereUniqueInputObjectSchema } from './AppointmentWhereUniqueInput.schema';
import { AppointmentUpdateWithWhereUniqueWithoutUserInputObjectSchema } from './AppointmentUpdateWithWhereUniqueWithoutUserInput.schema';
import { AppointmentUpdateManyWithWhereWithoutUserInputObjectSchema } from './AppointmentUpdateManyWithWhereWithoutUserInput.schema';
import { AppointmentScalarWhereInputObjectSchema } from './AppointmentScalarWhereInput.schema';
import type { Prisma } from '../../../generated/prisma';
const Schema: z.ZodType<Prisma.AppointmentUncheckedUpdateManyWithoutUserNestedInput> =
z
.object({
create: z
.union([
z.lazy(() => AppointmentCreateWithoutUserInputObjectSchema),
z.lazy(() => AppointmentCreateWithoutUserInputObjectSchema).array(),
z.lazy(() => AppointmentUncheckedCreateWithoutUserInputObjectSchema),
z
.lazy(() => AppointmentUncheckedCreateWithoutUserInputObjectSchema)
.array(),
])
.optional(),
connectOrCreate: z
.union([
z.lazy(() => AppointmentCreateOrConnectWithoutUserInputObjectSchema),
z
.lazy(() => AppointmentCreateOrConnectWithoutUserInputObjectSchema)
.array(),
])
.optional(),
upsert: z
.union([
z.lazy(
() => AppointmentUpsertWithWhereUniqueWithoutUserInputObjectSchema,
),
z
.lazy(
() =>
AppointmentUpsertWithWhereUniqueWithoutUserInputObjectSchema,
)
.array(),
])
.optional(),
createMany: z
.lazy(() => AppointmentCreateManyUserInputEnvelopeObjectSchema)
.optional(),
set: z
.union([
z.lazy(() => AppointmentWhereUniqueInputObjectSchema),
z.lazy(() => AppointmentWhereUniqueInputObjectSchema).array(),
])
.optional(),
disconnect: z
.union([
z.lazy(() => AppointmentWhereUniqueInputObjectSchema),
z.lazy(() => AppointmentWhereUniqueInputObjectSchema).array(),
])
.optional(),
delete: z
.union([
z.lazy(() => AppointmentWhereUniqueInputObjectSchema),
z.lazy(() => AppointmentWhereUniqueInputObjectSchema).array(),
])
.optional(),
connect: z
.union([
z.lazy(() => AppointmentWhereUniqueInputObjectSchema),
z.lazy(() => AppointmentWhereUniqueInputObjectSchema).array(),
])
.optional(),
update: z
.union([
z.lazy(
() => AppointmentUpdateWithWhereUniqueWithoutUserInputObjectSchema,
),
z
.lazy(
() =>
AppointmentUpdateWithWhereUniqueWithoutUserInputObjectSchema,
)
.array(),
])
.optional(),
updateMany: z
.union([
z.lazy(
() => AppointmentUpdateManyWithWhereWithoutUserInputObjectSchema,
),
z
.lazy(
() => AppointmentUpdateManyWithWhereWithoutUserInputObjectSchema,
)
.array(),
])
.optional(),
deleteMany: z
.union([
z.lazy(() => AppointmentScalarWhereInputObjectSchema),
z.lazy(() => AppointmentScalarWhereInputObjectSchema).array(),
])
.optional(),
})
.strict();
export const AppointmentUncheckedUpdateManyWithoutUserNestedInputObjectSchema =
Schema;

76
packages/db/shared/schemas/objects/AppointmentUncheckedUpdateWithoutPatientInput.schema.ts Normal file
View File

@@ -0,0 +1,76 @@
import { z } from 'zod';
import { IntFieldUpdateOperationsInputObjectSchema } from './IntFieldUpdateOperationsInput.schema';
import { StringFieldUpdateOperationsInputObjectSchema } from './StringFieldUpdateOperationsInput.schema';
import { DateTimeFieldUpdateOperationsInputObjectSchema } from './DateTimeFieldUpdateOperationsInput.schema';
import { NullableStringFieldUpdateOperationsInputObjectSchema } from './NullableStringFieldUpdateOperationsInput.schema';
import type { Prisma } from '../../../generated/prisma';
const Schema: z.ZodType<Prisma.AppointmentUncheckedUpdateWithoutPatientInput> =
z
.object({
id: z
.union([
z.number(),
z.lazy(() => IntFieldUpdateOperationsInputObjectSchema),
])
.optional(),
userId: z
.union([
z.number(),
z.lazy(() => IntFieldUpdateOperationsInputObjectSchema),
])
.optional(),
title: z
.union([
z.string(),
z.lazy(() => StringFieldUpdateOperationsInputObjectSchema),
])
.optional(),
date: z
.union([
z.coerce.date(),
z.lazy(() => DateTimeFieldUpdateOperationsInputObjectSchema),
])
.optional(),
startTime: z
.union([
z.coerce.date(),
z.lazy(() => DateTimeFieldUpdateOperationsInputObjectSchema),
])
.optional(),
endTime: z
.union([
z.coerce.date(),
z.lazy(() => DateTimeFieldUpdateOperationsInputObjectSchema),
])
.optional(),
type: z
.union([
z.string(),
z.lazy(() => StringFieldUpdateOperationsInputObjectSchema),
])
.optional(),
notes: z
.union([
z.string(),
z.lazy(() => NullableStringFieldUpdateOperationsInputObjectSchema),
])
.optional()
.nullable(),
status: z
.union([
z.string(),
z.lazy(() => StringFieldUpdateOperationsInputObjectSchema),
])
.optional(),
createdAt: z
.union([
z.coerce.date(),
z.lazy(() => DateTimeFieldUpdateOperationsInputObjectSchema),
])
.optional(),
})
.strict();
export const AppointmentUncheckedUpdateWithoutPatientInputObjectSchema = Schema;

75
packages/db/shared/schemas/objects/AppointmentUncheckedUpdateWithoutUserInput.schema.ts Normal file
View File

@@ -0,0 +1,75 @@
import { z } from 'zod';
import { IntFieldUpdateOperationsInputObjectSchema } from './IntFieldUpdateOperationsInput.schema';
import { StringFieldUpdateOperationsInputObjectSchema } from './StringFieldUpdateOperationsInput.schema';
import { DateTimeFieldUpdateOperationsInputObjectSchema } from './DateTimeFieldUpdateOperationsInput.schema';
import { NullableStringFieldUpdateOperationsInputObjectSchema } from './NullableStringFieldUpdateOperationsInput.schema';
import type { Prisma } from '../../../generated/prisma';
const Schema: z.ZodType<Prisma.AppointmentUncheckedUpdateWithoutUserInput> = z
.object({
id: z
.union([
z.number(),
z.lazy(() => IntFieldUpdateOperationsInputObjectSchema),
])
.optional(),
patientId: z
.union([
z.number(),
z.lazy(() => IntFieldUpdateOperationsInputObjectSchema),
])
.optional(),
title: z
.union([
z.string(),
z.lazy(() => StringFieldUpdateOperationsInputObjectSchema),
])
.optional(),
date: z
.union([
z.coerce.date(),
z.lazy(() => DateTimeFieldUpdateOperationsInputObjectSchema),
])
.optional(),
startTime: z
.union([
z.coerce.date(),
z.lazy(() => DateTimeFieldUpdateOperationsInputObjectSchema),
])
.optional(),
endTime: z
.union([
z.coerce.date(),
z.lazy(() => DateTimeFieldUpdateOperationsInputObjectSchema),
])
.optional(),
type: z
.union([
z.string(),
z.lazy(() => StringFieldUpdateOperationsInputObjectSchema),
])
.optional(),
notes: z
.union([
z.string(),
z.lazy(() => NullableStringFieldUpdateOperationsInputObjectSchema),
])
.optional()
.nullable(),
status: z
.union([
z.string(),
z.lazy(() => StringFieldUpdateOperationsInputObjectSchema),
])
.optional(),
createdAt: z
.union([
z.coerce.date(),
z.lazy(() => DateTimeFieldUpdateOperationsInputObjectSchema),
])
.optional(),
})
.strict();
export const AppointmentUncheckedUpdateWithoutUserInputObjectSchema = Schema;

75
packages/db/shared/schemas/objects/AppointmentUpdateInput.schema.ts Normal file
View File

@@ -0,0 +1,75 @@
import { z } from 'zod';
import { StringFieldUpdateOperationsInputObjectSchema } from './StringFieldUpdateOperationsInput.schema';
import { DateTimeFieldUpdateOperationsInputObjectSchema } from './DateTimeFieldUpdateOperationsInput.schema';
import { NullableStringFieldUpdateOperationsInputObjectSchema } from './NullableStringFieldUpdateOperationsInput.schema';
import { PatientUpdateOneRequiredWithoutAppointmentsNestedInputObjectSchema } from './PatientUpdateOneRequiredWithoutAppointmentsNestedInput.schema';
import { UserUpdateOneRequiredWithoutAppointmentsNestedInputObjectSchema } from './UserUpdateOneRequiredWithoutAppointmentsNestedInput.schema';
import type { Prisma } from '../../../generated/prisma';
const Schema: z.ZodType<Prisma.AppointmentUpdateInput> = z
.object({
title: z
.union([
z.string(),
z.lazy(() => StringFieldUpdateOperationsInputObjectSchema),
])
.optional(),
date: z
.union([
z.coerce.date(),
z.lazy(() => DateTimeFieldUpdateOperationsInputObjectSchema),
])
.optional(),
startTime: z
.union([
z.coerce.date(),
z.lazy(() => DateTimeFieldUpdateOperationsInputObjectSchema),
])
.optional(),
endTime: z
.union([
z.coerce.date(),
z.lazy(() => DateTimeFieldUpdateOperationsInputObjectSchema),
])
.optional(),
type: z
.union([
z.string(),
z.lazy(() => StringFieldUpdateOperationsInputObjectSchema),
])
.optional(),
notes: z
.union([
z.string(),
z.lazy(() => NullableStringFieldUpdateOperationsInputObjectSchema),
])
.optional()
.nullable(),
status: z
.union([
z.string(),
z.lazy(() => StringFieldUpdateOperationsInputObjectSchema),
])
.optional(),
createdAt: z
.union([
z.coerce.date(),
z.lazy(() => DateTimeFieldUpdateOperationsInputObjectSchema),
])
.optional(),
patient: z
.lazy(
() =>
PatientUpdateOneRequiredWithoutAppointmentsNestedInputObjectSchema,
)
.optional(),
user: z
.lazy(
() => UserUpdateOneRequiredWithoutAppointmentsNestedInputObjectSchema,
)
.optional(),
})
.strict();
export const AppointmentUpdateInputObjectSchema = Schema;

62
packages/db/shared/schemas/objects/AppointmentUpdateManyMutationInput.schema.ts Normal file
View File

@@ -0,0 +1,62 @@
import { z } from 'zod';
import { StringFieldUpdateOperationsInputObjectSchema } from './StringFieldUpdateOperationsInput.schema';
import { DateTimeFieldUpdateOperationsInputObjectSchema } from './DateTimeFieldUpdateOperationsInput.schema';
import { NullableStringFieldUpdateOperationsInputObjectSchema } from './NullableStringFieldUpdateOperationsInput.schema';
import type { Prisma } from '../../../generated/prisma';
const Schema: z.ZodType<Prisma.AppointmentUpdateManyMutationInput> = z
.object({
title: z
.union([
z.string(),
z.lazy(() => StringFieldUpdateOperationsInputObjectSchema),
])
.optional(),
date: z
.union([
z.coerce.date(),
z.lazy(() => DateTimeFieldUpdateOperationsInputObjectSchema),
])
.optional(),
startTime: z
.union([
z.coerce.date(),
z.lazy(() => DateTimeFieldUpdateOperationsInputObjectSchema),
])
.optional(),
endTime: z
.union([
z.coerce.date(),
z.lazy(() => DateTimeFieldUpdateOperationsInputObjectSchema),
])
.optional(),
type: z
.union([
z.string(),
z.lazy(() => StringFieldUpdateOperationsInputObjectSchema),
])
.optional(),
notes: z
.union([
z.string(),
z.lazy(() => NullableStringFieldUpdateOperationsInputObjectSchema),
])
.optional()
.nullable(),
status: z
.union([
z.string(),
z.lazy(() => StringFieldUpdateOperationsInputObjectSchema),
])
.optional(),
createdAt: z
.union([
z.coerce.date(),
z.lazy(() => DateTimeFieldUpdateOperationsInputObjectSchema),
])
.optional(),
})
.strict();
export const AppointmentUpdateManyMutationInputObjectSchema = Schema;

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

@@ -0,0 +1,23 @@
import { z } from 'zod';
import { AppointmentScalarWhereInputObjectSchema } from './AppointmentScalarWhereInput.schema';
import { AppointmentUpdateManyMutationInputObjectSchema } from './AppointmentUpdateManyMutationInput.schema';
import { AppointmentUncheckedUpdateManyWithoutAppointmentsInputObjectSchema } from './AppointmentUncheckedUpdateManyWithoutAppointmentsInput.schema';
import type { Prisma } from '../../../generated/prisma';
const Schema: z.ZodType<Prisma.AppointmentUpdateManyWithWhereWithoutPatientInput> =
z
.object({
where: z.lazy(() => AppointmentScalarWhereInputObjectSchema),
data: z.union([
z.lazy(() => AppointmentUpdateManyMutationInputObjectSchema),
z.lazy(
() =>
AppointmentUncheckedUpdateManyWithoutAppointmentsInputObjectSchema,
),
]),
})
.strict();
export const AppointmentUpdateManyWithWhereWithoutPatientInputObjectSchema =
Schema;

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

@@ -0,0 +1,23 @@
import { z } from 'zod';
import { AppointmentScalarWhereInputObjectSchema } from './AppointmentScalarWhereInput.schema';
import { AppointmentUpdateManyMutationInputObjectSchema } from './AppointmentUpdateManyMutationInput.schema';
import { AppointmentUncheckedUpdateManyWithoutAppointmentsInputObjectSchema } from './AppointmentUncheckedUpdateManyWithoutAppointmentsInput.schema';
import type { Prisma } from '../../../generated/prisma';
const Schema: z.ZodType<Prisma.AppointmentUpdateManyWithWhereWithoutUserInput> =
z
.object({
where: z.lazy(() => AppointmentScalarWhereInputObjectSchema),
data: z.union([
z.lazy(() => AppointmentUpdateManyMutationInputObjectSchema),
z.lazy(
() =>
AppointmentUncheckedUpdateManyWithoutAppointmentsInputObjectSchema,
),
]),
})
.strict();
export const AppointmentUpdateManyWithWhereWithoutUserInputObjectSchema =
Schema;

123
packages/db/shared/schemas/objects/AppointmentUpdateManyWithoutPatientNestedInput.schema.ts Normal file
View File

@@ -0,0 +1,123 @@
import { z } from 'zod';
import { AppointmentCreateWithoutPatientInputObjectSchema } from './AppointmentCreateWithoutPatientInput.schema';
import { AppointmentUncheckedCreateWithoutPatientInputObjectSchema } from './AppointmentUncheckedCreateWithoutPatientInput.schema';
import { AppointmentCreateOrConnectWithoutPatientInputObjectSchema } from './AppointmentCreateOrConnectWithoutPatientInput.schema';
import { AppointmentUpsertWithWhereUniqueWithoutPatientInputObjectSchema } from './AppointmentUpsertWithWhereUniqueWithoutPatientInput.schema';
import { AppointmentCreateManyPatientInputEnvelopeObjectSchema } from './AppointmentCreateManyPatientInputEnvelope.schema';
import { AppointmentWhereUniqueInputObjectSchema } from './AppointmentWhereUniqueInput.schema';
import { AppointmentUpdateWithWhereUniqueWithoutPatientInputObjectSchema } from './AppointmentUpdateWithWhereUniqueWithoutPatientInput.schema';
import { AppointmentUpdateManyWithWhereWithoutPatientInputObjectSchema } from './AppointmentUpdateManyWithWhereWithoutPatientInput.schema';
import { AppointmentScalarWhereInputObjectSchema } from './AppointmentScalarWhereInput.schema';
import type { Prisma } from '../../../generated/prisma';
const Schema: z.ZodType<Prisma.AppointmentUpdateManyWithoutPatientNestedInput> =
z
.object({
create: z
.union([
z.lazy(() => AppointmentCreateWithoutPatientInputObjectSchema),
z
.lazy(() => AppointmentCreateWithoutPatientInputObjectSchema)
.array(),
z.lazy(
() => AppointmentUncheckedCreateWithoutPatientInputObjectSchema,
),
z
.lazy(
() => AppointmentUncheckedCreateWithoutPatientInputObjectSchema,
)
.array(),
])
.optional(),
connectOrCreate: z
.union([
z.lazy(
() => AppointmentCreateOrConnectWithoutPatientInputObjectSchema,
),
z
.lazy(
() => AppointmentCreateOrConnectWithoutPatientInputObjectSchema,
)
.array(),
])
.optional(),
upsert: z
.union([
z.lazy(
() =>
AppointmentUpsertWithWhereUniqueWithoutPatientInputObjectSchema,
),
z
.lazy(
() =>
AppointmentUpsertWithWhereUniqueWithoutPatientInputObjectSchema,
)
.array(),
])
.optional(),
createMany: z
.lazy(() => AppointmentCreateManyPatientInputEnvelopeObjectSchema)
.optional(),
set: z
.union([
z.lazy(() => AppointmentWhereUniqueInputObjectSchema),
z.lazy(() => AppointmentWhereUniqueInputObjectSchema).array(),
])
.optional(),
disconnect: z
.union([
z.lazy(() => AppointmentWhereUniqueInputObjectSchema),
z.lazy(() => AppointmentWhereUniqueInputObjectSchema).array(),
])
.optional(),
delete: z
.union([
z.lazy(() => AppointmentWhereUniqueInputObjectSchema),
z.lazy(() => AppointmentWhereUniqueInputObjectSchema).array(),
])
.optional(),
connect: z
.union([
z.lazy(() => AppointmentWhereUniqueInputObjectSchema),
z.lazy(() => AppointmentWhereUniqueInputObjectSchema).array(),
])
.optional(),
update: z
.union([
z.lazy(
() =>
AppointmentUpdateWithWhereUniqueWithoutPatientInputObjectSchema,
),
z
.lazy(
() =>
AppointmentUpdateWithWhereUniqueWithoutPatientInputObjectSchema,
)
.array(),
])
.optional(),
updateMany: z
.union([
z.lazy(
() => AppointmentUpdateManyWithWhereWithoutPatientInputObjectSchema,
),
z
.lazy(
() =>
AppointmentUpdateManyWithWhereWithoutPatientInputObjectSchema,
)
.array(),
])
.optional(),
deleteMany: z
.union([
z.lazy(() => AppointmentScalarWhereInputObjectSchema),
z.lazy(() => AppointmentScalarWhereInputObjectSchema).array(),
])
.optional(),
})
.strict();
export const AppointmentUpdateManyWithoutPatientNestedInputObjectSchema =
Schema;

106
packages/db/shared/schemas/objects/AppointmentUpdateManyWithoutUserNestedInput.schema.ts Normal file
View File

@@ -0,0 +1,106 @@
import { z } from 'zod';
import { AppointmentCreateWithoutUserInputObjectSchema } from './AppointmentCreateWithoutUserInput.schema';
import { AppointmentUncheckedCreateWithoutUserInputObjectSchema } from './AppointmentUncheckedCreateWithoutUserInput.schema';
import { AppointmentCreateOrConnectWithoutUserInputObjectSchema } from './AppointmentCreateOrConnectWithoutUserInput.schema';
import { AppointmentUpsertWithWhereUniqueWithoutUserInputObjectSchema } from './AppointmentUpsertWithWhereUniqueWithoutUserInput.schema';
import { AppointmentCreateManyUserInputEnvelopeObjectSchema } from './AppointmentCreateManyUserInputEnvelope.schema';
import { AppointmentWhereUniqueInputObjectSchema } from './AppointmentWhereUniqueInput.schema';
import { AppointmentUpdateWithWhereUniqueWithoutUserInputObjectSchema } from './AppointmentUpdateWithWhereUniqueWithoutUserInput.schema';
import { AppointmentUpdateManyWithWhereWithoutUserInputObjectSchema } from './AppointmentUpdateManyWithWhereWithoutUserInput.schema';
import { AppointmentScalarWhereInputObjectSchema } from './AppointmentScalarWhereInput.schema';
import type { Prisma } from '../../../generated/prisma';
const Schema: z.ZodType<Prisma.AppointmentUpdateManyWithoutUserNestedInput> = z
.object({
create: z
.union([
z.lazy(() => AppointmentCreateWithoutUserInputObjectSchema),
z.lazy(() => AppointmentCreateWithoutUserInputObjectSchema).array(),
z.lazy(() => AppointmentUncheckedCreateWithoutUserInputObjectSchema),
z
.lazy(() => AppointmentUncheckedCreateWithoutUserInputObjectSchema)
.array(),
])
.optional(),
connectOrCreate: z
.union([
z.lazy(() => AppointmentCreateOrConnectWithoutUserInputObjectSchema),
z
.lazy(() => AppointmentCreateOrConnectWithoutUserInputObjectSchema)
.array(),
])
.optional(),
upsert: z
.union([
z.lazy(
() => AppointmentUpsertWithWhereUniqueWithoutUserInputObjectSchema,
),
z
.lazy(
() => AppointmentUpsertWithWhereUniqueWithoutUserInputObjectSchema,
)
.array(),
])
.optional(),
createMany: z
.lazy(() => AppointmentCreateManyUserInputEnvelopeObjectSchema)
.optional(),
set: z
.union([
z.lazy(() => AppointmentWhereUniqueInputObjectSchema),
z.lazy(() => AppointmentWhereUniqueInputObjectSchema).array(),
])
.optional(),
disconnect: z
.union([
z.lazy(() => AppointmentWhereUniqueInputObjectSchema),
z.lazy(() => AppointmentWhereUniqueInputObjectSchema).array(),
])
.optional(),
delete: z
.union([
z.lazy(() => AppointmentWhereUniqueInputObjectSchema),
z.lazy(() => AppointmentWhereUniqueInputObjectSchema).array(),
])
.optional(),
connect: z
.union([
z.lazy(() => AppointmentWhereUniqueInputObjectSchema),
z.lazy(() => AppointmentWhereUniqueInputObjectSchema).array(),
])
.optional(),
update: z
.union([
z.lazy(
() => AppointmentUpdateWithWhereUniqueWithoutUserInputObjectSchema,
),
z
.lazy(
() => AppointmentUpdateWithWhereUniqueWithoutUserInputObjectSchema,
)
.array(),
])
.optional(),
updateMany: z
.union([
z.lazy(
() => AppointmentUpdateManyWithWhereWithoutUserInputObjectSchema,
),
z
.lazy(
() => AppointmentUpdateManyWithWhereWithoutUserInputObjectSchema,
)
.array(),
])
.optional(),
deleteMany: z
.union([
z.lazy(() => AppointmentScalarWhereInputObjectSchema),
z.lazy(() => AppointmentScalarWhereInputObjectSchema).array(),
])
.optional(),
})
.strict();
export const AppointmentUpdateManyWithoutUserNestedInputObjectSchema = Schema;

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

@@ -0,0 +1,20 @@
import { z } from 'zod';
import { AppointmentWhereUniqueInputObjectSchema } from './AppointmentWhereUniqueInput.schema';
import { AppointmentUpdateWithoutPatientInputObjectSchema } from './AppointmentUpdateWithoutPatientInput.schema';
import { AppointmentUncheckedUpdateWithoutPatientInputObjectSchema } from './AppointmentUncheckedUpdateWithoutPatientInput.schema';
import type { Prisma } from '../../../generated/prisma';
const Schema: z.ZodType<Prisma.AppointmentUpdateWithWhereUniqueWithoutPatientInput> =
z
.object({
where: z.lazy(() => AppointmentWhereUniqueInputObjectSchema),
data: z.union([
z.lazy(() => AppointmentUpdateWithoutPatientInputObjectSchema),
z.lazy(() => AppointmentUncheckedUpdateWithoutPatientInputObjectSchema),
]),
})
.strict();
export const AppointmentUpdateWithWhereUniqueWithoutPatientInputObjectSchema =
Schema;

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

@@ -0,0 +1,20 @@
import { z } from 'zod';
import { AppointmentWhereUniqueInputObjectSchema } from './AppointmentWhereUniqueInput.schema';
import { AppointmentUpdateWithoutUserInputObjectSchema } from './AppointmentUpdateWithoutUserInput.schema';
import { AppointmentUncheckedUpdateWithoutUserInputObjectSchema } from './AppointmentUncheckedUpdateWithoutUserInput.schema';
import type { Prisma } from '../../../generated/prisma';
const Schema: z.ZodType<Prisma.AppointmentUpdateWithWhereUniqueWithoutUserInput> =
z
.object({
where: z.lazy(() => AppointmentWhereUniqueInputObjectSchema),
data: z.union([
z.lazy(() => AppointmentUpdateWithoutUserInputObjectSchema),
z.lazy(() => AppointmentUncheckedUpdateWithoutUserInputObjectSchema),
]),
})
.strict();
export const AppointmentUpdateWithWhereUniqueWithoutUserInputObjectSchema =
Schema;

68
packages/db/shared/schemas/objects/AppointmentUpdateWithoutPatientInput.schema.ts Normal file
View File

@@ -0,0 +1,68 @@
import { z } from 'zod';
import { StringFieldUpdateOperationsInputObjectSchema } from './StringFieldUpdateOperationsInput.schema';
import { DateTimeFieldUpdateOperationsInputObjectSchema } from './DateTimeFieldUpdateOperationsInput.schema';
import { NullableStringFieldUpdateOperationsInputObjectSchema } from './NullableStringFieldUpdateOperationsInput.schema';
import { UserUpdateOneRequiredWithoutAppointmentsNestedInputObjectSchema } from './UserUpdateOneRequiredWithoutAppointmentsNestedInput.schema';
import type { Prisma } from '../../../generated/prisma';
const Schema: z.ZodType<Prisma.AppointmentUpdateWithoutPatientInput> = z
.object({
title: z
.union([
z.string(),
z.lazy(() => StringFieldUpdateOperationsInputObjectSchema),
])
.optional(),
date: z
.union([
z.coerce.date(),
z.lazy(() => DateTimeFieldUpdateOperationsInputObjectSchema),
])
.optional(),
startTime: z
.union([
z.coerce.date(),
z.lazy(() => DateTimeFieldUpdateOperationsInputObjectSchema),
])
.optional(),
endTime: z
.union([
z.coerce.date(),
z.lazy(() => DateTimeFieldUpdateOperationsInputObjectSchema),
])
.optional(),
type: z
.union([
z.string(),
z.lazy(() => StringFieldUpdateOperationsInputObjectSchema),
])
.optional(),
notes: z
.union([
z.string(),
z.lazy(() => NullableStringFieldUpdateOperationsInputObjectSchema),
])
.optional()
.nullable(),
status: z
.union([
z.string(),
z.lazy(() => StringFieldUpdateOperationsInputObjectSchema),
])
.optional(),
createdAt: z
.union([
z.coerce.date(),
z.lazy(() => DateTimeFieldUpdateOperationsInputObjectSchema),
])
.optional(),
user: z
.lazy(
() => UserUpdateOneRequiredWithoutAppointmentsNestedInputObjectSchema,
)
.optional(),
})
.strict();
export const AppointmentUpdateWithoutPatientInputObjectSchema = Schema;

69
packages/db/shared/schemas/objects/AppointmentUpdateWithoutUserInput.schema.ts Normal file
View File

@@ -0,0 +1,69 @@
import { z } from 'zod';
import { StringFieldUpdateOperationsInputObjectSchema } from './StringFieldUpdateOperationsInput.schema';
import { DateTimeFieldUpdateOperationsInputObjectSchema } from './DateTimeFieldUpdateOperationsInput.schema';
import { NullableStringFieldUpdateOperationsInputObjectSchema } from './NullableStringFieldUpdateOperationsInput.schema';
import { PatientUpdateOneRequiredWithoutAppointmentsNestedInputObjectSchema } from './PatientUpdateOneRequiredWithoutAppointmentsNestedInput.schema';
import type { Prisma } from '../../../generated/prisma';
const Schema: z.ZodType<Prisma.AppointmentUpdateWithoutUserInput> = z
.object({
title: z
.union([
z.string(),
z.lazy(() => StringFieldUpdateOperationsInputObjectSchema),
])
.optional(),
date: z
.union([
z.coerce.date(),
z.lazy(() => DateTimeFieldUpdateOperationsInputObjectSchema),
])
.optional(),
startTime: z
.union([
z.coerce.date(),
z.lazy(() => DateTimeFieldUpdateOperationsInputObjectSchema),
])
.optional(),
endTime: z
.union([
z.coerce.date(),
z.lazy(() => DateTimeFieldUpdateOperationsInputObjectSchema),
])
.optional(),
type: z
.union([
z.string(),
z.lazy(() => StringFieldUpdateOperationsInputObjectSchema),
])
.optional(),
notes: z
.union([
z.string(),
z.lazy(() => NullableStringFieldUpdateOperationsInputObjectSchema),
])
.optional()
.nullable(),
status: z
.union([
z.string(),
z.lazy(() => StringFieldUpdateOperationsInputObjectSchema),
])
.optional(),
createdAt: z
.union([
z.coerce.date(),
z.lazy(() => DateTimeFieldUpdateOperationsInputObjectSchema),
])
.optional(),
patient: z
.lazy(
() =>
PatientUpdateOneRequiredWithoutAppointmentsNestedInputObjectSchema,
)
.optional(),
})
.strict();
export const AppointmentUpdateWithoutUserInputObjectSchema = Schema;

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

@@ -0,0 +1,26 @@
import { z } from 'zod';
import { AppointmentWhereUniqueInputObjectSchema } from './AppointmentWhereUniqueInput.schema';
import { AppointmentUpdateWithoutPatientInputObjectSchema } from './AppointmentUpdateWithoutPatientInput.schema';
import { AppointmentUncheckedUpdateWithoutPatientInputObjectSchema } from './AppointmentUncheckedUpdateWithoutPatientInput.schema';
import { AppointmentCreateWithoutPatientInputObjectSchema } from './AppointmentCreateWithoutPatientInput.schema';
import { AppointmentUncheckedCreateWithoutPatientInputObjectSchema } from './AppointmentUncheckedCreateWithoutPatientInput.schema';
import type { Prisma } from '../../../generated/prisma';
const Schema: z.ZodType<Prisma.AppointmentUpsertWithWhereUniqueWithoutPatientInput> =
z
.object({
where: z.lazy(() => AppointmentWhereUniqueInputObjectSchema),
update: z.union([
z.lazy(() => AppointmentUpdateWithoutPatientInputObjectSchema),
z.lazy(() => AppointmentUncheckedUpdateWithoutPatientInputObjectSchema),
]),
create: z.union([
z.lazy(() => AppointmentCreateWithoutPatientInputObjectSchema),
z.lazy(() => AppointmentUncheckedCreateWithoutPatientInputObjectSchema),
]),
})
.strict();
export const AppointmentUpsertWithWhereUniqueWithoutPatientInputObjectSchema =
Schema;

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

@@ -0,0 +1,26 @@
import { z } from 'zod';
import { AppointmentWhereUniqueInputObjectSchema } from './AppointmentWhereUniqueInput.schema';
import { AppointmentUpdateWithoutUserInputObjectSchema } from './AppointmentUpdateWithoutUserInput.schema';
import { AppointmentUncheckedUpdateWithoutUserInputObjectSchema } from './AppointmentUncheckedUpdateWithoutUserInput.schema';
import { AppointmentCreateWithoutUserInputObjectSchema } from './AppointmentCreateWithoutUserInput.schema';
import { AppointmentUncheckedCreateWithoutUserInputObjectSchema } from './AppointmentUncheckedCreateWithoutUserInput.schema';
import type { Prisma } from '../../../generated/prisma';
const Schema: z.ZodType<Prisma.AppointmentUpsertWithWhereUniqueWithoutUserInput> =
z
.object({
where: z.lazy(() => AppointmentWhereUniqueInputObjectSchema),
update: z.union([
z.lazy(() => AppointmentUpdateWithoutUserInputObjectSchema),
z.lazy(() => AppointmentUncheckedUpdateWithoutUserInputObjectSchema),
]),
create: z.union([
z.lazy(() => AppointmentCreateWithoutUserInputObjectSchema),
z.lazy(() => AppointmentUncheckedCreateWithoutUserInputObjectSchema),
]),
})
.strict();
export const AppointmentUpsertWithWhereUniqueWithoutUserInputObjectSchema =
Schema;

78
packages/db/shared/schemas/objects/AppointmentWhereInput.schema.ts Normal file
View File

@@ -0,0 +1,78 @@
import { z } from 'zod';
import { IntFilterObjectSchema } from './IntFilter.schema';
import { StringFilterObjectSchema } from './StringFilter.schema';
import { DateTimeFilterObjectSchema } from './DateTimeFilter.schema';
import { StringNullableFilterObjectSchema } from './StringNullableFilter.schema';
import { PatientRelationFilterObjectSchema } from './PatientRelationFilter.schema';
import { PatientWhereInputObjectSchema } from './PatientWhereInput.schema';
import { UserRelationFilterObjectSchema } from './UserRelationFilter.schema';
import { UserWhereInputObjectSchema } from './UserWhereInput.schema';
import type { Prisma } from '../../../generated/prisma';
const Schema: z.ZodType<Prisma.AppointmentWhereInput> = z
.object({
AND: z
.union([
z.lazy(() => AppointmentWhereInputObjectSchema),
z.lazy(() => AppointmentWhereInputObjectSchema).array(),
])
.optional(),
OR: z
.lazy(() => AppointmentWhereInputObjectSchema)
.array()
.optional(),
NOT: z
.union([
z.lazy(() => AppointmentWhereInputObjectSchema),
z.lazy(() => AppointmentWhereInputObjectSchema).array(),
])
.optional(),
id: z.union([z.lazy(() => IntFilterObjectSchema), z.number()]).optional(),
patientId: z
.union([z.lazy(() => IntFilterObjectSchema), z.number()])
.optional(),
userId: z
.union([z.lazy(() => IntFilterObjectSchema), z.number()])
.optional(),
title: z
.union([z.lazy(() => StringFilterObjectSchema), z.string()])
.optional(),
date: z
.union([z.lazy(() => DateTimeFilterObjectSchema), z.coerce.date()])
.optional(),
startTime: z
.union([z.lazy(() => DateTimeFilterObjectSchema), z.coerce.date()])
.optional(),
endTime: z
.union([z.lazy(() => DateTimeFilterObjectSchema), z.coerce.date()])
.optional(),
type: z
.union([z.lazy(() => StringFilterObjectSchema), z.string()])
.optional(),
notes: z
.union([z.lazy(() => StringNullableFilterObjectSchema), z.string()])
.optional()
.nullable(),
status: z
.union([z.lazy(() => StringFilterObjectSchema), z.string()])
.optional(),
createdAt: z
.union([z.lazy(() => DateTimeFilterObjectSchema), z.coerce.date()])
.optional(),
patient: z
.union([
z.lazy(() => PatientRelationFilterObjectSchema),
z.lazy(() => PatientWhereInputObjectSchema),
])
.optional(),
user: z
.union([
z.lazy(() => UserRelationFilterObjectSchema),
z.lazy(() => UserWhereInputObjectSchema),
])
.optional(),
})
.strict();
export const AppointmentWhereInputObjectSchema = Schema;

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

@@ -0,0 +1,11 @@
import { z } from 'zod';
import type { Prisma } from '../../../generated/prisma';
const Schema: z.ZodType<Prisma.AppointmentWhereUniqueInput> = z
.object({
id: z.number().optional(),
})
.strict();
export const AppointmentWhereUniqueInputObjectSchema = Schema;

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

@@ -0,0 +1,11 @@
import { z } from 'zod';
import type { Prisma } from '../../../generated/prisma';
const Schema: z.ZodType<Prisma.DateTimeFieldUpdateOperationsInput> = z
.object({
set: z.coerce.date().optional(),
})
.strict();
export const DateTimeFieldUpdateOperationsInputObjectSchema = Schema;

21
packages/db/shared/schemas/objects/DateTimeFilter.schema.ts Normal file
View File

@@ -0,0 +1,21 @@
import { z } from 'zod';
import { NestedDateTimeFilterObjectSchema } from './NestedDateTimeFilter.schema';
import type { Prisma } from '../../../generated/prisma';
const Schema: z.ZodType<Prisma.DateTimeFilter> = z
.object({
equals: z.coerce.date().optional(),
in: z.union([z.coerce.date().array(), z.coerce.date()]).optional(),
notIn: z.union([z.coerce.date().array(), z.coerce.date()]).optional(),
lt: z.coerce.date().optional(),
lte: z.coerce.date().optional(),
gt: z.coerce.date().optional(),
gte: z.coerce.date().optional(),
not: z
.union([z.coerce.date(), z.lazy(() => NestedDateTimeFilterObjectSchema)])
.optional(),
})
.strict();
export const DateTimeFilterObjectSchema = Schema;

29
packages/db/shared/schemas/objects/DateTimeWithAggregatesFilter.schema.ts Normal file
View File

@@ -0,0 +1,29 @@
import { z } from 'zod';
import { NestedDateTimeWithAggregatesFilterObjectSchema } from './NestedDateTimeWithAggregatesFilter.schema';
import { NestedIntFilterObjectSchema } from './NestedIntFilter.schema';
import { NestedDateTimeFilterObjectSchema } from './NestedDateTimeFilter.schema';
import type { Prisma } from '../../../generated/prisma';
const Schema: z.ZodType<Prisma.DateTimeWithAggregatesFilter> = z
.object({
equals: z.coerce.date().optional(),
in: z.union([z.coerce.date().array(), z.coerce.date()]).optional(),
notIn: z.union([z.coerce.date().array(), z.coerce.date()]).optional(),
lt: z.coerce.date().optional(),
lte: z.coerce.date().optional(),
gt: z.coerce.date().optional(),
gte: z.coerce.date().optional(),
not: z
.union([
z.coerce.date(),
z.lazy(() => NestedDateTimeWithAggregatesFilterObjectSchema),
])
.optional(),
_count: z.lazy(() => NestedIntFilterObjectSchema).optional(),
_min: z.lazy(() => NestedDateTimeFilterObjectSchema).optional(),
_max: z.lazy(() => NestedDateTimeFilterObjectSchema).optional(),
})
.strict();
export const DateTimeWithAggregatesFilterObjectSchema = Schema;

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

@@ -0,0 +1,15 @@
import { z } from 'zod';
import type { Prisma } from '../../../generated/prisma';
const Schema: z.ZodType<Prisma.IntFieldUpdateOperationsInput> = z
.object({
set: z.number().optional(),
increment: z.number().optional(),
decrement: z.number().optional(),
multiply: z.number().optional(),
divide: z.number().optional(),
})
.strict();
export const IntFieldUpdateOperationsInputObjectSchema = Schema;

21
packages/db/shared/schemas/objects/IntFilter.schema.ts Normal file
View File

@@ -0,0 +1,21 @@
import { z } from 'zod';
import { NestedIntFilterObjectSchema } from './NestedIntFilter.schema';
import type { Prisma } from '../../../generated/prisma';
const Schema: z.ZodType<Prisma.IntFilter> = z
.object({
equals: z.number().optional(),
in: z.union([z.number().array(), z.number()]).optional(),
notIn: z.union([z.number().array(), z.number()]).optional(),
lt: z.number().optional(),
lte: z.number().optional(),
gt: z.number().optional(),
gte: z.number().optional(),
not: z
.union([z.number(), z.lazy(() => NestedIntFilterObjectSchema)])
.optional(),
})
.strict();
export const IntFilterObjectSchema = Schema;

31
packages/db/shared/schemas/objects/IntWithAggregatesFilter.schema.ts Normal file
View File

@@ -0,0 +1,31 @@
import { z } from 'zod';
import { NestedIntWithAggregatesFilterObjectSchema } from './NestedIntWithAggregatesFilter.schema';
import { NestedIntFilterObjectSchema } from './NestedIntFilter.schema';
import { NestedFloatFilterObjectSchema } from './NestedFloatFilter.schema';
import type { Prisma } from '../../../generated/prisma';
const Schema: z.ZodType<Prisma.IntWithAggregatesFilter> = z
.object({
equals: z.number().optional(),
in: z.union([z.number().array(), z.number()]).optional(),
notIn: z.union([z.number().array(), z.number()]).optional(),
lt: z.number().optional(),
lte: z.number().optional(),
gt: z.number().optional(),
gte: z.number().optional(),
not: z
.union([
z.number(),
z.lazy(() => NestedIntWithAggregatesFilterObjectSchema),
])
.optional(),
_count: z.lazy(() => NestedIntFilterObjectSchema).optional(),
_avg: z.lazy(() => NestedFloatFilterObjectSchema).optional(),
_sum: z.lazy(() => NestedIntFilterObjectSchema).optional(),
_min: z.lazy(() => NestedIntFilterObjectSchema).optional(),
_max: z.lazy(() => NestedIntFilterObjectSchema).optional(),
})
.strict();
export const IntWithAggregatesFilterObjectSchema = Schema;

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

@@ -0,0 +1,20 @@
import { z } from 'zod';
import type { Prisma } from '../../../generated/prisma';
const Schema: z.ZodType<Prisma.NestedDateTimeFilter> = z
.object({
equals: z.coerce.date().optional(),
in: z.union([z.coerce.date().array(), z.coerce.date()]).optional(),
notIn: z.union([z.coerce.date().array(), z.coerce.date()]).optional(),
lt: z.coerce.date().optional(),
lte: z.coerce.date().optional(),
gt: z.coerce.date().optional(),
gte: z.coerce.date().optional(),
not: z
.union([z.coerce.date(), z.lazy(() => NestedDateTimeFilterObjectSchema)])
.optional(),
})
.strict();
export const NestedDateTimeFilterObjectSchema = Schema;

28
packages/db/shared/schemas/objects/NestedDateTimeWithAggregatesFilter.schema.ts Normal file
View File

@@ -0,0 +1,28 @@
import { z } from 'zod';
import { NestedIntFilterObjectSchema } from './NestedIntFilter.schema';
import { NestedDateTimeFilterObjectSchema } from './NestedDateTimeFilter.schema';
import type { Prisma } from '../../../generated/prisma';
const Schema: z.ZodType<Prisma.NestedDateTimeWithAggregatesFilter> = z
.object({
equals: z.coerce.date().optional(),
in: z.union([z.coerce.date().array(), z.coerce.date()]).optional(),
notIn: z.union([z.coerce.date().array(), z.coerce.date()]).optional(),
lt: z.coerce.date().optional(),
lte: z.coerce.date().optional(),
gt: z.coerce.date().optional(),
gte: z.coerce.date().optional(),
not: z
.union([
z.coerce.date(),
z.lazy(() => NestedDateTimeWithAggregatesFilterObjectSchema),
])
.optional(),
_count: z.lazy(() => NestedIntFilterObjectSchema).optional(),
_min: z.lazy(() => NestedDateTimeFilterObjectSchema).optional(),
_max: z.lazy(() => NestedDateTimeFilterObjectSchema).optional(),
})
.strict();
export const NestedDateTimeWithAggregatesFilterObjectSchema = Schema;

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

@@ -0,0 +1,20 @@
import { z } from 'zod';
import type { Prisma } from '../../../generated/prisma';
const Schema: z.ZodType<Prisma.NestedFloatFilter> = z
.object({
equals: z.number().optional(),
in: z.union([z.number().array(), z.number()]).optional(),
notIn: z.union([z.number().array(), z.number()]).optional(),
lt: z.number().optional(),
lte: z.number().optional(),
gt: z.number().optional(),
gte: z.number().optional(),
not: z
.union([z.number(), z.lazy(() => NestedFloatFilterObjectSchema)])
.optional(),
})
.strict();
export const NestedFloatFilterObjectSchema = Schema;

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

@@ -0,0 +1,20 @@
import { z } from 'zod';
import type { Prisma } from '../../../generated/prisma';
const Schema: z.ZodType<Prisma.NestedIntFilter> = z
.object({
equals: z.number().optional(),
in: z.union([z.number().array(), z.number()]).optional(),
notIn: z.union([z.number().array(), z.number()]).optional(),
lt: z.number().optional(),
lte: z.number().optional(),
gt: z.number().optional(),
gte: z.number().optional(),
not: z
.union([z.number(), z.lazy(() => NestedIntFilterObjectSchema)])
.optional(),
})
.strict();
export const NestedIntFilterObjectSchema = Schema;

21
packages/db/shared/schemas/objects/NestedIntNullableFilter.schema.ts Normal file
View File

@@ -0,0 +1,21 @@
import { z } from 'zod';
import type { Prisma } from '../../../generated/prisma';
const Schema: z.ZodType<Prisma.NestedIntNullableFilter> = z
.object({
equals: z.number().optional().nullable(),
in: z.union([z.number().array(), z.number()]).optional().nullable(),
notIn: z.union([z.number().array(), z.number()]).optional().nullable(),
lt: z.number().optional(),
lte: z.number().optional(),
gt: z.number().optional(),
gte: z.number().optional(),
not: z
.union([z.number(), z.lazy(() => NestedIntNullableFilterObjectSchema)])
.optional()
.nullable(),
})
.strict();
export const NestedIntNullableFilterObjectSchema = Schema;

30
packages/db/shared/schemas/objects/NestedIntWithAggregatesFilter.schema.ts Normal file
View File

@@ -0,0 +1,30 @@
import { z } from 'zod';
import { NestedIntFilterObjectSchema } from './NestedIntFilter.schema';
import { NestedFloatFilterObjectSchema } from './NestedFloatFilter.schema';
import type { Prisma } from '../../../generated/prisma';
const Schema: z.ZodType<Prisma.NestedIntWithAggregatesFilter> = z
.object({
equals: z.number().optional(),
in: z.union([z.number().array(), z.number()]).optional(),
notIn: z.union([z.number().array(), z.number()]).optional(),
lt: z.number().optional(),
lte: z.number().optional(),
gt: z.number().optional(),
gte: z.number().optional(),
not: z
.union([
z.number(),
z.lazy(() => NestedIntWithAggregatesFilterObjectSchema),
])
.optional(),
_count: z.lazy(() => NestedIntFilterObjectSchema).optional(),
_avg: z.lazy(() => NestedFloatFilterObjectSchema).optional(),
_sum: z.lazy(() => NestedIntFilterObjectSchema).optional(),
_min: z.lazy(() => NestedIntFilterObjectSchema).optional(),
_max: z.lazy(() => NestedIntFilterObjectSchema).optional(),
})
.strict();
export const NestedIntWithAggregatesFilterObjectSchema = Schema;

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

@@ -0,0 +1,23 @@
import { z } from 'zod';
import type { Prisma } from '../../../generated/prisma';
const Schema: z.ZodType<Prisma.NestedStringFilter> = z
.object({
equals: z.string().optional(),
in: z.union([z.string().array(), z.string()]).optional(),
notIn: z.union([z.string().array(), z.string()]).optional(),
lt: z.string().optional(),
lte: z.string().optional(),
gt: z.string().optional(),
gte: z.string().optional(),
contains: z.string().optional(),
startsWith: z.string().optional(),
endsWith: z.string().optional(),
not: z
.union([z.string(), z.lazy(() => NestedStringFilterObjectSchema)])
.optional(),
})
.strict();
export const NestedStringFilterObjectSchema = Schema;

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

@@ -0,0 +1,24 @@
import { z } from 'zod';
import type { Prisma } from '../../../generated/prisma';
const Schema: z.ZodType<Prisma.NestedStringNullableFilter> = z
.object({
equals: z.string().optional().nullable(),
in: z.union([z.string().array(), z.string()]).optional().nullable(),
notIn: z.union([z.string().array(), z.string()]).optional().nullable(),
lt: z.string().optional(),
lte: z.string().optional(),
gt: z.string().optional(),
gte: z.string().optional(),
contains: z.string().optional(),
startsWith: z.string().optional(),
endsWith: z.string().optional(),
not: z
.union([z.string(), z.lazy(() => NestedStringNullableFilterObjectSchema)])
.optional()
.nullable(),
})
.strict();
export const NestedStringNullableFilterObjectSchema = Schema;

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

@@ -0,0 +1,32 @@
import { z } from 'zod';
import { NestedIntNullableFilterObjectSchema } from './NestedIntNullableFilter.schema';
import { NestedStringNullableFilterObjectSchema } from './NestedStringNullableFilter.schema';
import type { Prisma } from '../../../generated/prisma';
const Schema: z.ZodType<Prisma.NestedStringNullableWithAggregatesFilter> = z
.object({
equals: z.string().optional().nullable(),
in: z.union([z.string().array(), z.string()]).optional().nullable(),
notIn: z.union([z.string().array(), z.string()]).optional().nullable(),
lt: z.string().optional(),
lte: z.string().optional(),
gt: z.string().optional(),
gte: z.string().optional(),
contains: z.string().optional(),
startsWith: z.string().optional(),
endsWith: z.string().optional(),
not: z
.union([
z.string(),
z.lazy(() => NestedStringNullableWithAggregatesFilterObjectSchema),
])
.optional()
.nullable(),
_count: z.lazy(() => NestedIntNullableFilterObjectSchema).optional(),
_min: z.lazy(() => NestedStringNullableFilterObjectSchema).optional(),
_max: z.lazy(() => NestedStringNullableFilterObjectSchema).optional(),
})
.strict();
export const NestedStringNullableWithAggregatesFilterObjectSchema = Schema;

31
packages/db/shared/schemas/objects/NestedStringWithAggregatesFilter.schema.ts Normal file
View File

@@ -0,0 +1,31 @@
import { z } from 'zod';
import { NestedIntFilterObjectSchema } from './NestedIntFilter.schema';
import { NestedStringFilterObjectSchema } from './NestedStringFilter.schema';
import type { Prisma } from '../../../generated/prisma';
const Schema: z.ZodType<Prisma.NestedStringWithAggregatesFilter> = z
.object({
equals: z.string().optional(),
in: z.union([z.string().array(), z.string()]).optional(),
notIn: z.union([z.string().array(), z.string()]).optional(),
lt: z.string().optional(),
lte: z.string().optional(),
gt: z.string().optional(),
gte: z.string().optional(),
contains: z.string().optional(),
startsWith: z.string().optional(),
endsWith: z.string().optional(),
not: z
.union([
z.string(),
z.lazy(() => NestedStringWithAggregatesFilterObjectSchema),
])
.optional(),
_count: z.lazy(() => NestedIntFilterObjectSchema).optional(),
_min: z.lazy(() => NestedStringFilterObjectSchema).optional(),
_max: z.lazy(() => NestedStringFilterObjectSchema).optional(),
})
.strict();
export const NestedStringWithAggregatesFilterObjectSchema = Schema;

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

@@ -0,0 +1,11 @@
import { z } from 'zod';
import type { Prisma } from '../../../generated/prisma';
const Schema: z.ZodType<Prisma.NullableStringFieldUpdateOperationsInput> = z
.object({
set: z.string().optional().nullable(),
})
.strict();
export const NullableStringFieldUpdateOperationsInputObjectSchema = Schema;

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

@@ -0,0 +1,12 @@
import { z } from 'zod';
import type { Prisma } from '../../../generated/prisma';
const Schema: z.ZodType<Prisma.PatientAvgAggregateInputType> = z
.object({
id: z.literal(true).optional(),
userId: z.literal(true).optional(),
})
.strict();
export const PatientAvgAggregateInputObjectSchema = Schema;

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

@@ -0,0 +1,13 @@
import { z } from 'zod';
import { SortOrderSchema } from '../enums/SortOrder.schema';
import type { Prisma } from '../../../generated/prisma';
const Schema: z.ZodType<Prisma.PatientAvgOrderByAggregateInput> = z
.object({
id: z.lazy(() => SortOrderSchema).optional(),
userId: z.lazy(() => SortOrderSchema).optional(),
})
.strict();
export const PatientAvgOrderByAggregateInputObjectSchema = Schema;

30
packages/db/shared/schemas/objects/PatientCountAggregateInput.schema.ts Normal file
View File

@@ -0,0 +1,30 @@
import { z } from 'zod';
import type { Prisma } from '../../../generated/prisma';
const Schema: z.ZodType<Prisma.PatientCountAggregateInputType> = z
.object({
id: z.literal(true).optional(),
firstName: z.literal(true).optional(),
lastName: z.literal(true).optional(),
dateOfBirth: z.literal(true).optional(),
gender: z.literal(true).optional(),
phone: z.literal(true).optional(),
email: z.literal(true).optional(),
address: z.literal(true).optional(),
city: z.literal(true).optional(),
zipCode: z.literal(true).optional(),
insuranceProvider: z.literal(true).optional(),
insuranceId: z.literal(true).optional(),
groupNumber: z.literal(true).optional(),
policyHolder: z.literal(true).optional(),
allergies: z.literal(true).optional(),
medicalConditions: z.literal(true).optional(),
status: z.literal(true).optional(),
userId: z.literal(true).optional(),
createdAt: z.literal(true).optional(),
_all: z.literal(true).optional(),
})
.strict();
export const PatientCountAggregateInputObjectSchema = Schema;

30
packages/db/shared/schemas/objects/PatientCountOrderByAggregateInput.schema.ts Normal file
View File

@@ -0,0 +1,30 @@
import { z } from 'zod';
import { SortOrderSchema } from '../enums/SortOrder.schema';
import type { Prisma } from '../../../generated/prisma';
const Schema: z.ZodType<Prisma.PatientCountOrderByAggregateInput> = z
.object({
id: z.lazy(() => SortOrderSchema).optional(),
firstName: z.lazy(() => SortOrderSchema).optional(),
lastName: z.lazy(() => SortOrderSchema).optional(),
dateOfBirth: z.lazy(() => SortOrderSchema).optional(),
gender: z.lazy(() => SortOrderSchema).optional(),
phone: z.lazy(() => SortOrderSchema).optional(),
email: z.lazy(() => SortOrderSchema).optional(),
address: z.lazy(() => SortOrderSchema).optional(),
city: z.lazy(() => SortOrderSchema).optional(),
zipCode: z.lazy(() => SortOrderSchema).optional(),
insuranceProvider: z.lazy(() => SortOrderSchema).optional(),
insuranceId: z.lazy(() => SortOrderSchema).optional(),
groupNumber: z.lazy(() => SortOrderSchema).optional(),
policyHolder: z.lazy(() => SortOrderSchema).optional(),
allergies: z.lazy(() => SortOrderSchema).optional(),
medicalConditions: z.lazy(() => SortOrderSchema).optional(),
status: z.lazy(() => SortOrderSchema).optional(),
userId: z.lazy(() => SortOrderSchema).optional(),
createdAt: z.lazy(() => SortOrderSchema).optional(),
})
.strict();
export const PatientCountOrderByAggregateInputObjectSchema = Schema;

33
packages/db/shared/schemas/objects/PatientCreateInput.schema.ts Normal file
View File

@@ -0,0 +1,33 @@
import { z } from 'zod';
import { UserCreateNestedOneWithoutPatientsInputObjectSchema } from './UserCreateNestedOneWithoutPatientsInput.schema';
import { AppointmentCreateNestedManyWithoutPatientInputObjectSchema } from './AppointmentCreateNestedManyWithoutPatientInput.schema';
import type { Prisma } from '../../../generated/prisma';
const Schema: z.ZodType<Prisma.PatientCreateInput> = z
.object({
firstName: z.string(),
lastName: z.string(),
dateOfBirth: z.coerce.date(),
gender: z.string(),
phone: z.string(),
email: z.string().optional().nullable(),
address: z.string().optional().nullable(),
city: z.string().optional().nullable(),
zipCode: z.string().optional().nullable(),
insuranceProvider: z.string().optional().nullable(),
insuranceId: z.string().optional().nullable(),
groupNumber: z.string().optional().nullable(),
policyHolder: z.string().optional().nullable(),
allergies: z.string().optional().nullable(),
medicalConditions: z.string().optional().nullable(),
status: z.string().optional(),
createdAt: z.coerce.date().optional(),
user: z.lazy(() => UserCreateNestedOneWithoutPatientsInputObjectSchema),
appointments: z
.lazy(() => AppointmentCreateNestedManyWithoutPatientInputObjectSchema)
.optional(),
})
.strict();
export const PatientCreateInputObjectSchema = Schema;

29
packages/db/shared/schemas/objects/PatientCreateManyInput.schema.ts Normal file
View File

@@ -0,0 +1,29 @@
import { z } from 'zod';
import type { Prisma } from '../../../generated/prisma';
const Schema: z.ZodType<Prisma.PatientCreateManyInput> = z
.object({
id: z.number().optional(),
firstName: z.string(),
lastName: z.string(),
dateOfBirth: z.coerce.date(),
gender: z.string(),
phone: z.string(),
email: z.string().optional().nullable(),
address: z.string().optional().nullable(),
city: z.string().optional().nullable(),
zipCode: z.string().optional().nullable(),
insuranceProvider: z.string().optional().nullable(),
insuranceId: z.string().optional().nullable(),
groupNumber: z.string().optional().nullable(),
policyHolder: z.string().optional().nullable(),
allergies: z.string().optional().nullable(),
medicalConditions: z.string().optional().nullable(),
status: z.string().optional(),
userId: z.number(),
createdAt: z.coerce.date().optional(),
})
.strict();
export const PatientCreateManyInputObjectSchema = Schema;

28
packages/db/shared/schemas/objects/PatientCreateManyUserInput.schema.ts Normal file
View File

@@ -0,0 +1,28 @@
import { z } from 'zod';
import type { Prisma } from '../../../generated/prisma';
const Schema: z.ZodType<Prisma.PatientCreateManyUserInput> = z
.object({
id: z.number().optional(),
firstName: z.string(),
lastName: z.string(),
dateOfBirth: z.coerce.date(),
gender: z.string(),
phone: z.string(),
email: z.string().optional().nullable(),
address: z.string().optional().nullable(),
city: z.string().optional().nullable(),
zipCode: z.string().optional().nullable(),
insuranceProvider: z.string().optional().nullable(),
insuranceId: z.string().optional().nullable(),
groupNumber: z.string().optional().nullable(),
policyHolder: z.string().optional().nullable(),
allergies: z.string().optional().nullable(),
medicalConditions: z.string().optional().nullable(),
status: z.string().optional(),
createdAt: z.coerce.date().optional(),
})
.strict();
export const PatientCreateManyUserInputObjectSchema = Schema;

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

@@ -0,0 +1,16 @@
import { z } from 'zod';
import { PatientCreateManyUserInputObjectSchema } from './PatientCreateManyUserInput.schema';
import type { Prisma } from '../../../generated/prisma';
const Schema: z.ZodType<Prisma.PatientCreateManyUserInputEnvelope> = z
.object({
data: z.union([
z.lazy(() => PatientCreateManyUserInputObjectSchema),
z.lazy(() => PatientCreateManyUserInputObjectSchema).array(),
]),
skipDuplicates: z.boolean().optional(),
})
.strict();
export const PatientCreateManyUserInputEnvelopeObjectSchema = Schema;

42
packages/db/shared/schemas/objects/PatientCreateNestedManyWithoutUserInput.schema.ts Normal file
View File

@@ -0,0 +1,42 @@
import { z } from 'zod';
import { PatientCreateWithoutUserInputObjectSchema } from './PatientCreateWithoutUserInput.schema';
import { PatientUncheckedCreateWithoutUserInputObjectSchema } from './PatientUncheckedCreateWithoutUserInput.schema';
import { PatientCreateOrConnectWithoutUserInputObjectSchema } from './PatientCreateOrConnectWithoutUserInput.schema';
import { PatientCreateManyUserInputEnvelopeObjectSchema } from './PatientCreateManyUserInputEnvelope.schema';
import { PatientWhereUniqueInputObjectSchema } from './PatientWhereUniqueInput.schema';
import type { Prisma } from '../../../generated/prisma';
const Schema: z.ZodType<Prisma.PatientCreateNestedManyWithoutUserInput> = z
.object({
create: z
.union([
z.lazy(() => PatientCreateWithoutUserInputObjectSchema),
z.lazy(() => PatientCreateWithoutUserInputObjectSchema).array(),
z.lazy(() => PatientUncheckedCreateWithoutUserInputObjectSchema),
z
.lazy(() => PatientUncheckedCreateWithoutUserInputObjectSchema)
.array(),
])
.optional(),
connectOrCreate: z
.union([
z.lazy(() => PatientCreateOrConnectWithoutUserInputObjectSchema),
z
.lazy(() => PatientCreateOrConnectWithoutUserInputObjectSchema)
.array(),
])
.optional(),
createMany: z
.lazy(() => PatientCreateManyUserInputEnvelopeObjectSchema)
.optional(),
connect: z
.union([
z.lazy(() => PatientWhereUniqueInputObjectSchema),
z.lazy(() => PatientWhereUniqueInputObjectSchema).array(),
])
.optional(),
})
.strict();
export const PatientCreateNestedManyWithoutUserInputObjectSchema = Schema;

28
packages/db/shared/schemas/objects/PatientCreateNestedOneWithoutAppointmentsInput.schema.ts Normal file
View File

@@ -0,0 +1,28 @@
import { z } from 'zod';
import { PatientCreateWithoutAppointmentsInputObjectSchema } from './PatientCreateWithoutAppointmentsInput.schema';
import { PatientUncheckedCreateWithoutAppointmentsInputObjectSchema } from './PatientUncheckedCreateWithoutAppointmentsInput.schema';
import { PatientCreateOrConnectWithoutAppointmentsInputObjectSchema } from './PatientCreateOrConnectWithoutAppointmentsInput.schema';
import { PatientWhereUniqueInputObjectSchema } from './PatientWhereUniqueInput.schema';
import type { Prisma } from '../../../generated/prisma';
const Schema: z.ZodType<Prisma.PatientCreateNestedOneWithoutAppointmentsInput> =
z
.object({
create: z
.union([
z.lazy(() => PatientCreateWithoutAppointmentsInputObjectSchema),
z.lazy(
() => PatientUncheckedCreateWithoutAppointmentsInputObjectSchema,
),
])
.optional(),
connectOrCreate: z
.lazy(() => PatientCreateOrConnectWithoutAppointmentsInputObjectSchema)
.optional(),
connect: z.lazy(() => PatientWhereUniqueInputObjectSchema).optional(),
})
.strict();
export const PatientCreateNestedOneWithoutAppointmentsInputObjectSchema =
Schema;

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

@@ -0,0 +1,22 @@
import { z } from 'zod';
import { PatientWhereUniqueInputObjectSchema } from './PatientWhereUniqueInput.schema';
import { PatientCreateWithoutAppointmentsInputObjectSchema } from './PatientCreateWithoutAppointmentsInput.schema';
import { PatientUncheckedCreateWithoutAppointmentsInputObjectSchema } from './PatientUncheckedCreateWithoutAppointmentsInput.schema';
import type { Prisma } from '../../../generated/prisma';
const Schema: z.ZodType<Prisma.PatientCreateOrConnectWithoutAppointmentsInput> =
z
.object({
where: z.lazy(() => PatientWhereUniqueInputObjectSchema),
create: z.union([
z.lazy(() => PatientCreateWithoutAppointmentsInputObjectSchema),
z.lazy(
() => PatientUncheckedCreateWithoutAppointmentsInputObjectSchema,
),
]),
})
.strict();
export const PatientCreateOrConnectWithoutAppointmentsInputObjectSchema =
Schema;

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

@@ -0,0 +1,18 @@
import { z } from 'zod';
import { PatientWhereUniqueInputObjectSchema } from './PatientWhereUniqueInput.schema';
import { PatientCreateWithoutUserInputObjectSchema } from './PatientCreateWithoutUserInput.schema';
import { PatientUncheckedCreateWithoutUserInputObjectSchema } from './PatientUncheckedCreateWithoutUserInput.schema';
import type { Prisma } from '../../../generated/prisma';
const Schema: z.ZodType<Prisma.PatientCreateOrConnectWithoutUserInput> = z
.object({
where: z.lazy(() => PatientWhereUniqueInputObjectSchema),
create: z.union([
z.lazy(() => PatientCreateWithoutUserInputObjectSchema),
z.lazy(() => PatientUncheckedCreateWithoutUserInputObjectSchema),
]),
})
.strict();
export const PatientCreateOrConnectWithoutUserInputObjectSchema = Schema;

29
packages/db/shared/schemas/objects/PatientCreateWithoutAppointmentsInput.schema.ts Normal file
View File

@@ -0,0 +1,29 @@
import { z } from 'zod';
import { UserCreateNestedOneWithoutPatientsInputObjectSchema } from './UserCreateNestedOneWithoutPatientsInput.schema';
import type { Prisma } from '../../../generated/prisma';
const Schema: z.ZodType<Prisma.PatientCreateWithoutAppointmentsInput> = z
.object({
firstName: z.string(),
lastName: z.string(),
dateOfBirth: z.coerce.date(),
gender: z.string(),
phone: z.string(),
email: z.string().optional().nullable(),
address: z.string().optional().nullable(),
city: z.string().optional().nullable(),
zipCode: z.string().optional().nullable(),
insuranceProvider: z.string().optional().nullable(),
insuranceId: z.string().optional().nullable(),
groupNumber: z.string().optional().nullable(),
policyHolder: z.string().optional().nullable(),
allergies: z.string().optional().nullable(),
medicalConditions: z.string().optional().nullable(),
status: z.string().optional(),
createdAt: z.coerce.date().optional(),
user: z.lazy(() => UserCreateNestedOneWithoutPatientsInputObjectSchema),
})
.strict();
export const PatientCreateWithoutAppointmentsInputObjectSchema = Schema;

31
packages/db/shared/schemas/objects/PatientCreateWithoutUserInput.schema.ts Normal file
View File

@@ -0,0 +1,31 @@
import { z } from 'zod';
import { AppointmentCreateNestedManyWithoutPatientInputObjectSchema } from './AppointmentCreateNestedManyWithoutPatientInput.schema';
import type { Prisma } from '../../../generated/prisma';
const Schema: z.ZodType<Prisma.PatientCreateWithoutUserInput> = z
.object({
firstName: z.string(),
lastName: z.string(),
dateOfBirth: z.coerce.date(),
gender: z.string(),
phone: z.string(),
email: z.string().optional().nullable(),
address: z.string().optional().nullable(),
city: z.string().optional().nullable(),
zipCode: z.string().optional().nullable(),
insuranceProvider: z.string().optional().nullable(),
insuranceId: z.string().optional().nullable(),
groupNumber: z.string().optional().nullable(),
policyHolder: z.string().optional().nullable(),
allergies: z.string().optional().nullable(),
medicalConditions: z.string().optional().nullable(),
status: z.string().optional(),
createdAt: z.coerce.date().optional(),
appointments: z
.lazy(() => AppointmentCreateNestedManyWithoutPatientInputObjectSchema)
.optional(),
})
.strict();
export const PatientCreateWithoutUserInputObjectSchema = Schema;

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

@@ -0,0 +1,14 @@
import { z } from 'zod';
import { PatientWhereInputObjectSchema } from './PatientWhereInput.schema';
import type { Prisma } from '../../../generated/prisma';
const Schema: z.ZodType<Prisma.PatientListRelationFilter> = z
.object({
every: z.lazy(() => PatientWhereInputObjectSchema).optional(),
some: z.lazy(() => PatientWhereInputObjectSchema).optional(),
none: z.lazy(() => PatientWhereInputObjectSchema).optional(),
})
.strict();
export const PatientListRelationFilterObjectSchema = Schema;

29
packages/db/shared/schemas/objects/PatientMaxAggregateInput.schema.ts Normal file
View File

@@ -0,0 +1,29 @@
import { z } from 'zod';
import type { Prisma } from '../../../generated/prisma';
const Schema: z.ZodType<Prisma.PatientMaxAggregateInputType> = z
.object({
id: z.literal(true).optional(),
firstName: z.literal(true).optional(),
lastName: z.literal(true).optional(),
dateOfBirth: z.literal(true).optional(),
gender: z.literal(true).optional(),
phone: z.literal(true).optional(),
email: z.literal(true).optional(),
address: z.literal(true).optional(),
city: z.literal(true).optional(),
zipCode: z.literal(true).optional(),
insuranceProvider: z.literal(true).optional(),
insuranceId: z.literal(true).optional(),
groupNumber: z.literal(true).optional(),
policyHolder: z.literal(true).optional(),
allergies: z.literal(true).optional(),
medicalConditions: z.literal(true).optional(),
status: z.literal(true).optional(),
userId: z.literal(true).optional(),
createdAt: z.literal(true).optional(),
})
.strict();
export const PatientMaxAggregateInputObjectSchema = Schema;

30
packages/db/shared/schemas/objects/PatientMaxOrderByAggregateInput.schema.ts Normal file
View File

@@ -0,0 +1,30 @@
import { z } from 'zod';
import { SortOrderSchema } from '../enums/SortOrder.schema';
import type { Prisma } from '../../../generated/prisma';
const Schema: z.ZodType<Prisma.PatientMaxOrderByAggregateInput> = z
.object({
id: z.lazy(() => SortOrderSchema).optional(),
firstName: z.lazy(() => SortOrderSchema).optional(),
lastName: z.lazy(() => SortOrderSchema).optional(),
dateOfBirth: z.lazy(() => SortOrderSchema).optional(),
gender: z.lazy(() => SortOrderSchema).optional(),
phone: z.lazy(() => SortOrderSchema).optional(),
email: z.lazy(() => SortOrderSchema).optional(),
address: z.lazy(() => SortOrderSchema).optional(),
city: z.lazy(() => SortOrderSchema).optional(),
zipCode: z.lazy(() => SortOrderSchema).optional(),
insuranceProvider: z.lazy(() => SortOrderSchema).optional(),
insuranceId: z.lazy(() => SortOrderSchema).optional(),
groupNumber: z.lazy(() => SortOrderSchema).optional(),
policyHolder: z.lazy(() => SortOrderSchema).optional(),
allergies: z.lazy(() => SortOrderSchema).optional(),
medicalConditions: z.lazy(() => SortOrderSchema).optional(),
status: z.lazy(() => SortOrderSchema).optional(),
userId: z.lazy(() => SortOrderSchema).optional(),
createdAt: z.lazy(() => SortOrderSchema).optional(),
})
.strict();
export const PatientMaxOrderByAggregateInputObjectSchema = Schema;

29
packages/db/shared/schemas/objects/PatientMinAggregateInput.schema.ts Normal file
View File

@@ -0,0 +1,29 @@
import { z } from 'zod';
import type { Prisma } from '../../../generated/prisma';
const Schema: z.ZodType<Prisma.PatientMinAggregateInputType> = z
.object({
id: z.literal(true).optional(),
firstName: z.literal(true).optional(),
lastName: z.literal(true).optional(),
dateOfBirth: z.literal(true).optional(),
gender: z.literal(true).optional(),
phone: z.literal(true).optional(),
email: z.literal(true).optional(),
address: z.literal(true).optional(),
city: z.literal(true).optional(),
zipCode: z.literal(true).optional(),
insuranceProvider: z.literal(true).optional(),
insuranceId: z.literal(true).optional(),
groupNumber: z.literal(true).optional(),
policyHolder: z.literal(true).optional(),
allergies: z.literal(true).optional(),
medicalConditions: z.literal(true).optional(),
status: z.literal(true).optional(),
userId: z.literal(true).optional(),
createdAt: z.literal(true).optional(),
})
.strict();
export const PatientMinAggregateInputObjectSchema = Schema;

30
packages/db/shared/schemas/objects/PatientMinOrderByAggregateInput.schema.ts Normal file
View File

@@ -0,0 +1,30 @@
import { z } from 'zod';
import { SortOrderSchema } from '../enums/SortOrder.schema';
import type { Prisma } from '../../../generated/prisma';
const Schema: z.ZodType<Prisma.PatientMinOrderByAggregateInput> = z
.object({
id: z.lazy(() => SortOrderSchema).optional(),
firstName: z.lazy(() => SortOrderSchema).optional(),
lastName: z.lazy(() => SortOrderSchema).optional(),
dateOfBirth: z.lazy(() => SortOrderSchema).optional(),
gender: z.lazy(() => SortOrderSchema).optional(),
phone: z.lazy(() => SortOrderSchema).optional(),
email: z.lazy(() => SortOrderSchema).optional(),
address: z.lazy(() => SortOrderSchema).optional(),
city: z.lazy(() => SortOrderSchema).optional(),
zipCode: z.lazy(() => SortOrderSchema).optional(),
insuranceProvider: z.lazy(() => SortOrderSchema).optional(),
insuranceId: z.lazy(() => SortOrderSchema).optional(),
groupNumber: z.lazy(() => SortOrderSchema).optional(),
policyHolder: z.lazy(() => SortOrderSchema).optional(),
allergies: z.lazy(() => SortOrderSchema).optional(),
medicalConditions: z.lazy(() => SortOrderSchema).optional(),
status: z.lazy(() => SortOrderSchema).optional(),
userId: z.lazy(() => SortOrderSchema).optional(),
createdAt: z.lazy(() => SortOrderSchema).optional(),
})
.strict();
export const PatientMinOrderByAggregateInputObjectSchema = Schema;

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

@@ -0,0 +1,12 @@
import { z } from 'zod';
import { SortOrderSchema } from '../enums/SortOrder.schema';
import type { Prisma } from '../../../generated/prisma';
const Schema: z.ZodType<Prisma.PatientOrderByRelationAggregateInput> = z
.object({
_count: z.lazy(() => SortOrderSchema).optional(),
})
.strict();
export const PatientOrderByRelationAggregateInputObjectSchema = Schema;

93
packages/db/shared/schemas/objects/PatientOrderByWithAggregationInput.schema.ts Normal file
View File

@@ -0,0 +1,93 @@
import { z } from 'zod';
import { SortOrderSchema } from '../enums/SortOrder.schema';
import { SortOrderInputObjectSchema } from './SortOrderInput.schema';
import { PatientCountOrderByAggregateInputObjectSchema } from './PatientCountOrderByAggregateInput.schema';
import { PatientAvgOrderByAggregateInputObjectSchema } from './PatientAvgOrderByAggregateInput.schema';
import { PatientMaxOrderByAggregateInputObjectSchema } from './PatientMaxOrderByAggregateInput.schema';
import { PatientMinOrderByAggregateInputObjectSchema } from './PatientMinOrderByAggregateInput.schema';
import { PatientSumOrderByAggregateInputObjectSchema } from './PatientSumOrderByAggregateInput.schema';
import type { Prisma } from '../../../generated/prisma';
const Schema: z.ZodType<Prisma.PatientOrderByWithAggregationInput> = z
.object({
id: z.lazy(() => SortOrderSchema).optional(),
firstName: z.lazy(() => SortOrderSchema).optional(),
lastName: z.lazy(() => SortOrderSchema).optional(),
dateOfBirth: z.lazy(() => SortOrderSchema).optional(),
gender: z.lazy(() => SortOrderSchema).optional(),
phone: z.lazy(() => SortOrderSchema).optional(),
email: z
.union([
z.lazy(() => SortOrderSchema),
z.lazy(() => SortOrderInputObjectSchema),
])
.optional(),
address: z
.union([
z.lazy(() => SortOrderSchema),
z.lazy(() => SortOrderInputObjectSchema),
])
.optional(),
city: z
.union([
z.lazy(() => SortOrderSchema),
z.lazy(() => SortOrderInputObjectSchema),
])
.optional(),
zipCode: z
.union([
z.lazy(() => SortOrderSchema),
z.lazy(() => SortOrderInputObjectSchema),
])
.optional(),
insuranceProvider: z
.union([
z.lazy(() => SortOrderSchema),
z.lazy(() => SortOrderInputObjectSchema),
])
.optional(),
insuranceId: z
.union([
z.lazy(() => SortOrderSchema),
z.lazy(() => SortOrderInputObjectSchema),
])
.optional(),
groupNumber: z
.union([
z.lazy(() => SortOrderSchema),
z.lazy(() => SortOrderInputObjectSchema),
])
.optional(),
policyHolder: z
.union([
z.lazy(() => SortOrderSchema),
z.lazy(() => SortOrderInputObjectSchema),
])
.optional(),
allergies: z
.union([
z.lazy(() => SortOrderSchema),
z.lazy(() => SortOrderInputObjectSchema),
])
.optional(),
medicalConditions: z
.union([
z.lazy(() => SortOrderSchema),
z.lazy(() => SortOrderInputObjectSchema),
])
.optional(),
status: z.lazy(() => SortOrderSchema).optional(),
userId: z.lazy(() => SortOrderSchema).optional(),
createdAt: z.lazy(() => SortOrderSchema).optional(),
_count: z
.lazy(() => PatientCountOrderByAggregateInputObjectSchema)
.optional(),
_avg: z.lazy(() => PatientAvgOrderByAggregateInputObjectSchema).optional(),
_max: z.lazy(() => PatientMaxOrderByAggregateInputObjectSchema).optional(),
_min: z.lazy(() => PatientMinOrderByAggregateInputObjectSchema).optional(),
_sum: z.lazy(() => PatientSumOrderByAggregateInputObjectSchema).optional(),
})
.strict();
export const PatientOrderByWithAggregationInputObjectSchema = Schema;

87
packages/db/shared/schemas/objects/PatientOrderByWithRelationInput.schema.ts Normal file
View File

@@ -0,0 +1,87 @@
import { z } from 'zod';
import { SortOrderSchema } from '../enums/SortOrder.schema';
import { SortOrderInputObjectSchema } from './SortOrderInput.schema';
import { UserOrderByWithRelationInputObjectSchema } from './UserOrderByWithRelationInput.schema';
import { AppointmentOrderByRelationAggregateInputObjectSchema } from './AppointmentOrderByRelationAggregateInput.schema';
import type { Prisma } from '../../../generated/prisma';
const Schema: z.ZodType<Prisma.PatientOrderByWithRelationInput> = z
.object({
id: z.lazy(() => SortOrderSchema).optional(),
firstName: z.lazy(() => SortOrderSchema).optional(),
lastName: z.lazy(() => SortOrderSchema).optional(),
dateOfBirth: z.lazy(() => SortOrderSchema).optional(),
gender: z.lazy(() => SortOrderSchema).optional(),
phone: z.lazy(() => SortOrderSchema).optional(),
email: z
.union([
z.lazy(() => SortOrderSchema),
z.lazy(() => SortOrderInputObjectSchema),
])
.optional(),
address: z
.union([
z.lazy(() => SortOrderSchema),
z.lazy(() => SortOrderInputObjectSchema),
])
.optional(),
city: z
.union([
z.lazy(() => SortOrderSchema),
z.lazy(() => SortOrderInputObjectSchema),
])
.optional(),
zipCode: z
.union([
z.lazy(() => SortOrderSchema),
z.lazy(() => SortOrderInputObjectSchema),
])
.optional(),
insuranceProvider: z
.union([
z.lazy(() => SortOrderSchema),
z.lazy(() => SortOrderInputObjectSchema),
])
.optional(),
insuranceId: z
.union([
z.lazy(() => SortOrderSchema),
z.lazy(() => SortOrderInputObjectSchema),
])
.optional(),
groupNumber: z
.union([
z.lazy(() => SortOrderSchema),
z.lazy(() => SortOrderInputObjectSchema),
])
.optional(),
policyHolder: z
.union([
z.lazy(() => SortOrderSchema),
z.lazy(() => SortOrderInputObjectSchema),
])
.optional(),
allergies: z
.union([
z.lazy(() => SortOrderSchema),
z.lazy(() => SortOrderInputObjectSchema),
])
.optional(),
medicalConditions: z
.union([
z.lazy(() => SortOrderSchema),
z.lazy(() => SortOrderInputObjectSchema),
])
.optional(),
status: z.lazy(() => SortOrderSchema).optional(),
userId: z.lazy(() => SortOrderSchema).optional(),
createdAt: z.lazy(() => SortOrderSchema).optional(),
user: z.lazy(() => UserOrderByWithRelationInputObjectSchema).optional(),
appointments: z
.lazy(() => AppointmentOrderByRelationAggregateInputObjectSchema)
.optional(),
})
.strict();
export const PatientOrderByWithRelationInputObjectSchema = Schema;

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

@@ -0,0 +1,19 @@
import { z } from 'zod';
import { PatientWhereInputObjectSchema } from './PatientWhereInput.schema';
import type { Prisma } from '../../../generated/prisma';
const Schema: z.ZodType<Prisma.PatientRelationFilter> = z
.object({
is: z
.lazy(() => PatientWhereInputObjectSchema)
.optional()
.nullable(),
isNot: z
.lazy(() => PatientWhereInputObjectSchema)
.optional()
.nullable(),
})
.strict();
export const PatientRelationFilterObjectSchema = Schema;

95
packages/db/shared/schemas/objects/PatientScalarWhereInput.schema.ts Normal file
View File

@@ -0,0 +1,95 @@
import { z } from 'zod';
import { IntFilterObjectSchema } from './IntFilter.schema';
import { StringFilterObjectSchema } from './StringFilter.schema';
import { DateTimeFilterObjectSchema } from './DateTimeFilter.schema';
import { StringNullableFilterObjectSchema } from './StringNullableFilter.schema';
import type { Prisma } from '../../../generated/prisma';
const Schema: z.ZodType<Prisma.PatientScalarWhereInput> = z
.object({
AND: z
.union([
z.lazy(() => PatientScalarWhereInputObjectSchema),
z.lazy(() => PatientScalarWhereInputObjectSchema).array(),
])
.optional(),
OR: z
.lazy(() => PatientScalarWhereInputObjectSchema)
.array()
.optional(),
NOT: z
.union([
z.lazy(() => PatientScalarWhereInputObjectSchema),
z.lazy(() => PatientScalarWhereInputObjectSchema).array(),
])
.optional(),
id: z.union([z.lazy(() => IntFilterObjectSchema), z.number()]).optional(),
firstName: z
.union([z.lazy(() => StringFilterObjectSchema), z.string()])
.optional(),
lastName: z
.union([z.lazy(() => StringFilterObjectSchema), z.string()])
.optional(),
dateOfBirth: z
.union([z.lazy(() => DateTimeFilterObjectSchema), z.coerce.date()])
.optional(),
gender: z
.union([z.lazy(() => StringFilterObjectSchema), z.string()])
.optional(),
phone: z
.union([z.lazy(() => StringFilterObjectSchema), z.string()])
.optional(),
email: z
.union([z.lazy(() => StringNullableFilterObjectSchema), z.string()])
.optional()
.nullable(),
address: z
.union([z.lazy(() => StringNullableFilterObjectSchema), z.string()])
.optional()
.nullable(),
city: z
.union([z.lazy(() => StringNullableFilterObjectSchema), z.string()])
.optional()
.nullable(),
zipCode: z
.union([z.lazy(() => StringNullableFilterObjectSchema), z.string()])
.optional()
.nullable(),
insuranceProvider: z
.union([z.lazy(() => StringNullableFilterObjectSchema), z.string()])
.optional()
.nullable(),
insuranceId: z
.union([z.lazy(() => StringNullableFilterObjectSchema), z.string()])
.optional()
.nullable(),
groupNumber: z
.union([z.lazy(() => StringNullableFilterObjectSchema), z.string()])
.optional()
.nullable(),
policyHolder: z
.union([z.lazy(() => StringNullableFilterObjectSchema), z.string()])
.optional()
.nullable(),
allergies: z
.union([z.lazy(() => StringNullableFilterObjectSchema), z.string()])
.optional()
.nullable(),
medicalConditions: z
.union([z.lazy(() => StringNullableFilterObjectSchema), z.string()])
.optional()
.nullable(),
status: z
.union([z.lazy(() => StringFilterObjectSchema), z.string()])
.optional(),
userId: z
.union([z.lazy(() => IntFilterObjectSchema), z.number()])
.optional(),
createdAt: z
.union([z.lazy(() => DateTimeFilterObjectSchema), z.coerce.date()])
.optional(),
})
.strict();
export const PatientScalarWhereInputObjectSchema = Schema;

133
packages/db/shared/schemas/objects/PatientScalarWhereWithAggregatesInput.schema.ts Normal file
View File

@@ -0,0 +1,133 @@
import { z } from 'zod';
import { IntWithAggregatesFilterObjectSchema } from './IntWithAggregatesFilter.schema';
import { StringWithAggregatesFilterObjectSchema } from './StringWithAggregatesFilter.schema';
import { DateTimeWithAggregatesFilterObjectSchema } from './DateTimeWithAggregatesFilter.schema';
import { StringNullableWithAggregatesFilterObjectSchema } from './StringNullableWithAggregatesFilter.schema';
import type { Prisma } from '../../../generated/prisma';
const Schema: z.ZodType<Prisma.PatientScalarWhereWithAggregatesInput> = z
.object({
AND: z
.union([
z.lazy(() => PatientScalarWhereWithAggregatesInputObjectSchema),
z.lazy(() => PatientScalarWhereWithAggregatesInputObjectSchema).array(),
])
.optional(),
OR: z
.lazy(() => PatientScalarWhereWithAggregatesInputObjectSchema)
.array()
.optional(),
NOT: z
.union([
z.lazy(() => PatientScalarWhereWithAggregatesInputObjectSchema),
z.lazy(() => PatientScalarWhereWithAggregatesInputObjectSchema).array(),
])
.optional(),
id: z
.union([z.lazy(() => IntWithAggregatesFilterObjectSchema), z.number()])
.optional(),
firstName: z
.union([z.lazy(() => StringWithAggregatesFilterObjectSchema), z.string()])
.optional(),
lastName: z
.union([z.lazy(() => StringWithAggregatesFilterObjectSchema), z.string()])
.optional(),
dateOfBirth: z
.union([
z.lazy(() => DateTimeWithAggregatesFilterObjectSchema),
z.coerce.date(),
])
.optional(),
gender: z
.union([z.lazy(() => StringWithAggregatesFilterObjectSchema), z.string()])
.optional(),
phone: z
.union([z.lazy(() => StringWithAggregatesFilterObjectSchema), z.string()])
.optional(),
email: z
.union([
z.lazy(() => StringNullableWithAggregatesFilterObjectSchema),
z.string(),
])
.optional()
.nullable(),
address: z
.union([
z.lazy(() => StringNullableWithAggregatesFilterObjectSchema),
z.string(),
])
.optional()
.nullable(),
city: z
.union([
z.lazy(() => StringNullableWithAggregatesFilterObjectSchema),
z.string(),
])
.optional()
.nullable(),
zipCode: z
.union([
z.lazy(() => StringNullableWithAggregatesFilterObjectSchema),
z.string(),
])
.optional()
.nullable(),
insuranceProvider: z
.union([
z.lazy(() => StringNullableWithAggregatesFilterObjectSchema),
z.string(),
])
.optional()
.nullable(),
insuranceId: z
.union([
z.lazy(() => StringNullableWithAggregatesFilterObjectSchema),
z.string(),
])
.optional()
.nullable(),
groupNumber: z
.union([
z.lazy(() => StringNullableWithAggregatesFilterObjectSchema),
z.string(),
])
.optional()
.nullable(),
policyHolder: z
.union([
z.lazy(() => StringNullableWithAggregatesFilterObjectSchema),
z.string(),
])
.optional()
.nullable(),
allergies: z
.union([
z.lazy(() => StringNullableWithAggregatesFilterObjectSchema),
z.string(),
])
.optional()
.nullable(),
medicalConditions: z
.union([
z.lazy(() => StringNullableWithAggregatesFilterObjectSchema),
z.string(),
])
.optional()
.nullable(),
status: z
.union([z.lazy(() => StringWithAggregatesFilterObjectSchema), z.string()])
.optional(),
userId: z
.union([z.lazy(() => IntWithAggregatesFilterObjectSchema), z.number()])
.optional(),
createdAt: z
.union([
z.lazy(() => DateTimeWithAggregatesFilterObjectSchema),
z.coerce.date(),
])
.optional(),
})
.strict();
export const PatientScalarWhereWithAggregatesInputObjectSchema = Schema;

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

@@ -0,0 +1,12 @@
import { z } from 'zod';
import type { Prisma } from '../../../generated/prisma';
const Schema: z.ZodType<Prisma.PatientSumAggregateInputType> = z
.object({
id: z.literal(true).optional(),
userId: z.literal(true).optional(),
})
.strict();
export const PatientSumAggregateInputObjectSchema = Schema;

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

@@ -0,0 +1,13 @@
import { z } from 'zod';
import { SortOrderSchema } from '../enums/SortOrder.schema';
import type { Prisma } from '../../../generated/prisma';
const Schema: z.ZodType<Prisma.PatientSumOrderByAggregateInput> = z
.object({
id: z.lazy(() => SortOrderSchema).optional(),
userId: z.lazy(() => SortOrderSchema).optional(),
})
.strict();
export const PatientSumOrderByAggregateInputObjectSchema = Schema;

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

@@ -0,0 +1,36 @@
import { z } from 'zod';
import { AppointmentUncheckedCreateNestedManyWithoutPatientInputObjectSchema } from './AppointmentUncheckedCreateNestedManyWithoutPatientInput.schema';
import type { Prisma } from '../../../generated/prisma';
const Schema: z.ZodType<Prisma.PatientUncheckedCreateInput> = z
.object({
id: z.number().optional(),
firstName: z.string(),
lastName: z.string(),
dateOfBirth: z.coerce.date(),
gender: z.string(),
phone: z.string(),
email: z.string().optional().nullable(),
address: z.string().optional().nullable(),
city: z.string().optional().nullable(),
zipCode: z.string().optional().nullable(),
insuranceProvider: z.string().optional().nullable(),
insuranceId: z.string().optional().nullable(),
groupNumber: z.string().optional().nullable(),
policyHolder: z.string().optional().nullable(),
allergies: z.string().optional().nullable(),
medicalConditions: z.string().optional().nullable(),
status: z.string().optional(),
userId: z.number(),
createdAt: z.coerce.date().optional(),
appointments: z
.lazy(
() =>
AppointmentUncheckedCreateNestedManyWithoutPatientInputObjectSchema,
)
.optional(),
})
.strict();
export const PatientUncheckedCreateInputObjectSchema = Schema;

44
packages/db/shared/schemas/objects/PatientUncheckedCreateNestedManyWithoutUserInput.schema.ts Normal file
View File

@@ -0,0 +1,44 @@
import { z } from 'zod';
import { PatientCreateWithoutUserInputObjectSchema } from './PatientCreateWithoutUserInput.schema';
import { PatientUncheckedCreateWithoutUserInputObjectSchema } from './PatientUncheckedCreateWithoutUserInput.schema';
import { PatientCreateOrConnectWithoutUserInputObjectSchema } from './PatientCreateOrConnectWithoutUserInput.schema';
import { PatientCreateManyUserInputEnvelopeObjectSchema } from './PatientCreateManyUserInputEnvelope.schema';
import { PatientWhereUniqueInputObjectSchema } from './PatientWhereUniqueInput.schema';
import type { Prisma } from '../../../generated/prisma';
const Schema: z.ZodType<Prisma.PatientUncheckedCreateNestedManyWithoutUserInput> =
z
.object({
create: z
.union([
z.lazy(() => PatientCreateWithoutUserInputObjectSchema),
z.lazy(() => PatientCreateWithoutUserInputObjectSchema).array(),
z.lazy(() => PatientUncheckedCreateWithoutUserInputObjectSchema),
z
.lazy(() => PatientUncheckedCreateWithoutUserInputObjectSchema)
.array(),
])
.optional(),
connectOrCreate: z
.union([
z.lazy(() => PatientCreateOrConnectWithoutUserInputObjectSchema),
z
.lazy(() => PatientCreateOrConnectWithoutUserInputObjectSchema)
.array(),
])
.optional(),
createMany: z
.lazy(() => PatientCreateManyUserInputEnvelopeObjectSchema)
.optional(),
connect: z
.union([
z.lazy(() => PatientWhereUniqueInputObjectSchema),
z.lazy(() => PatientWhereUniqueInputObjectSchema).array(),
])
.optional(),
})
.strict();
export const PatientUncheckedCreateNestedManyWithoutUserInputObjectSchema =
Schema;

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