first commit

packages/db/shared/schemas/aggregateAppointment.schema.ts

@@ -0,0 +1,29 @@
+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(),
+});

packages/db/shared/schemas/aggregatePatient.schema.ts

@@ -0,0 +1,29 @@
+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(),
+});

packages/db/shared/schemas/aggregateUser.schema.ts

@@ -0,0 +1,29 @@
+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(),
+});

packages/db/shared/schemas/createManyAppointment.schema.ts

@@ -0,0 +1,10 @@
+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(),
+});

packages/db/shared/schemas/createManyPatient.schema.ts

@@ -0,0 +1,10 @@
+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(),
+});

packages/db/shared/schemas/createManyUser.schema.ts

@@ -0,0 +1,10 @@
+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(),
+});

packages/db/shared/schemas/createOneAppointment.schema.ts

@@ -0,0 +1,10 @@
+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,
+  ]),
+});

packages/db/shared/schemas/createOnePatient.schema.ts

@@ -0,0 +1,10 @@
+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,
+  ]),
+});

packages/db/shared/schemas/createOneUser.schema.ts

@@ -0,0 +1,10 @@
+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,
+  ]),
+});

packages/db/shared/schemas/deleteManyAppointment.schema.ts

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

packages/db/shared/schemas/deleteManyPatient.schema.ts

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

packages/db/shared/schemas/deleteManyUser.schema.ts

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

packages/db/shared/schemas/deleteOneAppointment.schema.ts

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

packages/db/shared/schemas/deleteOnePatient.schema.ts

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

packages/db/shared/schemas/deleteOneUser.schema.ts

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

packages/db/shared/schemas/enums/AppointmentScalarFieldEnum.schema.ts

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

packages/db/shared/schemas/enums/NullsOrder.schema.ts

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

packages/db/shared/schemas/enums/PatientScalarFieldEnum.schema.ts

@@ -0,0 +1,23 @@
+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',
+]);

packages/db/shared/schemas/enums/QueryMode.schema.ts

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

packages/db/shared/schemas/enums/SortOrder.schema.ts

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

packages/db/shared/schemas/enums/TransactionIsolationLevel.schema.ts

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

packages/db/shared/schemas/enums/UserScalarFieldEnum.schema.ts

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

packages/db/shared/schemas/findFirstAppointment.schema.ts

@@ -0,0 +1,19 @@
+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(),
+});

packages/db/shared/schemas/findFirstPatient.schema.ts

@@ -0,0 +1,19 @@
+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(),
+});

packages/db/shared/schemas/findFirstUser.schema.ts

@@ -0,0 +1,19 @@
+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(),
+});

packages/db/shared/schemas/findManyAppointment.schema.ts

@@ -0,0 +1,19 @@
+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(),
+});

packages/db/shared/schemas/findManyPatient.schema.ts

@@ -0,0 +1,19 @@
+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(),
+});

packages/db/shared/schemas/findManyUser.schema.ts

@@ -0,0 +1,19 @@
+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(),
+});

packages/db/shared/schemas/findUniqueAppointment.schema.ts

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

packages/db/shared/schemas/findUniquePatient.schema.ts

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

packages/db/shared/schemas/findUniqueUser.schema.ts

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

packages/db/shared/schemas/groupByAppointment.schema.ts

@@ -0,0 +1,19 @@
+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),
+});

packages/db/shared/schemas/groupByPatient.schema.ts

@@ -0,0 +1,19 @@
+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),
+});

packages/db/shared/schemas/groupByUser.schema.ts

@@ -0,0 +1,19 @@
+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),
+});

packages/db/shared/schemas/index.ts

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

packages/db/shared/schemas/objects/AppointmentAvgAggregateInput.schema.ts

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

packages/db/shared/schemas/objects/AppointmentAvgOrderByAggregateInput.schema.ts

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

packages/db/shared/schemas/objects/AppointmentCountAggregateInput.schema.ts

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

packages/db/shared/schemas/objects/AppointmentCountOrderByAggregateInput.schema.ts

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

packages/db/shared/schemas/objects/AppointmentCreateInput.schema.ts

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

packages/db/shared/schemas/objects/AppointmentCreateManyInput.schema.ts

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

packages/db/shared/schemas/objects/AppointmentCreateManyPatientInput.schema.ts

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

packages/db/shared/schemas/objects/AppointmentCreateManyPatientInputEnvelope.schema.ts

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

packages/db/shared/schemas/objects/AppointmentCreateManyUserInput.schema.ts

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

packages/db/shared/schemas/objects/AppointmentCreateManyUserInputEnvelope.schema.ts

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

packages/db/shared/schemas/objects/AppointmentCreateNestedManyWithoutPatientInput.schema.ts

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

packages/db/shared/schemas/objects/AppointmentCreateNestedManyWithoutUserInput.schema.ts

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

packages/db/shared/schemas/objects/AppointmentCreateOrConnectWithoutPatientInput.schema.ts

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

packages/db/shared/schemas/objects/AppointmentCreateOrConnectWithoutUserInput.schema.ts

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

packages/db/shared/schemas/objects/AppointmentCreateWithoutPatientInput.schema.ts

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

packages/db/shared/schemas/objects/AppointmentCreateWithoutUserInput.schema.ts

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

packages/db/shared/schemas/objects/AppointmentListRelationFilter.schema.ts

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

packages/db/shared/schemas/objects/AppointmentMaxAggregateInput.schema.ts

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

packages/db/shared/schemas/objects/AppointmentMaxOrderByAggregateInput.schema.ts

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

packages/db/shared/schemas/objects/AppointmentMinAggregateInput.schema.ts

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

packages/db/shared/schemas/objects/AppointmentMinOrderByAggregateInput.schema.ts

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

packages/db/shared/schemas/objects/AppointmentOrderByRelationAggregateInput.schema.ts

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

packages/db/shared/schemas/objects/AppointmentOrderByWithAggregationInput.schema.ts

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

packages/db/shared/schemas/objects/AppointmentOrderByWithRelationInput.schema.ts

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

packages/db/shared/schemas/objects/AppointmentScalarWhereInput.schema.ts

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

packages/db/shared/schemas/objects/AppointmentScalarWhereWithAggregatesInput.schema.ts

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

packages/db/shared/schemas/objects/AppointmentSumAggregateInput.schema.ts

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

packages/db/shared/schemas/objects/AppointmentSumOrderByAggregateInput.schema.ts

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

packages/db/shared/schemas/objects/AppointmentUncheckedCreateInput.schema.ts

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

packages/db/shared/schemas/objects/AppointmentUncheckedCreateNestedManyWithoutPatientInput.schema.ts

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

packages/db/shared/schemas/objects/AppointmentUncheckedCreateNestedManyWithoutUserInput.schema.ts

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

packages/db/shared/schemas/objects/AppointmentUncheckedCreateWithoutPatientInput.schema.ts

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

packages/db/shared/schemas/objects/AppointmentUncheckedCreateWithoutUserInput.schema.ts

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

packages/db/shared/schemas/objects/AppointmentUncheckedUpdateInput.schema.ts

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

packages/db/shared/schemas/objects/AppointmentUncheckedUpdateManyInput.schema.ts

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

packages/db/shared/schemas/objects/AppointmentUncheckedUpdateManyWithoutAppointmentsInput.schema.ts

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

packages/db/shared/schemas/objects/AppointmentUncheckedUpdateManyWithoutPatientNestedInput.schema.ts

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

packages/db/shared/schemas/objects/AppointmentUncheckedUpdateManyWithoutUserNestedInput.schema.ts

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

packages/db/shared/schemas/objects/AppointmentUncheckedUpdateWithoutPatientInput.schema.ts

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

packages/db/shared/schemas/objects/AppointmentUncheckedUpdateWithoutUserInput.schema.ts

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

packages/db/shared/schemas/objects/AppointmentUpdateInput.schema.ts

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

packages/db/shared/schemas/objects/AppointmentUpdateManyMutationInput.schema.ts

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

packages/db/shared/schemas/objects/AppointmentUpdateManyWithWhereWithoutPatientInput.schema.ts

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

packages/db/shared/schemas/objects/AppointmentUpdateManyWithWhereWithoutUserInput.schema.ts

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

packages/db/shared/schemas/objects/AppointmentUpdateManyWithoutPatientNestedInput.schema.ts

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

packages/db/shared/schemas/objects/AppointmentUpdateManyWithoutUserNestedInput.schema.ts

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

packages/db/shared/schemas/objects/AppointmentUpdateWithWhereUniqueWithoutPatientInput.schema.ts

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

packages/db/shared/schemas/objects/AppointmentUpdateWithWhereUniqueWithoutUserInput.schema.ts

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

packages/db/shared/schemas/objects/AppointmentUpdateWithoutPatientInput.schema.ts

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

packages/db/shared/schemas/objects/AppointmentUpdateWithoutUserInput.schema.ts

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

packages/db/shared/schemas/objects/AppointmentUpsertWithWhereUniqueWithoutPatientInput.schema.ts

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

packages/db/shared/schemas/objects/AppointmentUpsertWithWhereUniqueWithoutUserInput.schema.ts

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

packages/db/shared/schemas/objects/AppointmentWhereInput.schema.ts

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

packages/db/shared/schemas/objects/AppointmentWhereUniqueInput.schema.ts

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

packages/db/shared/schemas/objects/DateTimeFieldUpdateOperationsInput.schema.ts

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

packages/db/shared/schemas/objects/DateTimeFilter.schema.ts

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

packages/db/shared/schemas/objects/DateTimeWithAggregatesFilter.schema.ts

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

packages/db/shared/schemas/objects/IntFieldUpdateOperationsInput.schema.ts

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

packages/db/shared/schemas/objects/IntFilter.schema.ts

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

packages/db/shared/schemas/objects/IntWithAggregatesFilter.schema.ts

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

packages/db/shared/schemas/objects/NestedDateTimeFilter.schema.ts

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

packages/db/shared/schemas/objects/NestedDateTimeWithAggregatesFilter.schema.ts

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

packages/db/shared/schemas/objects/NestedFloatFilter.schema.ts

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

packages/db/shared/schemas/objects/NestedIntFilter.schema.ts

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

packages/db/shared/schemas/objects/NestedIntNullableFilter.schema.ts

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