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

tailwind styles added

Browse Source
This commit is contained in:
Vishnu
2025-05-10 14:07:49 +05:30
parent 4b02202ec9
commit dd26e27193
209 changed files with 0 additions and 7143 deletions
Download Patch File Download Diff File Expand all files Collapse all files

29
packages/db/shared/schemas/aggregateAppointment.schema.ts
View File

@@ -1,29 +0,0 @@
import { z } from 'zod';
import { AppointmentOrderByWithRelationInputObjectSchema } from './objects/AppointmentOrderByWithRelationInput.schema';
import { AppointmentWhereInputObjectSchema } from './objects/AppointmentWhereInput.schema';
import { AppointmentWhereUniqueInputObjectSchema } from './objects/AppointmentWhereUniqueInput.schema';
import { AppointmentCountAggregateInputObjectSchema } from './objects/AppointmentCountAggregateInput.schema';
import { AppointmentMinAggregateInputObjectSchema } from './objects/AppointmentMinAggregateInput.schema';
import { AppointmentMaxAggregateInputObjectSchema } from './objects/AppointmentMaxAggregateInput.schema';
import { AppointmentAvgAggregateInputObjectSchema } from './objects/AppointmentAvgAggregateInput.schema';
import { AppointmentSumAggregateInputObjectSchema } from './objects/AppointmentSumAggregateInput.schema';
export const AppointmentAggregateSchema = z.object({
orderBy: z
.union([
AppointmentOrderByWithRelationInputObjectSchema,
AppointmentOrderByWithRelationInputObjectSchema.array(),
])
.optional(),
where: AppointmentWhereInputObjectSchema.optional(),
cursor: AppointmentWhereUniqueInputObjectSchema.optional(),
take: z.number().optional(),
skip: z.number().optional(),
_count: z
.union([z.literal(true), AppointmentCountAggregateInputObjectSchema])
.optional(),
_min: AppointmentMinAggregateInputObjectSchema.optional(),
_max: AppointmentMaxAggregateInputObjectSchema.optional(),
_avg: AppointmentAvgAggregateInputObjectSchema.optional(),
_sum: AppointmentSumAggregateInputObjectSchema.optional(),
});

29
packages/db/shared/schemas/aggregatePatient.schema.ts
View File

@@ -1,29 +0,0 @@
import { z } from 'zod';
import { PatientOrderByWithRelationInputObjectSchema } from './objects/PatientOrderByWithRelationInput.schema';
import { PatientWhereInputObjectSchema } from './objects/PatientWhereInput.schema';
import { PatientWhereUniqueInputObjectSchema } from './objects/PatientWhereUniqueInput.schema';
import { PatientCountAggregateInputObjectSchema } from './objects/PatientCountAggregateInput.schema';
import { PatientMinAggregateInputObjectSchema } from './objects/PatientMinAggregateInput.schema';
import { PatientMaxAggregateInputObjectSchema } from './objects/PatientMaxAggregateInput.schema';
import { PatientAvgAggregateInputObjectSchema } from './objects/PatientAvgAggregateInput.schema';
import { PatientSumAggregateInputObjectSchema } from './objects/PatientSumAggregateInput.schema';
export const PatientAggregateSchema = z.object({
orderBy: z
.union([
PatientOrderByWithRelationInputObjectSchema,
PatientOrderByWithRelationInputObjectSchema.array(),
])
.optional(),
where: PatientWhereInputObjectSchema.optional(),
cursor: PatientWhereUniqueInputObjectSchema.optional(),
take: z.number().optional(),
skip: z.number().optional(),
_count: z
.union([z.literal(true), PatientCountAggregateInputObjectSchema])
.optional(),
_min: PatientMinAggregateInputObjectSchema.optional(),
_max: PatientMaxAggregateInputObjectSchema.optional(),
_avg: PatientAvgAggregateInputObjectSchema.optional(),
_sum: PatientSumAggregateInputObjectSchema.optional(),
});

29
packages/db/shared/schemas/aggregateUser.schema.ts
View File

@@ -1,29 +0,0 @@
import { z } from 'zod';
import { UserOrderByWithRelationInputObjectSchema } from './objects/UserOrderByWithRelationInput.schema';
import { UserWhereInputObjectSchema } from './objects/UserWhereInput.schema';
import { UserWhereUniqueInputObjectSchema } from './objects/UserWhereUniqueInput.schema';
import { UserCountAggregateInputObjectSchema } from './objects/UserCountAggregateInput.schema';
import { UserMinAggregateInputObjectSchema } from './objects/UserMinAggregateInput.schema';
import { UserMaxAggregateInputObjectSchema } from './objects/UserMaxAggregateInput.schema';
import { UserAvgAggregateInputObjectSchema } from './objects/UserAvgAggregateInput.schema';
import { UserSumAggregateInputObjectSchema } from './objects/UserSumAggregateInput.schema';
export const UserAggregateSchema = z.object({
orderBy: z
.union([
UserOrderByWithRelationInputObjectSchema,
UserOrderByWithRelationInputObjectSchema.array(),
])
.optional(),
where: UserWhereInputObjectSchema.optional(),
cursor: UserWhereUniqueInputObjectSchema.optional(),
take: z.number().optional(),
skip: z.number().optional(),
_count: z
.union([z.literal(true), UserCountAggregateInputObjectSchema])
.optional(),
_min: UserMinAggregateInputObjectSchema.optional(),
_max: UserMaxAggregateInputObjectSchema.optional(),
_avg: UserAvgAggregateInputObjectSchema.optional(),
_sum: UserSumAggregateInputObjectSchema.optional(),
});

10
packages/db/shared/schemas/createManyAppointment.schema.ts
View File

@@ -1,10 +0,0 @@
import { z } from 'zod';
import { AppointmentCreateManyInputObjectSchema } from './objects/AppointmentCreateManyInput.schema';
export const AppointmentCreateManySchema = z.object({
data: z.union([
AppointmentCreateManyInputObjectSchema,
z.array(AppointmentCreateManyInputObjectSchema),
]),
skipDuplicates: z.boolean().optional(),
});

10
packages/db/shared/schemas/createManyPatient.schema.ts
View File

@@ -1,10 +0,0 @@
import { z } from 'zod';
import { PatientCreateManyInputObjectSchema } from './objects/PatientCreateManyInput.schema';
export const PatientCreateManySchema = z.object({
data: z.union([
PatientCreateManyInputObjectSchema,
z.array(PatientCreateManyInputObjectSchema),
]),
skipDuplicates: z.boolean().optional(),
});

10
packages/db/shared/schemas/createManyUser.schema.ts
View File

@@ -1,10 +0,0 @@
import { z } from 'zod';
import { UserCreateManyInputObjectSchema } from './objects/UserCreateManyInput.schema';
export const UserCreateManySchema = z.object({
data: z.union([
UserCreateManyInputObjectSchema,
z.array(UserCreateManyInputObjectSchema),
]),
skipDuplicates: z.boolean().optional(),
});

10
packages/db/shared/schemas/createOneAppointment.schema.ts
View File

@@ -1,10 +0,0 @@
import { z } from 'zod';
import { AppointmentCreateInputObjectSchema } from './objects/AppointmentCreateInput.schema';
import { AppointmentUncheckedCreateInputObjectSchema } from './objects/AppointmentUncheckedCreateInput.schema';
export const AppointmentCreateOneSchema = z.object({
data: z.union([
AppointmentCreateInputObjectSchema,
AppointmentUncheckedCreateInputObjectSchema,
]),
});

10
packages/db/shared/schemas/createOnePatient.schema.ts
View File

@@ -1,10 +0,0 @@
import { z } from 'zod';
import { PatientCreateInputObjectSchema } from './objects/PatientCreateInput.schema';
import { PatientUncheckedCreateInputObjectSchema } from './objects/PatientUncheckedCreateInput.schema';
export const PatientCreateOneSchema = z.object({
data: z.union([
PatientCreateInputObjectSchema,
PatientUncheckedCreateInputObjectSchema,
]),
});

10
packages/db/shared/schemas/createOneUser.schema.ts
View File

@@ -1,10 +0,0 @@
import { z } from 'zod';
import { UserCreateInputObjectSchema } from './objects/UserCreateInput.schema';
import { UserUncheckedCreateInputObjectSchema } from './objects/UserUncheckedCreateInput.schema';
export const UserCreateOneSchema = z.object({
data: z.union([
UserCreateInputObjectSchema,
UserUncheckedCreateInputObjectSchema,
]),
});

6
packages/db/shared/schemas/deleteManyAppointment.schema.ts
View File

@@ -1,6 +0,0 @@
import { z } from 'zod';
import { AppointmentWhereInputObjectSchema } from './objects/AppointmentWhereInput.schema';
export const AppointmentDeleteManySchema = z.object({
where: AppointmentWhereInputObjectSchema.optional(),
});

6
packages/db/shared/schemas/deleteManyPatient.schema.ts
View File

@@ -1,6 +0,0 @@
import { z } from 'zod';
import { PatientWhereInputObjectSchema } from './objects/PatientWhereInput.schema';
export const PatientDeleteManySchema = z.object({
where: PatientWhereInputObjectSchema.optional(),
});

6
packages/db/shared/schemas/deleteManyUser.schema.ts
View File

@@ -1,6 +0,0 @@
import { z } from 'zod';
import { UserWhereInputObjectSchema } from './objects/UserWhereInput.schema';
export const UserDeleteManySchema = z.object({
where: UserWhereInputObjectSchema.optional(),
});

6
packages/db/shared/schemas/deleteOneAppointment.schema.ts
View File

@@ -1,6 +0,0 @@
import { z } from 'zod';
import { AppointmentWhereUniqueInputObjectSchema } from './objects/AppointmentWhereUniqueInput.schema';
export const AppointmentDeleteOneSchema = z.object({
where: AppointmentWhereUniqueInputObjectSchema,
});

6
packages/db/shared/schemas/deleteOnePatient.schema.ts
View File

@@ -1,6 +0,0 @@
import { z } from 'zod';
import { PatientWhereUniqueInputObjectSchema } from './objects/PatientWhereUniqueInput.schema';
export const PatientDeleteOneSchema = z.object({
where: PatientWhereUniqueInputObjectSchema,
});

6
packages/db/shared/schemas/deleteOneUser.schema.ts
View File

@@ -1,6 +0,0 @@
import { z } from 'zod';
import { UserWhereUniqueInputObjectSchema } from './objects/UserWhereUniqueInput.schema';
export const UserDeleteOneSchema = z.object({
where: UserWhereUniqueInputObjectSchema,
});

15
packages/db/shared/schemas/enums/AppointmentScalarFieldEnum.schema.ts
View File

@@ -1,15 +0,0 @@
import { z } from 'zod';
export const AppointmentScalarFieldEnumSchema = z.enum([
'id',
'patientId',
'userId',
'title',
'date',
'startTime',
'endTime',
'type',
'notes',
'status',
'createdAt',
]);

3
packages/db/shared/schemas/enums/NullsOrder.schema.ts
View File

@@ -1,3 +0,0 @@
import { z } from 'zod';
export const NullsOrderSchema = z.enum(['first', 'last']);

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

@@ -1,23 +0,0 @@
import { z } from 'zod';
export const PatientScalarFieldEnumSchema = z.enum([
'id',
'firstName',
'lastName',
'dateOfBirth',
'gender',
'phone',
'email',
'address',
'city',
'zipCode',
'insuranceProvider',
'insuranceId',
'groupNumber',
'policyHolder',
'allergies',
'medicalConditions',
'status',
'userId',
'createdAt',
]);

3
packages/db/shared/schemas/enums/QueryMode.schema.ts
View File

@@ -1,3 +0,0 @@
import { z } from 'zod';
export const QueryModeSchema = z.enum(['default', 'insensitive']);

3
packages/db/shared/schemas/enums/SortOrder.schema.ts
View File

@@ -1,3 +0,0 @@
import { z } from 'zod';
export const SortOrderSchema = z.enum(['asc', 'desc']);

8
packages/db/shared/schemas/enums/TransactionIsolationLevel.schema.ts
View File

@@ -1,8 +0,0 @@
import { z } from 'zod';
export const TransactionIsolationLevelSchema = z.enum([
'ReadUncommitted',
'ReadCommitted',
'RepeatableRead',
'Serializable',
]);

3
packages/db/shared/schemas/enums/UserScalarFieldEnum.schema.ts
View File

@@ -1,3 +0,0 @@
import { z } from 'zod';
export const UserScalarFieldEnumSchema = z.enum(['id', 'username', 'password']);

19
packages/db/shared/schemas/findFirstAppointment.schema.ts
View File

@@ -1,19 +0,0 @@
import { z } from 'zod';
import { AppointmentOrderByWithRelationInputObjectSchema } from './objects/AppointmentOrderByWithRelationInput.schema';
import { AppointmentWhereInputObjectSchema } from './objects/AppointmentWhereInput.schema';
import { AppointmentWhereUniqueInputObjectSchema } from './objects/AppointmentWhereUniqueInput.schema';
import { AppointmentScalarFieldEnumSchema } from './enums/AppointmentScalarFieldEnum.schema';
export const AppointmentFindFirstSchema = z.object({
orderBy: z
.union([
AppointmentOrderByWithRelationInputObjectSchema,
AppointmentOrderByWithRelationInputObjectSchema.array(),
])
.optional(),
where: AppointmentWhereInputObjectSchema.optional(),
cursor: AppointmentWhereUniqueInputObjectSchema.optional(),
take: z.number().optional(),
skip: z.number().optional(),
distinct: z.array(AppointmentScalarFieldEnumSchema).optional(),
});

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

@@ -1,19 +0,0 @@
import { z } from 'zod';
import { PatientOrderByWithRelationInputObjectSchema } from './objects/PatientOrderByWithRelationInput.schema';
import { PatientWhereInputObjectSchema } from './objects/PatientWhereInput.schema';
import { PatientWhereUniqueInputObjectSchema } from './objects/PatientWhereUniqueInput.schema';
import { PatientScalarFieldEnumSchema } from './enums/PatientScalarFieldEnum.schema';
export const PatientFindFirstSchema = z.object({
orderBy: z
.union([
PatientOrderByWithRelationInputObjectSchema,
PatientOrderByWithRelationInputObjectSchema.array(),
])
.optional(),
where: PatientWhereInputObjectSchema.optional(),
cursor: PatientWhereUniqueInputObjectSchema.optional(),
take: z.number().optional(),
skip: z.number().optional(),
distinct: z.array(PatientScalarFieldEnumSchema).optional(),
});

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

@@ -1,19 +0,0 @@
import { z } from 'zod';
import { UserOrderByWithRelationInputObjectSchema } from './objects/UserOrderByWithRelationInput.schema';
import { UserWhereInputObjectSchema } from './objects/UserWhereInput.schema';
import { UserWhereUniqueInputObjectSchema } from './objects/UserWhereUniqueInput.schema';
import { UserScalarFieldEnumSchema } from './enums/UserScalarFieldEnum.schema';
export const UserFindFirstSchema = z.object({
orderBy: z
.union([
UserOrderByWithRelationInputObjectSchema,
UserOrderByWithRelationInputObjectSchema.array(),
])
.optional(),
where: UserWhereInputObjectSchema.optional(),
cursor: UserWhereUniqueInputObjectSchema.optional(),
take: z.number().optional(),
skip: z.number().optional(),
distinct: z.array(UserScalarFieldEnumSchema).optional(),
});

19
packages/db/shared/schemas/findManyAppointment.schema.ts
View File

@@ -1,19 +0,0 @@
import { z } from 'zod';
import { AppointmentOrderByWithRelationInputObjectSchema } from './objects/AppointmentOrderByWithRelationInput.schema';
import { AppointmentWhereInputObjectSchema } from './objects/AppointmentWhereInput.schema';
import { AppointmentWhereUniqueInputObjectSchema } from './objects/AppointmentWhereUniqueInput.schema';
import { AppointmentScalarFieldEnumSchema } from './enums/AppointmentScalarFieldEnum.schema';
export const AppointmentFindManySchema = z.object({
orderBy: z
.union([
AppointmentOrderByWithRelationInputObjectSchema,
AppointmentOrderByWithRelationInputObjectSchema.array(),
])
.optional(),
where: AppointmentWhereInputObjectSchema.optional(),
cursor: AppointmentWhereUniqueInputObjectSchema.optional(),
take: z.number().optional(),
skip: z.number().optional(),
distinct: z.array(AppointmentScalarFieldEnumSchema).optional(),
});

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

@@ -1,19 +0,0 @@
import { z } from 'zod';
import { PatientOrderByWithRelationInputObjectSchema } from './objects/PatientOrderByWithRelationInput.schema';
import { PatientWhereInputObjectSchema } from './objects/PatientWhereInput.schema';
import { PatientWhereUniqueInputObjectSchema } from './objects/PatientWhereUniqueInput.schema';
import { PatientScalarFieldEnumSchema } from './enums/PatientScalarFieldEnum.schema';
export const PatientFindManySchema = z.object({
orderBy: z
.union([
PatientOrderByWithRelationInputObjectSchema,
PatientOrderByWithRelationInputObjectSchema.array(),
])
.optional(),
where: PatientWhereInputObjectSchema.optional(),
cursor: PatientWhereUniqueInputObjectSchema.optional(),
take: z.number().optional(),
skip: z.number().optional(),
distinct: z.array(PatientScalarFieldEnumSchema).optional(),
});

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

@@ -1,19 +0,0 @@
import { z } from 'zod';
import { UserOrderByWithRelationInputObjectSchema } from './objects/UserOrderByWithRelationInput.schema';
import { UserWhereInputObjectSchema } from './objects/UserWhereInput.schema';
import { UserWhereUniqueInputObjectSchema } from './objects/UserWhereUniqueInput.schema';
import { UserScalarFieldEnumSchema } from './enums/UserScalarFieldEnum.schema';
export const UserFindManySchema = z.object({
orderBy: z
.union([
UserOrderByWithRelationInputObjectSchema,
UserOrderByWithRelationInputObjectSchema.array(),
])
.optional(),
where: UserWhereInputObjectSchema.optional(),
cursor: UserWhereUniqueInputObjectSchema.optional(),
take: z.number().optional(),
skip: z.number().optional(),
distinct: z.array(UserScalarFieldEnumSchema).optional(),
});

6
packages/db/shared/schemas/findUniqueAppointment.schema.ts
View File

@@ -1,6 +0,0 @@
import { z } from 'zod';
import { AppointmentWhereUniqueInputObjectSchema } from './objects/AppointmentWhereUniqueInput.schema';
export const AppointmentFindUniqueSchema = z.object({
where: AppointmentWhereUniqueInputObjectSchema,
});

6
packages/db/shared/schemas/findUniquePatient.schema.ts
View File

@@ -1,6 +0,0 @@
import { z } from 'zod';
import { PatientWhereUniqueInputObjectSchema } from './objects/PatientWhereUniqueInput.schema';
export const PatientFindUniqueSchema = z.object({
where: PatientWhereUniqueInputObjectSchema,
});

6
packages/db/shared/schemas/findUniqueUser.schema.ts
View File

@@ -1,6 +0,0 @@
import { z } from 'zod';
import { UserWhereUniqueInputObjectSchema } from './objects/UserWhereUniqueInput.schema';
export const UserFindUniqueSchema = z.object({
where: UserWhereUniqueInputObjectSchema,
});

19
packages/db/shared/schemas/groupByAppointment.schema.ts
View File

@@ -1,19 +0,0 @@
import { z } from 'zod';
import { AppointmentWhereInputObjectSchema } from './objects/AppointmentWhereInput.schema';
import { AppointmentOrderByWithAggregationInputObjectSchema } from './objects/AppointmentOrderByWithAggregationInput.schema';
import { AppointmentScalarWhereWithAggregatesInputObjectSchema } from './objects/AppointmentScalarWhereWithAggregatesInput.schema';
import { AppointmentScalarFieldEnumSchema } from './enums/AppointmentScalarFieldEnum.schema';
export const AppointmentGroupBySchema = z.object({
where: AppointmentWhereInputObjectSchema.optional(),
orderBy: z
.union([
AppointmentOrderByWithAggregationInputObjectSchema,
AppointmentOrderByWithAggregationInputObjectSchema.array(),
])
.optional(),
having: AppointmentScalarWhereWithAggregatesInputObjectSchema.optional(),
take: z.number().optional(),
skip: z.number().optional(),
by: z.array(AppointmentScalarFieldEnumSchema),
});

19
packages/db/shared/schemas/groupByPatient.schema.ts
View File

@@ -1,19 +0,0 @@
import { z } from 'zod';
import { PatientWhereInputObjectSchema } from './objects/PatientWhereInput.schema';
import { PatientOrderByWithAggregationInputObjectSchema } from './objects/PatientOrderByWithAggregationInput.schema';
import { PatientScalarWhereWithAggregatesInputObjectSchema } from './objects/PatientScalarWhereWithAggregatesInput.schema';
import { PatientScalarFieldEnumSchema } from './enums/PatientScalarFieldEnum.schema';
export const PatientGroupBySchema = z.object({
where: PatientWhereInputObjectSchema.optional(),
orderBy: z
.union([
PatientOrderByWithAggregationInputObjectSchema,
PatientOrderByWithAggregationInputObjectSchema.array(),
])
.optional(),
having: PatientScalarWhereWithAggregatesInputObjectSchema.optional(),
take: z.number().optional(),
skip: z.number().optional(),
by: z.array(PatientScalarFieldEnumSchema),
});

19
packages/db/shared/schemas/groupByUser.schema.ts
View File

@@ -1,19 +0,0 @@
import { z } from 'zod';
import { UserWhereInputObjectSchema } from './objects/UserWhereInput.schema';
import { UserOrderByWithAggregationInputObjectSchema } from './objects/UserOrderByWithAggregationInput.schema';
import { UserScalarWhereWithAggregatesInputObjectSchema } from './objects/UserScalarWhereWithAggregatesInput.schema';
import { UserScalarFieldEnumSchema } from './enums/UserScalarFieldEnum.schema';
export const UserGroupBySchema = z.object({
where: UserWhereInputObjectSchema.optional(),
orderBy: z
.union([
UserOrderByWithAggregationInputObjectSchema,
UserOrderByWithAggregationInputObjectSchema.array(),
])
.optional(),
having: UserScalarWhereWithAggregatesInputObjectSchema.optional(),
take: z.number().optional(),
skip: z.number().optional(),
by: z.array(UserScalarFieldEnumSchema),
});

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

@@ -1,208 +0,0 @@
export * from './enums/TransactionIsolationLevel.schema';
export * from './enums/UserScalarFieldEnum.schema';
export * from './enums/PatientScalarFieldEnum.schema';
export * from './enums/AppointmentScalarFieldEnum.schema';
export * from './enums/SortOrder.schema';
export * from './enums/QueryMode.schema';
export * from './enums/NullsOrder.schema';
export * from './objects/UserWhereInput.schema';
export * from './objects/UserOrderByWithRelationInput.schema';
export * from './objects/UserWhereUniqueInput.schema';
export * from './objects/UserOrderByWithAggregationInput.schema';
export * from './objects/UserScalarWhereWithAggregatesInput.schema';
export * from './objects/PatientWhereInput.schema';
export * from './objects/PatientOrderByWithRelationInput.schema';
export * from './objects/PatientWhereUniqueInput.schema';
export * from './objects/PatientOrderByWithAggregationInput.schema';
export * from './objects/PatientScalarWhereWithAggregatesInput.schema';
export * from './objects/AppointmentWhereInput.schema';
export * from './objects/AppointmentOrderByWithRelationInput.schema';
export * from './objects/AppointmentWhereUniqueInput.schema';
export * from './objects/AppointmentOrderByWithAggregationInput.schema';
export * from './objects/AppointmentScalarWhereWithAggregatesInput.schema';
export * from './objects/UserCreateInput.schema';
export * from './objects/UserUncheckedCreateInput.schema';
export * from './objects/UserUpdateInput.schema';
export * from './objects/UserUncheckedUpdateInput.schema';
export * from './objects/UserCreateManyInput.schema';
export * from './objects/UserUpdateManyMutationInput.schema';
export * from './objects/UserUncheckedUpdateManyInput.schema';
export * from './objects/PatientCreateInput.schema';
export * from './objects/PatientUncheckedCreateInput.schema';
export * from './objects/PatientUpdateInput.schema';
export * from './objects/PatientUncheckedUpdateInput.schema';
export * from './objects/PatientCreateManyInput.schema';
export * from './objects/PatientUpdateManyMutationInput.schema';
export * from './objects/PatientUncheckedUpdateManyInput.schema';
export * from './objects/AppointmentCreateInput.schema';
export * from './objects/AppointmentUncheckedCreateInput.schema';
export * from './objects/AppointmentUpdateInput.schema';
export * from './objects/AppointmentUncheckedUpdateInput.schema';
export * from './objects/AppointmentCreateManyInput.schema';
export * from './objects/AppointmentUpdateManyMutationInput.schema';
export * from './objects/AppointmentUncheckedUpdateManyInput.schema';
export * from './objects/IntFilter.schema';
export * from './objects/StringFilter.schema';
export * from './objects/PatientListRelationFilter.schema';
export * from './objects/AppointmentListRelationFilter.schema';
export * from './objects/PatientOrderByRelationAggregateInput.schema';
export * from './objects/AppointmentOrderByRelationAggregateInput.schema';
export * from './objects/UserCountOrderByAggregateInput.schema';
export * from './objects/UserAvgOrderByAggregateInput.schema';
export * from './objects/UserMaxOrderByAggregateInput.schema';
export * from './objects/UserMinOrderByAggregateInput.schema';
export * from './objects/UserSumOrderByAggregateInput.schema';
export * from './objects/IntWithAggregatesFilter.schema';
export * from './objects/StringWithAggregatesFilter.schema';
export * from './objects/DateTimeFilter.schema';
export * from './objects/StringNullableFilter.schema';
export * from './objects/UserRelationFilter.schema';
export * from './objects/SortOrderInput.schema';
export * from './objects/PatientCountOrderByAggregateInput.schema';
export * from './objects/PatientAvgOrderByAggregateInput.schema';
export * from './objects/PatientMaxOrderByAggregateInput.schema';
export * from './objects/PatientMinOrderByAggregateInput.schema';
export * from './objects/PatientSumOrderByAggregateInput.schema';
export * from './objects/DateTimeWithAggregatesFilter.schema';
export * from './objects/StringNullableWithAggregatesFilter.schema';
export * from './objects/PatientRelationFilter.schema';
export * from './objects/AppointmentCountOrderByAggregateInput.schema';
export * from './objects/AppointmentAvgOrderByAggregateInput.schema';
export * from './objects/AppointmentMaxOrderByAggregateInput.schema';
export * from './objects/AppointmentMinOrderByAggregateInput.schema';
export * from './objects/AppointmentSumOrderByAggregateInput.schema';
export * from './objects/PatientCreateNestedManyWithoutUserInput.schema';
export * from './objects/AppointmentCreateNestedManyWithoutUserInput.schema';
export * from './objects/PatientUncheckedCreateNestedManyWithoutUserInput.schema';
export * from './objects/AppointmentUncheckedCreateNestedManyWithoutUserInput.schema';
export * from './objects/StringFieldUpdateOperationsInput.schema';
export * from './objects/PatientUpdateManyWithoutUserNestedInput.schema';
export * from './objects/AppointmentUpdateManyWithoutUserNestedInput.schema';
export * from './objects/IntFieldUpdateOperationsInput.schema';
export * from './objects/PatientUncheckedUpdateManyWithoutUserNestedInput.schema';
export * from './objects/AppointmentUncheckedUpdateManyWithoutUserNestedInput.schema';
export * from './objects/UserCreateNestedOneWithoutPatientsInput.schema';
export * from './objects/AppointmentCreateNestedManyWithoutPatientInput.schema';
export * from './objects/AppointmentUncheckedCreateNestedManyWithoutPatientInput.schema';
export * from './objects/DateTimeFieldUpdateOperationsInput.schema';
export * from './objects/NullableStringFieldUpdateOperationsInput.schema';
export * from './objects/UserUpdateOneRequiredWithoutPatientsNestedInput.schema';
export * from './objects/AppointmentUpdateManyWithoutPatientNestedInput.schema';
export * from './objects/AppointmentUncheckedUpdateManyWithoutPatientNestedInput.schema';
export * from './objects/PatientCreateNestedOneWithoutAppointmentsInput.schema';
export * from './objects/UserCreateNestedOneWithoutAppointmentsInput.schema';
export * from './objects/PatientUpdateOneRequiredWithoutAppointmentsNestedInput.schema';
export * from './objects/UserUpdateOneRequiredWithoutAppointmentsNestedInput.schema';
export * from './objects/NestedIntFilter.schema';
export * from './objects/NestedStringFilter.schema';
export * from './objects/NestedIntWithAggregatesFilter.schema';
export * from './objects/NestedFloatFilter.schema';
export * from './objects/NestedStringWithAggregatesFilter.schema';
export * from './objects/NestedDateTimeFilter.schema';
export * from './objects/NestedStringNullableFilter.schema';
export * from './objects/NestedDateTimeWithAggregatesFilter.schema';
export * from './objects/NestedStringNullableWithAggregatesFilter.schema';
export * from './objects/NestedIntNullableFilter.schema';
export * from './objects/PatientCreateWithoutUserInput.schema';
export * from './objects/PatientUncheckedCreateWithoutUserInput.schema';
export * from './objects/PatientCreateOrConnectWithoutUserInput.schema';
export * from './objects/PatientCreateManyUserInputEnvelope.schema';
export * from './objects/AppointmentCreateWithoutUserInput.schema';
export * from './objects/AppointmentUncheckedCreateWithoutUserInput.schema';
export * from './objects/AppointmentCreateOrConnectWithoutUserInput.schema';
export * from './objects/AppointmentCreateManyUserInputEnvelope.schema';
export * from './objects/PatientUpsertWithWhereUniqueWithoutUserInput.schema';
export * from './objects/PatientUpdateWithWhereUniqueWithoutUserInput.schema';
export * from './objects/PatientUpdateManyWithWhereWithoutUserInput.schema';
export * from './objects/PatientScalarWhereInput.schema';
export * from './objects/AppointmentUpsertWithWhereUniqueWithoutUserInput.schema';
export * from './objects/AppointmentUpdateWithWhereUniqueWithoutUserInput.schema';
export * from './objects/AppointmentUpdateManyWithWhereWithoutUserInput.schema';
export * from './objects/AppointmentScalarWhereInput.schema';
export * from './objects/UserCreateWithoutPatientsInput.schema';
export * from './objects/UserUncheckedCreateWithoutPatientsInput.schema';
export * from './objects/UserCreateOrConnectWithoutPatientsInput.schema';
export * from './objects/AppointmentCreateWithoutPatientInput.schema';
export * from './objects/AppointmentUncheckedCreateWithoutPatientInput.schema';
export * from './objects/AppointmentCreateOrConnectWithoutPatientInput.schema';
export * from './objects/AppointmentCreateManyPatientInputEnvelope.schema';
export * from './objects/UserUpsertWithoutPatientsInput.schema';
export * from './objects/UserUpdateWithoutPatientsInput.schema';
export * from './objects/UserUncheckedUpdateWithoutPatientsInput.schema';
export * from './objects/AppointmentUpsertWithWhereUniqueWithoutPatientInput.schema';
export * from './objects/AppointmentUpdateWithWhereUniqueWithoutPatientInput.schema';
export * from './objects/AppointmentUpdateManyWithWhereWithoutPatientInput.schema';
export * from './objects/PatientCreateWithoutAppointmentsInput.schema';
export * from './objects/PatientUncheckedCreateWithoutAppointmentsInput.schema';
export * from './objects/PatientCreateOrConnectWithoutAppointmentsInput.schema';
export * from './objects/UserCreateWithoutAppointmentsInput.schema';
export * from './objects/UserUncheckedCreateWithoutAppointmentsInput.schema';
export * from './objects/UserCreateOrConnectWithoutAppointmentsInput.schema';
export * from './objects/PatientUpsertWithoutAppointmentsInput.schema';
export * from './objects/PatientUpdateWithoutAppointmentsInput.schema';
export * from './objects/PatientUncheckedUpdateWithoutAppointmentsInput.schema';
export * from './objects/UserUpsertWithoutAppointmentsInput.schema';
export * from './objects/UserUpdateWithoutAppointmentsInput.schema';
export * from './objects/UserUncheckedUpdateWithoutAppointmentsInput.schema';
export * from './objects/PatientCreateManyUserInput.schema';
export * from './objects/AppointmentCreateManyUserInput.schema';
export * from './objects/PatientUpdateWithoutUserInput.schema';
export * from './objects/PatientUncheckedUpdateWithoutUserInput.schema';
export * from './objects/PatientUncheckedUpdateManyWithoutPatientsInput.schema';
export * from './objects/AppointmentUpdateWithoutUserInput.schema';
export * from './objects/AppointmentUncheckedUpdateWithoutUserInput.schema';
export * from './objects/AppointmentUncheckedUpdateManyWithoutAppointmentsInput.schema';
export * from './objects/AppointmentCreateManyPatientInput.schema';
export * from './objects/AppointmentUpdateWithoutPatientInput.schema';
export * from './objects/AppointmentUncheckedUpdateWithoutPatientInput.schema';
export * from './objects/UserCountAggregateInput.schema';
export * from './objects/UserAvgAggregateInput.schema';
export * from './objects/UserSumAggregateInput.schema';
export * from './objects/UserMinAggregateInput.schema';
export * from './objects/UserMaxAggregateInput.schema';
export * from './objects/PatientCountAggregateInput.schema';
export * from './objects/PatientAvgAggregateInput.schema';
export * from './objects/PatientSumAggregateInput.schema';
export * from './objects/PatientMinAggregateInput.schema';
export * from './objects/PatientMaxAggregateInput.schema';
export * from './objects/AppointmentCountAggregateInput.schema';
export * from './objects/AppointmentAvgAggregateInput.schema';
export * from './objects/AppointmentSumAggregateInput.schema';
export * from './objects/AppointmentMinAggregateInput.schema';
export * from './objects/AppointmentMaxAggregateInput.schema';
export * from './findUniqueUser.schema';
export * from './findFirstUser.schema';
export * from './findManyUser.schema';
export * from './createOneUser.schema';
export * from './createManyUser.schema';
export * from './deleteOneUser.schema';
export * from './deleteManyUser.schema';
export * from './updateOneUser.schema';
export * from './updateManyUser.schema';
export * from './upsertOneUser.schema';
export * from './aggregateUser.schema';
export * from './groupByUser.schema';
export * from './findUniquePatient.schema';
export * from './findFirstPatient.schema';
export * from './findManyPatient.schema';
export * from './createOnePatient.schema';
export * from './createManyPatient.schema';
export * from './deleteOnePatient.schema';
export * from './deleteManyPatient.schema';
export * from './updateOnePatient.schema';
export * from './updateManyPatient.schema';
export * from './upsertOnePatient.schema';
export * from './aggregatePatient.schema';
export * from './groupByPatient.schema';
export * from './findUniqueAppointment.schema';
export * from './findFirstAppointment.schema';
export * from './findManyAppointment.schema';
export * from './createOneAppointment.schema';
export * from './createManyAppointment.schema';
export * from './deleteOneAppointment.schema';
export * from './deleteManyAppointment.schema';
export * from './updateOneAppointment.schema';
export * from './updateManyAppointment.schema';
export * from './upsertOneAppointment.schema';
export * from './aggregateAppointment.schema';
export * from './groupByAppointment.schema';

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

@@ -1,13 +0,0 @@
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
View File

@@ -1,14 +0,0 @@
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
View File

@@ -1,22 +0,0 @@
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
View File

@@ -1,22 +0,0 @@
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
View File

@@ -1,24 +0,0 @@
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
View File

@@ -1,21 +0,0 @@
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
View File

@@ -1,20 +0,0 @@
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
View File

@@ -1,16 +0,0 @@
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
View File

@@ -1,20 +0,0 @@
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
View File

@@ -1,16 +0,0 @@
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
View File

@@ -1,54 +0,0 @@
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
View File

@@ -1,42 +0,0 @@
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
View File

@@ -1,19 +0,0 @@
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
View File

@@ -1,18 +0,0 @@
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
View File

@@ -1,20 +0,0 @@
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
View File

@@ -1,22 +0,0 @@
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
View File

@@ -1,14 +0,0 @@
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
View File

@@ -1,21 +0,0 @@
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
View File

@@ -1,22 +0,0 @@
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
View File

@@ -1,21 +0,0 @@
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
View File

@@ -1,22 +0,0 @@
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
View File

@@ -1,12 +0,0 @@
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
View File

@@ -1,48 +0,0 @@
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
View File

@@ -1,34 +0,0 @@
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
View File

@@ -1,62 +0,0 @@
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
View File

@@ -1,83 +0,0 @@
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
View File

@@ -1,13 +0,0 @@
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
View File

@@ -1,14 +0,0 @@
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
View File

@@ -1,21 +0,0 @@
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
View File

@@ -1,54 +0,0 @@
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
View File

@@ -1,44 +0,0 @@
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
View File

@@ -1,21 +0,0 @@
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
View File

@@ -1,20 +0,0 @@
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
View File

@@ -1,81 +0,0 @@
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
View File

@@ -1,81 +0,0 @@
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
View File

@@ -1,77 +0,0 @@
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
View File

@@ -1,123 +0,0 @@
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
View File

@@ -1,110 +0,0 @@
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
View File

@@ -1,76 +0,0 @@
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
View File

@@ -1,75 +0,0 @@
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
View File

@@ -1,75 +0,0 @@
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
View File

@@ -1,62 +0,0 @@
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
View File

@@ -1,23 +0,0 @@
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
View File

@@ -1,23 +0,0 @@
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
View File

@@ -1,123 +0,0 @@
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
View File

@@ -1,106 +0,0 @@
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
View File

@@ -1,20 +0,0 @@
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
View File

@@ -1,20 +0,0 @@
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
View File

@@ -1,68 +0,0 @@
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
View File

@@ -1,69 +0,0 @@
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
View File

@@ -1,26 +0,0 @@
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
View File

@@ -1,26 +0,0 @@
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
View File

@@ -1,78 +0,0 @@
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
View File

@@ -1,11 +0,0 @@
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
View File

@@ -1,11 +0,0 @@
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
View File

@@ -1,21 +0,0 @@
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
View File

@@ -1,29 +0,0 @@
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
View File

@@ -1,15 +0,0 @@
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
View File

@@ -1,21 +0,0 @@
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
View File

@@ -1,31 +0,0 @@
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
View File

@@ -1,20 +0,0 @@
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
View File

@@ -1,28 +0,0 @@
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
View File

@@ -1,20 +0,0 @@
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
View File

@@ -1,20 +0,0 @@
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
View File

@@ -1,21 +0,0 @@
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;

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