initial commit

packages/db/shared/schemas/objects/AppointmentArgs.schema.d.ts

@@ -0,0 +1,23 @@
+import * as z from 'zod';
+import type { Prisma } from '../../../generated/prisma';
+export declare const AppointmentArgsObjectSchema: z.ZodObject<{
+    select: z.ZodOptional<z.ZodLazy<z.ZodType<Prisma.AppointmentSelect<import("../../../generated/prisma/runtime/client").DefaultArgs>, z.ZodTypeDef, Prisma.AppointmentSelect<import("../../../generated/prisma/runtime/client").DefaultArgs>>>>;
+    include: z.ZodOptional<z.ZodLazy<z.ZodType<Prisma.AppointmentInclude<import("../../../generated/prisma/runtime/client").DefaultArgs>, z.ZodTypeDef, Prisma.AppointmentInclude<import("../../../generated/prisma/runtime/client").DefaultArgs>>>>;
+}, "strict", z.ZodTypeAny, {
+    include?: Prisma.AppointmentInclude<import("../../../generated/prisma/runtime/client").DefaultArgs> | undefined;
+    select?: Prisma.AppointmentSelect<import("../../../generated/prisma/runtime/client").DefaultArgs> | undefined;
+}, {
+    include?: Prisma.AppointmentInclude<import("../../../generated/prisma/runtime/client").DefaultArgs> | undefined;
+    select?: Prisma.AppointmentSelect<import("../../../generated/prisma/runtime/client").DefaultArgs> | undefined;
+}>;
+export declare const AppointmentArgsObjectZodSchema: z.ZodObject<{
+    select: z.ZodOptional<z.ZodLazy<z.ZodType<Prisma.AppointmentSelect<import("../../../generated/prisma/runtime/client").DefaultArgs>, z.ZodTypeDef, Prisma.AppointmentSelect<import("../../../generated/prisma/runtime/client").DefaultArgs>>>>;
+    include: z.ZodOptional<z.ZodLazy<z.ZodType<Prisma.AppointmentInclude<import("../../../generated/prisma/runtime/client").DefaultArgs>, z.ZodTypeDef, Prisma.AppointmentInclude<import("../../../generated/prisma/runtime/client").DefaultArgs>>>>;
+}, "strict", z.ZodTypeAny, {
+    include?: Prisma.AppointmentInclude<import("../../../generated/prisma/runtime/client").DefaultArgs> | undefined;
+    select?: Prisma.AppointmentSelect<import("../../../generated/prisma/runtime/client").DefaultArgs> | undefined;
+}, {
+    include?: Prisma.AppointmentInclude<import("../../../generated/prisma/runtime/client").DefaultArgs> | undefined;
+    select?: Prisma.AppointmentSelect<import("../../../generated/prisma/runtime/client").DefaultArgs> | undefined;
+}>;
+//# sourceMappingURL=AppointmentArgs.schema.d.ts.map

packages/db/shared/schemas/objects/AppointmentArgs.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AppointmentArgs.schema.d.ts","sourceRoot":"","sources":["AppointmentArgs.schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AACzB,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,2BAA2B,CAAC;AAQxD,eAAO,MAAM,2BAA2B;;;;;;;;;EAAe,CAAC;AACxD,eAAO,MAAM,8BAA8B;;;;;;;;;EAAe,CAAC"}

packages/db/shared/schemas/objects/AppointmentArgs.schema.js

@@ -0,0 +1,45 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppointmentArgsObjectZodSchema = exports.AppointmentArgsObjectSchema = void 0;
+const z = __importStar(require("zod"));
+const AppointmentSelect_schema_1 = require("./AppointmentSelect.schema");
+const AppointmentInclude_schema_1 = require("./AppointmentInclude.schema");
+const makeSchema = () => z.object({
+    select: z.lazy(() => AppointmentSelect_schema_1.AppointmentSelectObjectSchema).optional(),
+    include: z.lazy(() => AppointmentInclude_schema_1.AppointmentIncludeObjectSchema).optional()
+}).strict();
+exports.AppointmentArgsObjectSchema = makeSchema();
+exports.AppointmentArgsObjectZodSchema = makeSchema();

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

@@ -0,0 +1,11 @@
+import * as z from 'zod';
+import type { Prisma } from '../../../generated/prisma';
+import { AppointmentSelectObjectSchema as AppointmentSelectObjectSchema } from './AppointmentSelect.schema';
+import { AppointmentIncludeObjectSchema as AppointmentIncludeObjectSchema } from './AppointmentInclude.schema'
+
+const makeSchema = () => z.object({
+  select: z.lazy(() => AppointmentSelectObjectSchema).optional(),
+  include: z.lazy(() => AppointmentIncludeObjectSchema).optional()
+}).strict();
+export const AppointmentArgsObjectSchema = makeSchema();
+export const AppointmentArgsObjectZodSchema = makeSchema();

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

@@ -0,0 +1,20 @@
+import * as z from 'zod';
+import type { Prisma } from '../../../generated/prisma';
+export declare const AppointmentAvgAggregateInputObjectSchema: z.ZodType<Prisma.AppointmentAvgAggregateInputType>;
+export declare const AppointmentAvgAggregateInputObjectZodSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodLiteral<true>>;
+    patientId: z.ZodOptional<z.ZodLiteral<true>>;
+    userId: z.ZodOptional<z.ZodLiteral<true>>;
+    staffId: z.ZodOptional<z.ZodLiteral<true>>;
+}, "strict", z.ZodTypeAny, {
+    id?: true | undefined;
+    userId?: true | undefined;
+    patientId?: true | undefined;
+    staffId?: true | undefined;
+}, {
+    id?: true | undefined;
+    userId?: true | undefined;
+    patientId?: true | undefined;
+    staffId?: true | undefined;
+}>;
+//# sourceMappingURL=AppointmentAvgAggregateInput.schema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"AppointmentAvgAggregateInput.schema.d.ts","sourceRoot":"","sources":["AppointmentAvgAggregateInput.schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AACzB,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,2BAA2B,CAAC;AASxD,eAAO,MAAM,wCAAwC,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,gCAAgC,CAAiF,CAAC;AAC1L,eAAO,MAAM,2CAA2C;;;;;;;;;;;;;;;EAAe,CAAC"}

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

@@ -0,0 +1,45 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppointmentAvgAggregateInputObjectZodSchema = exports.AppointmentAvgAggregateInputObjectSchema = void 0;
+const z = __importStar(require("zod"));
+const makeSchema = () => z.object({
+    id: z.literal(true).optional(),
+    patientId: z.literal(true).optional(),
+    userId: z.literal(true).optional(),
+    staffId: z.literal(true).optional()
+}).strict();
+exports.AppointmentAvgAggregateInputObjectSchema = makeSchema();
+exports.AppointmentAvgAggregateInputObjectZodSchema = makeSchema();

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

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

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

@@ -0,0 +1,20 @@
+import * as z from 'zod';
+import type { Prisma } from '../../../generated/prisma';
+export declare const AppointmentAvgOrderByAggregateInputObjectSchema: z.ZodType<Prisma.AppointmentAvgOrderByAggregateInput>;
+export declare const AppointmentAvgOrderByAggregateInputObjectZodSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodEnum<["asc", "desc"]>>;
+    patientId: z.ZodOptional<z.ZodEnum<["asc", "desc"]>>;
+    userId: z.ZodOptional<z.ZodEnum<["asc", "desc"]>>;
+    staffId: z.ZodOptional<z.ZodEnum<["asc", "desc"]>>;
+}, "strict", z.ZodTypeAny, {
+    id?: "asc" | "desc" | undefined;
+    userId?: "asc" | "desc" | undefined;
+    patientId?: "asc" | "desc" | undefined;
+    staffId?: "asc" | "desc" | undefined;
+}, {
+    id?: "asc" | "desc" | undefined;
+    userId?: "asc" | "desc" | undefined;
+    patientId?: "asc" | "desc" | undefined;
+    staffId?: "asc" | "desc" | undefined;
+}>;
+//# sourceMappingURL=AppointmentAvgOrderByAggregateInput.schema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"AppointmentAvgOrderByAggregateInput.schema.d.ts","sourceRoot":"","sources":["AppointmentAvgOrderByAggregateInput.schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AACzB,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,2BAA2B,CAAC;AASxD,eAAO,MAAM,+CAA+C,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,mCAAmC,CAAoF,CAAC;AACvM,eAAO,MAAM,kDAAkD;;;;;;;;;;;;;;;EAAe,CAAC"}

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

@@ -0,0 +1,46 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppointmentAvgOrderByAggregateInputObjectZodSchema = exports.AppointmentAvgOrderByAggregateInputObjectSchema = void 0;
+const z = __importStar(require("zod"));
+const SortOrder_schema_1 = require("../enums/SortOrder.schema");
+const makeSchema = () => z.object({
+    id: SortOrder_schema_1.SortOrderSchema.optional(),
+    patientId: SortOrder_schema_1.SortOrderSchema.optional(),
+    userId: SortOrder_schema_1.SortOrderSchema.optional(),
+    staffId: SortOrder_schema_1.SortOrderSchema.optional()
+}).strict();
+exports.AppointmentAvgOrderByAggregateInputObjectSchema = makeSchema();
+exports.AppointmentAvgOrderByAggregateInputObjectZodSchema = makeSchema();

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

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

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

@@ -0,0 +1,53 @@
+import * as z from 'zod';
+import type { Prisma } from '../../../generated/prisma';
+export declare const AppointmentCountAggregateInputObjectSchema: z.ZodType<Prisma.AppointmentCountAggregateInputType>;
+export declare const AppointmentCountAggregateInputObjectZodSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodLiteral<true>>;
+    patientId: z.ZodOptional<z.ZodLiteral<true>>;
+    userId: z.ZodOptional<z.ZodLiteral<true>>;
+    staffId: z.ZodOptional<z.ZodLiteral<true>>;
+    title: z.ZodOptional<z.ZodLiteral<true>>;
+    date: z.ZodOptional<z.ZodLiteral<true>>;
+    startTime: z.ZodOptional<z.ZodLiteral<true>>;
+    endTime: z.ZodOptional<z.ZodLiteral<true>>;
+    type: z.ZodOptional<z.ZodLiteral<true>>;
+    notes: z.ZodOptional<z.ZodLiteral<true>>;
+    procedureCodeNotes: z.ZodOptional<z.ZodLiteral<true>>;
+    status: z.ZodOptional<z.ZodLiteral<true>>;
+    createdAt: z.ZodOptional<z.ZodLiteral<true>>;
+    eligibilityStatus: z.ZodOptional<z.ZodLiteral<true>>;
+    _all: z.ZodOptional<z.ZodLiteral<true>>;
+}, "strict", z.ZodTypeAny, {
+    type?: true | undefined;
+    status?: true | undefined;
+    createdAt?: true | undefined;
+    id?: true | undefined;
+    userId?: true | undefined;
+    date?: true | undefined;
+    title?: true | undefined;
+    patientId?: true | undefined;
+    startTime?: true | undefined;
+    endTime?: true | undefined;
+    notes?: true | undefined;
+    procedureCodeNotes?: true | undefined;
+    eligibilityStatus?: true | undefined;
+    staffId?: true | undefined;
+    _all?: true | undefined;
+}, {
+    type?: true | undefined;
+    status?: true | undefined;
+    createdAt?: true | undefined;
+    id?: true | undefined;
+    userId?: true | undefined;
+    date?: true | undefined;
+    title?: true | undefined;
+    patientId?: true | undefined;
+    startTime?: true | undefined;
+    endTime?: true | undefined;
+    notes?: true | undefined;
+    procedureCodeNotes?: true | undefined;
+    eligibilityStatus?: true | undefined;
+    staffId?: true | undefined;
+    _all?: true | undefined;
+}>;
+//# sourceMappingURL=AppointmentCountAggregateInput.schema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"AppointmentCountAggregateInput.schema.d.ts","sourceRoot":"","sources":["AppointmentCountAggregateInput.schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AACzB,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,2BAA2B,CAAC;AAoBxD,eAAO,MAAM,0CAA0C,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,kCAAkC,CAAmF,CAAC;AAChM,eAAO,MAAM,6CAA6C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAe,CAAC"}

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

@@ -0,0 +1,56 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppointmentCountAggregateInputObjectZodSchema = exports.AppointmentCountAggregateInputObjectSchema = void 0;
+const z = __importStar(require("zod"));
+const makeSchema = () => z.object({
+    id: z.literal(true).optional(),
+    patientId: z.literal(true).optional(),
+    userId: z.literal(true).optional(),
+    staffId: 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(),
+    procedureCodeNotes: z.literal(true).optional(),
+    status: z.literal(true).optional(),
+    createdAt: z.literal(true).optional(),
+    eligibilityStatus: z.literal(true).optional(),
+    _all: z.literal(true).optional()
+}).strict();
+exports.AppointmentCountAggregateInputObjectSchema = makeSchema();
+exports.AppointmentCountAggregateInputObjectZodSchema = makeSchema();

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

@@ -0,0 +1,23 @@
+import * as z from 'zod';
+import type { Prisma } from '../../../generated/prisma';
+
+
+const makeSchema = () => z.object({
+  id: z.literal(true).optional(),
+  patientId: z.literal(true).optional(),
+  userId: z.literal(true).optional(),
+  staffId: 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(),
+  procedureCodeNotes: z.literal(true).optional(),
+  status: z.literal(true).optional(),
+  createdAt: z.literal(true).optional(),
+  eligibilityStatus: z.literal(true).optional(),
+  _all: z.literal(true).optional()
+}).strict();
+export const AppointmentCountAggregateInputObjectSchema: z.ZodType<Prisma.AppointmentCountAggregateInputType> = makeSchema() as unknown as z.ZodType<Prisma.AppointmentCountAggregateInputType>;
+export const AppointmentCountAggregateInputObjectZodSchema = makeSchema();

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

@@ -0,0 +1,50 @@
+import * as z from 'zod';
+import type { Prisma } from '../../../generated/prisma';
+export declare const AppointmentCountOrderByAggregateInputObjectSchema: z.ZodType<Prisma.AppointmentCountOrderByAggregateInput>;
+export declare const AppointmentCountOrderByAggregateInputObjectZodSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodEnum<["asc", "desc"]>>;
+    patientId: z.ZodOptional<z.ZodEnum<["asc", "desc"]>>;
+    userId: z.ZodOptional<z.ZodEnum<["asc", "desc"]>>;
+    staffId: z.ZodOptional<z.ZodEnum<["asc", "desc"]>>;
+    title: z.ZodOptional<z.ZodEnum<["asc", "desc"]>>;
+    date: z.ZodOptional<z.ZodEnum<["asc", "desc"]>>;
+    startTime: z.ZodOptional<z.ZodEnum<["asc", "desc"]>>;
+    endTime: z.ZodOptional<z.ZodEnum<["asc", "desc"]>>;
+    type: z.ZodOptional<z.ZodEnum<["asc", "desc"]>>;
+    notes: z.ZodOptional<z.ZodEnum<["asc", "desc"]>>;
+    procedureCodeNotes: z.ZodOptional<z.ZodEnum<["asc", "desc"]>>;
+    status: z.ZodOptional<z.ZodEnum<["asc", "desc"]>>;
+    createdAt: z.ZodOptional<z.ZodEnum<["asc", "desc"]>>;
+    eligibilityStatus: z.ZodOptional<z.ZodEnum<["asc", "desc"]>>;
+}, "strict", z.ZodTypeAny, {
+    type?: "asc" | "desc" | undefined;
+    status?: "asc" | "desc" | undefined;
+    createdAt?: "asc" | "desc" | undefined;
+    id?: "asc" | "desc" | undefined;
+    userId?: "asc" | "desc" | undefined;
+    date?: "asc" | "desc" | undefined;
+    title?: "asc" | "desc" | undefined;
+    patientId?: "asc" | "desc" | undefined;
+    startTime?: "asc" | "desc" | undefined;
+    endTime?: "asc" | "desc" | undefined;
+    notes?: "asc" | "desc" | undefined;
+    procedureCodeNotes?: "asc" | "desc" | undefined;
+    eligibilityStatus?: "asc" | "desc" | undefined;
+    staffId?: "asc" | "desc" | undefined;
+}, {
+    type?: "asc" | "desc" | undefined;
+    status?: "asc" | "desc" | undefined;
+    createdAt?: "asc" | "desc" | undefined;
+    id?: "asc" | "desc" | undefined;
+    userId?: "asc" | "desc" | undefined;
+    date?: "asc" | "desc" | undefined;
+    title?: "asc" | "desc" | undefined;
+    patientId?: "asc" | "desc" | undefined;
+    startTime?: "asc" | "desc" | undefined;
+    endTime?: "asc" | "desc" | undefined;
+    notes?: "asc" | "desc" | undefined;
+    procedureCodeNotes?: "asc" | "desc" | undefined;
+    eligibilityStatus?: "asc" | "desc" | undefined;
+    staffId?: "asc" | "desc" | undefined;
+}>;
+//# sourceMappingURL=AppointmentCountOrderByAggregateInput.schema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"AppointmentCountOrderByAggregateInput.schema.d.ts","sourceRoot":"","sources":["AppointmentCountOrderByAggregateInput.schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AACzB,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,2BAA2B,CAAC;AAmBxD,eAAO,MAAM,iDAAiD,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,qCAAqC,CAAsF,CAAC;AAC7M,eAAO,MAAM,oDAAoD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAe,CAAC"}

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

@@ -0,0 +1,56 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppointmentCountOrderByAggregateInputObjectZodSchema = exports.AppointmentCountOrderByAggregateInputObjectSchema = void 0;
+const z = __importStar(require("zod"));
+const SortOrder_schema_1 = require("../enums/SortOrder.schema");
+const makeSchema = () => z.object({
+    id: SortOrder_schema_1.SortOrderSchema.optional(),
+    patientId: SortOrder_schema_1.SortOrderSchema.optional(),
+    userId: SortOrder_schema_1.SortOrderSchema.optional(),
+    staffId: SortOrder_schema_1.SortOrderSchema.optional(),
+    title: SortOrder_schema_1.SortOrderSchema.optional(),
+    date: SortOrder_schema_1.SortOrderSchema.optional(),
+    startTime: SortOrder_schema_1.SortOrderSchema.optional(),
+    endTime: SortOrder_schema_1.SortOrderSchema.optional(),
+    type: SortOrder_schema_1.SortOrderSchema.optional(),
+    notes: SortOrder_schema_1.SortOrderSchema.optional(),
+    procedureCodeNotes: SortOrder_schema_1.SortOrderSchema.optional(),
+    status: SortOrder_schema_1.SortOrderSchema.optional(),
+    createdAt: SortOrder_schema_1.SortOrderSchema.optional(),
+    eligibilityStatus: SortOrder_schema_1.SortOrderSchema.optional()
+}).strict();
+exports.AppointmentCountOrderByAggregateInputObjectSchema = makeSchema();
+exports.AppointmentCountOrderByAggregateInputObjectZodSchema = makeSchema();

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

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

packages/db/shared/schemas/objects/AppointmentCountOutputTypeArgs.schema.d.ts

@@ -0,0 +1,17 @@
+import * as z from 'zod';
+import type { Prisma } from '../../../generated/prisma';
+export declare const AppointmentCountOutputTypeArgsObjectSchema: z.ZodObject<{
+    select: z.ZodOptional<z.ZodLazy<z.ZodType<Prisma.AppointmentCountOutputTypeSelect<import("../../../generated/prisma/runtime/client").DefaultArgs>, z.ZodTypeDef, Prisma.AppointmentCountOutputTypeSelect<import("../../../generated/prisma/runtime/client").DefaultArgs>>>>;
+}, "strict", z.ZodTypeAny, {
+    select?: Prisma.AppointmentCountOutputTypeSelect<import("../../../generated/prisma/runtime/client").DefaultArgs> | undefined;
+}, {
+    select?: Prisma.AppointmentCountOutputTypeSelect<import("../../../generated/prisma/runtime/client").DefaultArgs> | undefined;
+}>;
+export declare const AppointmentCountOutputTypeArgsObjectZodSchema: z.ZodObject<{
+    select: z.ZodOptional<z.ZodLazy<z.ZodType<Prisma.AppointmentCountOutputTypeSelect<import("../../../generated/prisma/runtime/client").DefaultArgs>, z.ZodTypeDef, Prisma.AppointmentCountOutputTypeSelect<import("../../../generated/prisma/runtime/client").DefaultArgs>>>>;
+}, "strict", z.ZodTypeAny, {
+    select?: Prisma.AppointmentCountOutputTypeSelect<import("../../../generated/prisma/runtime/client").DefaultArgs> | undefined;
+}, {
+    select?: Prisma.AppointmentCountOutputTypeSelect<import("../../../generated/prisma/runtime/client").DefaultArgs> | undefined;
+}>;
+//# sourceMappingURL=AppointmentCountOutputTypeArgs.schema.d.ts.map

packages/db/shared/schemas/objects/AppointmentCountOutputTypeArgs.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AppointmentCountOutputTypeArgs.schema.d.ts","sourceRoot":"","sources":["AppointmentCountOutputTypeArgs.schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AACzB,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,2BAA2B,CAAC;AAMxD,eAAO,MAAM,0CAA0C;;;;;;EAAe,CAAC;AACvE,eAAO,MAAM,6CAA6C;;;;;;EAAe,CAAC"}

packages/db/shared/schemas/objects/AppointmentCountOutputTypeArgs.schema.js

@@ -0,0 +1,43 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppointmentCountOutputTypeArgsObjectZodSchema = exports.AppointmentCountOutputTypeArgsObjectSchema = void 0;
+const z = __importStar(require("zod"));
+const AppointmentCountOutputTypeSelect_schema_1 = require("./AppointmentCountOutputTypeSelect.schema");
+const makeSchema = () => z.object({
+    select: z.lazy(() => AppointmentCountOutputTypeSelect_schema_1.AppointmentCountOutputTypeSelectObjectSchema).optional()
+}).strict();
+exports.AppointmentCountOutputTypeArgsObjectSchema = makeSchema();
+exports.AppointmentCountOutputTypeArgsObjectZodSchema = makeSchema();

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

@@ -0,0 +1,9 @@
+import * as z from 'zod';
+import type { Prisma } from '../../../generated/prisma';
+import { AppointmentCountOutputTypeSelectObjectSchema as AppointmentCountOutputTypeSelectObjectSchema } from './AppointmentCountOutputTypeSelect.schema'
+
+const makeSchema = () => z.object({
+  select: z.lazy(() => AppointmentCountOutputTypeSelectObjectSchema).optional()
+}).strict();
+export const AppointmentCountOutputTypeArgsObjectSchema = makeSchema();
+export const AppointmentCountOutputTypeArgsObjectZodSchema = makeSchema();

packages/db/shared/schemas/objects/AppointmentCountOutputTypeCountClaimsArgs.schema.d.ts

@@ -0,0 +1,17 @@
+import * as z from 'zod';
+import type { Prisma } from '../../../generated/prisma';
+export declare const AppointmentCountOutputTypeCountClaimsArgsObjectSchema: z.ZodObject<{
+    where: z.ZodOptional<z.ZodLazy<z.ZodType<Prisma.ClaimWhereInput, z.ZodTypeDef, Prisma.ClaimWhereInput>>>;
+}, "strict", z.ZodTypeAny, {
+    where?: Prisma.ClaimWhereInput | undefined;
+}, {
+    where?: Prisma.ClaimWhereInput | undefined;
+}>;
+export declare const AppointmentCountOutputTypeCountClaimsArgsObjectZodSchema: z.ZodObject<{
+    where: z.ZodOptional<z.ZodLazy<z.ZodType<Prisma.ClaimWhereInput, z.ZodTypeDef, Prisma.ClaimWhereInput>>>;
+}, "strict", z.ZodTypeAny, {
+    where?: Prisma.ClaimWhereInput | undefined;
+}, {
+    where?: Prisma.ClaimWhereInput | undefined;
+}>;
+//# sourceMappingURL=AppointmentCountOutputTypeCountClaimsArgs.schema.d.ts.map

packages/db/shared/schemas/objects/AppointmentCountOutputTypeCountClaimsArgs.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AppointmentCountOutputTypeCountClaimsArgs.schema.d.ts","sourceRoot":"","sources":["AppointmentCountOutputTypeCountClaimsArgs.schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AACzB,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,2BAA2B,CAAC;AAMxD,eAAO,MAAM,qDAAqD;;;;;;EAAe,CAAC;AAClF,eAAO,MAAM,wDAAwD;;;;;;EAAe,CAAC"}

packages/db/shared/schemas/objects/AppointmentCountOutputTypeCountClaimsArgs.schema.js

@@ -0,0 +1,43 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppointmentCountOutputTypeCountClaimsArgsObjectZodSchema = exports.AppointmentCountOutputTypeCountClaimsArgsObjectSchema = void 0;
+const z = __importStar(require("zod"));
+const ClaimWhereInput_schema_1 = require("./ClaimWhereInput.schema");
+const makeSchema = () => z.object({
+    where: z.lazy(() => ClaimWhereInput_schema_1.ClaimWhereInputObjectSchema).optional()
+}).strict();
+exports.AppointmentCountOutputTypeCountClaimsArgsObjectSchema = makeSchema();
+exports.AppointmentCountOutputTypeCountClaimsArgsObjectZodSchema = makeSchema();

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

@@ -0,0 +1,9 @@
+import * as z from 'zod';
+import type { Prisma } from '../../../generated/prisma';
+import { ClaimWhereInputObjectSchema as ClaimWhereInputObjectSchema } from './ClaimWhereInput.schema'
+
+const makeSchema = () => z.object({
+  where: z.lazy(() => ClaimWhereInputObjectSchema).optional()
+}).strict();
+export const AppointmentCountOutputTypeCountClaimsArgsObjectSchema = makeSchema();
+export const AppointmentCountOutputTypeCountClaimsArgsObjectZodSchema = makeSchema();

packages/db/shared/schemas/objects/AppointmentCountOutputTypeCountProceduresArgs.schema.d.ts

@@ -0,0 +1,17 @@
+import * as z from 'zod';
+import type { Prisma } from '../../../generated/prisma';
+export declare const AppointmentCountOutputTypeCountProceduresArgsObjectSchema: z.ZodObject<{
+    where: z.ZodOptional<z.ZodLazy<z.ZodType<Prisma.AppointmentProcedureWhereInput, z.ZodTypeDef, Prisma.AppointmentProcedureWhereInput>>>;
+}, "strict", z.ZodTypeAny, {
+    where?: Prisma.AppointmentProcedureWhereInput | undefined;
+}, {
+    where?: Prisma.AppointmentProcedureWhereInput | undefined;
+}>;
+export declare const AppointmentCountOutputTypeCountProceduresArgsObjectZodSchema: z.ZodObject<{
+    where: z.ZodOptional<z.ZodLazy<z.ZodType<Prisma.AppointmentProcedureWhereInput, z.ZodTypeDef, Prisma.AppointmentProcedureWhereInput>>>;
+}, "strict", z.ZodTypeAny, {
+    where?: Prisma.AppointmentProcedureWhereInput | undefined;
+}, {
+    where?: Prisma.AppointmentProcedureWhereInput | undefined;
+}>;
+//# sourceMappingURL=AppointmentCountOutputTypeCountProceduresArgs.schema.d.ts.map

packages/db/shared/schemas/objects/AppointmentCountOutputTypeCountProceduresArgs.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AppointmentCountOutputTypeCountProceduresArgs.schema.d.ts","sourceRoot":"","sources":["AppointmentCountOutputTypeCountProceduresArgs.schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AACzB,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,2BAA2B,CAAC;AAMxD,eAAO,MAAM,yDAAyD;;;;;;EAAe,CAAC;AACtF,eAAO,MAAM,4DAA4D;;;;;;EAAe,CAAC"}

packages/db/shared/schemas/objects/AppointmentCountOutputTypeCountProceduresArgs.schema.js

@@ -0,0 +1,43 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppointmentCountOutputTypeCountProceduresArgsObjectZodSchema = exports.AppointmentCountOutputTypeCountProceduresArgsObjectSchema = void 0;
+const z = __importStar(require("zod"));
+const AppointmentProcedureWhereInput_schema_1 = require("./AppointmentProcedureWhereInput.schema");
+const makeSchema = () => z.object({
+    where: z.lazy(() => AppointmentProcedureWhereInput_schema_1.AppointmentProcedureWhereInputObjectSchema).optional()
+}).strict();
+exports.AppointmentCountOutputTypeCountProceduresArgsObjectSchema = makeSchema();
+exports.AppointmentCountOutputTypeCountProceduresArgsObjectZodSchema = makeSchema();

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

@@ -0,0 +1,9 @@
+import * as z from 'zod';
+import type { Prisma } from '../../../generated/prisma';
+import { AppointmentProcedureWhereInputObjectSchema as AppointmentProcedureWhereInputObjectSchema } from './AppointmentProcedureWhereInput.schema'
+
+const makeSchema = () => z.object({
+  where: z.lazy(() => AppointmentProcedureWhereInputObjectSchema).optional()
+}).strict();
+export const AppointmentCountOutputTypeCountProceduresArgsObjectSchema = makeSchema();
+export const AppointmentCountOutputTypeCountProceduresArgsObjectZodSchema = makeSchema();

packages/db/shared/schemas/objects/AppointmentCountOutputTypeSelect.schema.d.ts

@@ -0,0 +1,34 @@
+import * as z from 'zod';
+import type { Prisma } from '../../../generated/prisma';
+export declare const AppointmentCountOutputTypeSelectObjectSchema: z.ZodType<Prisma.AppointmentCountOutputTypeSelect>;
+export declare const AppointmentCountOutputTypeSelectObjectZodSchema: z.ZodObject<{
+    procedures: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodLazy<z.ZodObject<{
+        where: z.ZodOptional<z.ZodLazy<z.ZodType<Prisma.AppointmentProcedureWhereInput, z.ZodTypeDef, Prisma.AppointmentProcedureWhereInput>>>;
+    }, "strict", z.ZodTypeAny, {
+        where?: Prisma.AppointmentProcedureWhereInput | undefined;
+    }, {
+        where?: Prisma.AppointmentProcedureWhereInput | undefined;
+    }>>]>>;
+    claims: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodLazy<z.ZodObject<{
+        where: z.ZodOptional<z.ZodLazy<z.ZodType<Prisma.ClaimWhereInput, z.ZodTypeDef, Prisma.ClaimWhereInput>>>;
+    }, "strict", z.ZodTypeAny, {
+        where?: Prisma.ClaimWhereInput | undefined;
+    }, {
+        where?: Prisma.ClaimWhereInput | undefined;
+    }>>]>>;
+}, "strict", z.ZodTypeAny, {
+    procedures?: boolean | {
+        where?: Prisma.AppointmentProcedureWhereInput | undefined;
+    } | undefined;
+    claims?: boolean | {
+        where?: Prisma.ClaimWhereInput | undefined;
+    } | undefined;
+}, {
+    procedures?: boolean | {
+        where?: Prisma.AppointmentProcedureWhereInput | undefined;
+    } | undefined;
+    claims?: boolean | {
+        where?: Prisma.ClaimWhereInput | undefined;
+    } | undefined;
+}>;
+//# sourceMappingURL=AppointmentCountOutputTypeSelect.schema.d.ts.map

packages/db/shared/schemas/objects/AppointmentCountOutputTypeSelect.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AppointmentCountOutputTypeSelect.schema.d.ts","sourceRoot":"","sources":["AppointmentCountOutputTypeSelect.schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AACzB,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,2BAA2B,CAAC;AAQxD,eAAO,MAAM,4CAA4C,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,gCAAgC,CAAiF,CAAC;AAC9L,eAAO,MAAM,+CAA+C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAe,CAAC"}

packages/db/shared/schemas/objects/AppointmentCountOutputTypeSelect.schema.js

@@ -0,0 +1,45 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppointmentCountOutputTypeSelectObjectZodSchema = exports.AppointmentCountOutputTypeSelectObjectSchema = void 0;
+const z = __importStar(require("zod"));
+const AppointmentCountOutputTypeCountProceduresArgs_schema_1 = require("./AppointmentCountOutputTypeCountProceduresArgs.schema");
+const AppointmentCountOutputTypeCountClaimsArgs_schema_1 = require("./AppointmentCountOutputTypeCountClaimsArgs.schema");
+const makeSchema = () => z.object({
+    procedures: z.union([z.boolean(), z.lazy(() => AppointmentCountOutputTypeCountProceduresArgs_schema_1.AppointmentCountOutputTypeCountProceduresArgsObjectSchema)]).optional(),
+    claims: z.union([z.boolean(), z.lazy(() => AppointmentCountOutputTypeCountClaimsArgs_schema_1.AppointmentCountOutputTypeCountClaimsArgsObjectSchema)]).optional()
+}).strict();
+exports.AppointmentCountOutputTypeSelectObjectSchema = makeSchema();
+exports.AppointmentCountOutputTypeSelectObjectZodSchema = makeSchema();

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

@@ -0,0 +1,11 @@
+import * as z from 'zod';
+import type { Prisma } from '../../../generated/prisma';
+import { AppointmentCountOutputTypeCountProceduresArgsObjectSchema as AppointmentCountOutputTypeCountProceduresArgsObjectSchema } from './AppointmentCountOutputTypeCountProceduresArgs.schema';
+import { AppointmentCountOutputTypeCountClaimsArgsObjectSchema as AppointmentCountOutputTypeCountClaimsArgsObjectSchema } from './AppointmentCountOutputTypeCountClaimsArgs.schema'
+
+const makeSchema = () => z.object({
+  procedures: z.union([z.boolean(), z.lazy(() => AppointmentCountOutputTypeCountProceduresArgsObjectSchema)]).optional(),
+  claims: z.union([z.boolean(), z.lazy(() => AppointmentCountOutputTypeCountClaimsArgsObjectSchema)]).optional()
+}).strict();
+export const AppointmentCountOutputTypeSelectObjectSchema: z.ZodType<Prisma.AppointmentCountOutputTypeSelect> = makeSchema() as unknown as z.ZodType<Prisma.AppointmentCountOutputTypeSelect>;
+export const AppointmentCountOutputTypeSelectObjectZodSchema = makeSchema();

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

@@ -0,0 +1,53 @@
+import * as z from 'zod';
+import type { Prisma } from '../../../generated/prisma';
+export declare const AppointmentCreateInputObjectSchema: z.ZodType<Prisma.AppointmentCreateInput>;
+export declare const AppointmentCreateInputObjectZodSchema: z.ZodObject<{
+    title: z.ZodString;
+    date: z.ZodDate;
+    startTime: z.ZodString;
+    endTime: z.ZodString;
+    type: z.ZodString;
+    notes: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    procedureCodeNotes: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    status: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodOptional<z.ZodDate>;
+    eligibilityStatus: z.ZodOptional<z.ZodEnum<["ACTIVE", "INACTIVE", "UNKNOWN"]>>;
+    patient: z.ZodLazy<z.ZodType<Prisma.PatientCreateNestedOneWithoutAppointmentsInput, z.ZodTypeDef, Prisma.PatientCreateNestedOneWithoutAppointmentsInput>>;
+    user: z.ZodLazy<z.ZodType<Prisma.UserCreateNestedOneWithoutAppointmentsInput, z.ZodTypeDef, Prisma.UserCreateNestedOneWithoutAppointmentsInput>>;
+    staff: z.ZodOptional<z.ZodLazy<z.ZodType<Prisma.StaffCreateNestedOneWithoutAppointmentsInput, z.ZodTypeDef, Prisma.StaffCreateNestedOneWithoutAppointmentsInput>>>;
+    procedures: z.ZodOptional<z.ZodLazy<z.ZodType<Prisma.AppointmentProcedureCreateNestedManyWithoutAppointmentInput, z.ZodTypeDef, Prisma.AppointmentProcedureCreateNestedManyWithoutAppointmentInput>>>;
+    claims: z.ZodOptional<z.ZodLazy<z.ZodType<Prisma.ClaimCreateNestedManyWithoutAppointmentInput, z.ZodTypeDef, Prisma.ClaimCreateNestedManyWithoutAppointmentInput>>>;
+}, "strict", z.ZodTypeAny, {
+    type: string;
+    user: Prisma.UserCreateNestedOneWithoutAppointmentsInput;
+    date: Date;
+    title: string;
+    patient: Prisma.PatientCreateNestedOneWithoutAppointmentsInput;
+    startTime: string;
+    endTime: string;
+    status?: string | undefined;
+    createdAt?: Date | undefined;
+    notes?: string | null | undefined;
+    procedureCodeNotes?: string | null | undefined;
+    eligibilityStatus?: "ACTIVE" | "INACTIVE" | "UNKNOWN" | undefined;
+    staff?: Prisma.StaffCreateNestedOneWithoutAppointmentsInput | undefined;
+    procedures?: Prisma.AppointmentProcedureCreateNestedManyWithoutAppointmentInput | undefined;
+    claims?: Prisma.ClaimCreateNestedManyWithoutAppointmentInput | undefined;
+}, {
+    type: string;
+    user: Prisma.UserCreateNestedOneWithoutAppointmentsInput;
+    date: Date;
+    title: string;
+    patient: Prisma.PatientCreateNestedOneWithoutAppointmentsInput;
+    startTime: string;
+    endTime: string;
+    status?: string | undefined;
+    createdAt?: Date | undefined;
+    notes?: string | null | undefined;
+    procedureCodeNotes?: string | null | undefined;
+    eligibilityStatus?: "ACTIVE" | "INACTIVE" | "UNKNOWN" | undefined;
+    staff?: Prisma.StaffCreateNestedOneWithoutAppointmentsInput | undefined;
+    procedures?: Prisma.AppointmentProcedureCreateNestedManyWithoutAppointmentInput | undefined;
+    claims?: Prisma.ClaimCreateNestedManyWithoutAppointmentInput | undefined;
+}>;
+//# sourceMappingURL=AppointmentCreateInput.schema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"AppointmentCreateInput.schema.d.ts","sourceRoot":"","sources":["AppointmentCreateInput.schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AACzB,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,2BAA2B,CAAC;AAyBxD,eAAO,MAAM,kCAAkC,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,sBAAsB,CAAuE,CAAC;AAChK,eAAO,MAAM,qCAAqC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAe,CAAC"}

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

@@ -0,0 +1,62 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppointmentCreateInputObjectZodSchema = exports.AppointmentCreateInputObjectSchema = void 0;
+const z = __importStar(require("zod"));
+const PatientStatus_schema_1 = require("../enums/PatientStatus.schema");
+const PatientCreateNestedOneWithoutAppointmentsInput_schema_1 = require("./PatientCreateNestedOneWithoutAppointmentsInput.schema");
+const UserCreateNestedOneWithoutAppointmentsInput_schema_1 = require("./UserCreateNestedOneWithoutAppointmentsInput.schema");
+const StaffCreateNestedOneWithoutAppointmentsInput_schema_1 = require("./StaffCreateNestedOneWithoutAppointmentsInput.schema");
+const AppointmentProcedureCreateNestedManyWithoutAppointmentInput_schema_1 = require("./AppointmentProcedureCreateNestedManyWithoutAppointmentInput.schema");
+const ClaimCreateNestedManyWithoutAppointmentInput_schema_1 = require("./ClaimCreateNestedManyWithoutAppointmentInput.schema");
+const makeSchema = () => z.object({
+    title: z.string(),
+    date: z.coerce.date(),
+    startTime: z.string(),
+    endTime: z.string(),
+    type: z.string(),
+    notes: z.string().optional().nullable(),
+    procedureCodeNotes: z.string().optional().nullable(),
+    status: z.string().optional(),
+    createdAt: z.coerce.date().optional(),
+    eligibilityStatus: PatientStatus_schema_1.PatientStatusSchema.optional(),
+    patient: z.lazy(() => PatientCreateNestedOneWithoutAppointmentsInput_schema_1.PatientCreateNestedOneWithoutAppointmentsInputObjectSchema),
+    user: z.lazy(() => UserCreateNestedOneWithoutAppointmentsInput_schema_1.UserCreateNestedOneWithoutAppointmentsInputObjectSchema),
+    staff: z.lazy(() => StaffCreateNestedOneWithoutAppointmentsInput_schema_1.StaffCreateNestedOneWithoutAppointmentsInputObjectSchema).optional(),
+    procedures: z.lazy(() => AppointmentProcedureCreateNestedManyWithoutAppointmentInput_schema_1.AppointmentProcedureCreateNestedManyWithoutAppointmentInputObjectSchema).optional(),
+    claims: z.lazy(() => ClaimCreateNestedManyWithoutAppointmentInput_schema_1.ClaimCreateNestedManyWithoutAppointmentInputObjectSchema).optional()
+}).strict();
+exports.AppointmentCreateInputObjectSchema = makeSchema();
+exports.AppointmentCreateInputObjectZodSchema = makeSchema();

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

@@ -0,0 +1,28 @@
+import * as z from 'zod';
+import type { Prisma } from '../../../generated/prisma';
+import { PatientStatusSchema } from '../enums/PatientStatus.schema';
+import { PatientCreateNestedOneWithoutAppointmentsInputObjectSchema as PatientCreateNestedOneWithoutAppointmentsInputObjectSchema } from './PatientCreateNestedOneWithoutAppointmentsInput.schema';
+import { UserCreateNestedOneWithoutAppointmentsInputObjectSchema as UserCreateNestedOneWithoutAppointmentsInputObjectSchema } from './UserCreateNestedOneWithoutAppointmentsInput.schema';
+import { StaffCreateNestedOneWithoutAppointmentsInputObjectSchema as StaffCreateNestedOneWithoutAppointmentsInputObjectSchema } from './StaffCreateNestedOneWithoutAppointmentsInput.schema';
+import { AppointmentProcedureCreateNestedManyWithoutAppointmentInputObjectSchema as AppointmentProcedureCreateNestedManyWithoutAppointmentInputObjectSchema } from './AppointmentProcedureCreateNestedManyWithoutAppointmentInput.schema';
+import { ClaimCreateNestedManyWithoutAppointmentInputObjectSchema as ClaimCreateNestedManyWithoutAppointmentInputObjectSchema } from './ClaimCreateNestedManyWithoutAppointmentInput.schema'
+
+const makeSchema = () => z.object({
+  title: z.string(),
+  date: z.coerce.date(),
+  startTime: z.string(),
+  endTime: z.string(),
+  type: z.string(),
+  notes: z.string().optional().nullable(),
+  procedureCodeNotes: z.string().optional().nullable(),
+  status: z.string().optional(),
+  createdAt: z.coerce.date().optional(),
+  eligibilityStatus: PatientStatusSchema.optional(),
+  patient: z.lazy(() => PatientCreateNestedOneWithoutAppointmentsInputObjectSchema),
+  user: z.lazy(() => UserCreateNestedOneWithoutAppointmentsInputObjectSchema),
+  staff: z.lazy(() => StaffCreateNestedOneWithoutAppointmentsInputObjectSchema).optional(),
+  procedures: z.lazy(() => AppointmentProcedureCreateNestedManyWithoutAppointmentInputObjectSchema).optional(),
+  claims: z.lazy(() => ClaimCreateNestedManyWithoutAppointmentInputObjectSchema).optional()
+}).strict();
+export const AppointmentCreateInputObjectSchema: z.ZodType<Prisma.AppointmentCreateInput> = makeSchema() as unknown as z.ZodType<Prisma.AppointmentCreateInput>;
+export const AppointmentCreateInputObjectZodSchema = makeSchema();

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

@@ -0,0 +1,50 @@
+import * as z from 'zod';
+import type { Prisma } from '../../../generated/prisma';
+export declare const AppointmentCreateManyInputObjectSchema: z.ZodType<Prisma.AppointmentCreateManyInput>;
+export declare const AppointmentCreateManyInputObjectZodSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodNumber>;
+    patientId: z.ZodNumber;
+    userId: z.ZodNumber;
+    staffId: z.ZodNumber;
+    title: z.ZodString;
+    date: z.ZodDate;
+    startTime: z.ZodString;
+    endTime: z.ZodString;
+    type: z.ZodString;
+    notes: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    procedureCodeNotes: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    status: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodOptional<z.ZodDate>;
+    eligibilityStatus: z.ZodOptional<z.ZodEnum<["ACTIVE", "INACTIVE", "UNKNOWN"]>>;
+}, "strict", z.ZodTypeAny, {
+    type: string;
+    userId: number;
+    date: Date;
+    title: string;
+    patientId: number;
+    startTime: string;
+    endTime: string;
+    staffId: number;
+    status?: string | undefined;
+    createdAt?: Date | undefined;
+    id?: number | undefined;
+    notes?: string | null | undefined;
+    procedureCodeNotes?: string | null | undefined;
+    eligibilityStatus?: "ACTIVE" | "INACTIVE" | "UNKNOWN" | undefined;
+}, {
+    type: string;
+    userId: number;
+    date: Date;
+    title: string;
+    patientId: number;
+    startTime: string;
+    endTime: string;
+    staffId: number;
+    status?: string | undefined;
+    createdAt?: Date | undefined;
+    id?: number | undefined;
+    notes?: string | null | undefined;
+    procedureCodeNotes?: string | null | undefined;
+    eligibilityStatus?: "ACTIVE" | "INACTIVE" | "UNKNOWN" | undefined;
+}>;
+//# sourceMappingURL=AppointmentCreateManyInput.schema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"AppointmentCreateManyInput.schema.d.ts","sourceRoot":"","sources":["AppointmentCreateManyInput.schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AACzB,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,2BAA2B,CAAC;AAmBxD,eAAO,MAAM,sCAAsC,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,0BAA0B,CAA2E,CAAC;AAC5K,eAAO,MAAM,yCAAyC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAe,CAAC"}

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

@@ -0,0 +1,56 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppointmentCreateManyInputObjectZodSchema = exports.AppointmentCreateManyInputObjectSchema = void 0;
+const z = __importStar(require("zod"));
+const PatientStatus_schema_1 = require("../enums/PatientStatus.schema");
+const makeSchema = () => z.object({
+    id: z.number().int().optional(),
+    patientId: z.number().int(),
+    userId: z.number().int(),
+    staffId: z.number().int(),
+    title: z.string(),
+    date: z.coerce.date(),
+    startTime: z.string(),
+    endTime: z.string(),
+    type: z.string(),
+    notes: z.string().optional().nullable(),
+    procedureCodeNotes: z.string().optional().nullable(),
+    status: z.string().optional(),
+    createdAt: z.coerce.date().optional(),
+    eligibilityStatus: PatientStatus_schema_1.PatientStatusSchema.optional()
+}).strict();
+exports.AppointmentCreateManyInputObjectSchema = makeSchema();
+exports.AppointmentCreateManyInputObjectZodSchema = makeSchema();

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

@@ -0,0 +1,22 @@
+import * as z from 'zod';
+import type { Prisma } from '../../../generated/prisma';
+import { PatientStatusSchema } from '../enums/PatientStatus.schema'
+
+const makeSchema = () => z.object({
+  id: z.number().int().optional(),
+  patientId: z.number().int(),
+  userId: z.number().int(),
+  staffId: z.number().int(),
+  title: z.string(),
+  date: z.coerce.date(),
+  startTime: z.string(),
+  endTime: z.string(),
+  type: z.string(),
+  notes: z.string().optional().nullable(),
+  procedureCodeNotes: z.string().optional().nullable(),
+  status: z.string().optional(),
+  createdAt: z.coerce.date().optional(),
+  eligibilityStatus: PatientStatusSchema.optional()
+}).strict();
+export const AppointmentCreateManyInputObjectSchema: z.ZodType<Prisma.AppointmentCreateManyInput> = makeSchema() as unknown as z.ZodType<Prisma.AppointmentCreateManyInput>;
+export const AppointmentCreateManyInputObjectZodSchema = makeSchema();

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

@@ -0,0 +1,47 @@
+import * as z from 'zod';
+import type { Prisma } from '../../../generated/prisma';
+export declare const AppointmentCreateManyPatientInputObjectSchema: z.ZodType<Prisma.AppointmentCreateManyPatientInput>;
+export declare const AppointmentCreateManyPatientInputObjectZodSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodNumber>;
+    userId: z.ZodNumber;
+    staffId: z.ZodNumber;
+    title: z.ZodString;
+    date: z.ZodDate;
+    startTime: z.ZodString;
+    endTime: z.ZodString;
+    type: z.ZodString;
+    notes: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    procedureCodeNotes: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    status: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodOptional<z.ZodDate>;
+    eligibilityStatus: z.ZodOptional<z.ZodEnum<["ACTIVE", "INACTIVE", "UNKNOWN"]>>;
+}, "strict", z.ZodTypeAny, {
+    type: string;
+    userId: number;
+    date: Date;
+    title: string;
+    startTime: string;
+    endTime: string;
+    staffId: number;
+    status?: string | undefined;
+    createdAt?: Date | undefined;
+    id?: number | undefined;
+    notes?: string | null | undefined;
+    procedureCodeNotes?: string | null | undefined;
+    eligibilityStatus?: "ACTIVE" | "INACTIVE" | "UNKNOWN" | undefined;
+}, {
+    type: string;
+    userId: number;
+    date: Date;
+    title: string;
+    startTime: string;
+    endTime: string;
+    staffId: number;
+    status?: string | undefined;
+    createdAt?: Date | undefined;
+    id?: number | undefined;
+    notes?: string | null | undefined;
+    procedureCodeNotes?: string | null | undefined;
+    eligibilityStatus?: "ACTIVE" | "INACTIVE" | "UNKNOWN" | undefined;
+}>;
+//# sourceMappingURL=AppointmentCreateManyPatientInput.schema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"AppointmentCreateManyPatientInput.schema.d.ts","sourceRoot":"","sources":["AppointmentCreateManyPatientInput.schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AACzB,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,2BAA2B,CAAC;AAkBxD,eAAO,MAAM,6CAA6C,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,iCAAiC,CAAkF,CAAC;AACjM,eAAO,MAAM,gDAAgD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAe,CAAC"}

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

@@ -0,0 +1,55 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppointmentCreateManyPatientInputObjectZodSchema = exports.AppointmentCreateManyPatientInputObjectSchema = void 0;
+const z = __importStar(require("zod"));
+const PatientStatus_schema_1 = require("../enums/PatientStatus.schema");
+const makeSchema = () => z.object({
+    id: z.number().int().optional(),
+    userId: z.number().int(),
+    staffId: z.number().int(),
+    title: z.string(),
+    date: z.coerce.date(),
+    startTime: z.string(),
+    endTime: z.string(),
+    type: z.string(),
+    notes: z.string().optional().nullable(),
+    procedureCodeNotes: z.string().optional().nullable(),
+    status: z.string().optional(),
+    createdAt: z.coerce.date().optional(),
+    eligibilityStatus: PatientStatus_schema_1.PatientStatusSchema.optional()
+}).strict();
+exports.AppointmentCreateManyPatientInputObjectSchema = makeSchema();
+exports.AppointmentCreateManyPatientInputObjectZodSchema = makeSchema();

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

@@ -0,0 +1,21 @@
+import * as z from 'zod';
+import type { Prisma } from '../../../generated/prisma';
+import { PatientStatusSchema } from '../enums/PatientStatus.schema'
+
+const makeSchema = () => z.object({
+  id: z.number().int().optional(),
+  userId: z.number().int(),
+  staffId: z.number().int(),
+  title: z.string(),
+  date: z.coerce.date(),
+  startTime: z.string(),
+  endTime: z.string(),
+  type: z.string(),
+  notes: z.string().optional().nullable(),
+  procedureCodeNotes: z.string().optional().nullable(),
+  status: z.string().optional(),
+  createdAt: z.coerce.date().optional(),
+  eligibilityStatus: PatientStatusSchema.optional()
+}).strict();
+export const AppointmentCreateManyPatientInputObjectSchema: z.ZodType<Prisma.AppointmentCreateManyPatientInput> = makeSchema() as unknown as z.ZodType<Prisma.AppointmentCreateManyPatientInput>;
+export const AppointmentCreateManyPatientInputObjectZodSchema = makeSchema();

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

@@ -0,0 +1,14 @@
+import * as z from 'zod';
+import type { Prisma } from '../../../generated/prisma';
+export declare const AppointmentCreateManyPatientInputEnvelopeObjectSchema: z.ZodType<Prisma.AppointmentCreateManyPatientInputEnvelope>;
+export declare const AppointmentCreateManyPatientInputEnvelopeObjectZodSchema: z.ZodObject<{
+    data: z.ZodUnion<[z.ZodLazy<z.ZodType<Prisma.AppointmentCreateManyPatientInput, z.ZodTypeDef, Prisma.AppointmentCreateManyPatientInput>>, z.ZodArray<z.ZodLazy<z.ZodType<Prisma.AppointmentCreateManyPatientInput, z.ZodTypeDef, Prisma.AppointmentCreateManyPatientInput>>, "many">]>;
+    skipDuplicates: z.ZodOptional<z.ZodBoolean>;
+}, "strict", z.ZodTypeAny, {
+    data: Prisma.AppointmentCreateManyPatientInput | Prisma.AppointmentCreateManyPatientInput[];
+    skipDuplicates?: boolean | undefined;
+}, {
+    data: Prisma.AppointmentCreateManyPatientInput | Prisma.AppointmentCreateManyPatientInput[];
+    skipDuplicates?: boolean | undefined;
+}>;
+//# sourceMappingURL=AppointmentCreateManyPatientInputEnvelope.schema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"AppointmentCreateManyPatientInputEnvelope.schema.d.ts","sourceRoot":"","sources":["AppointmentCreateManyPatientInputEnvelope.schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AACzB,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,2BAA2B,CAAC;AAOxD,eAAO,MAAM,qDAAqD,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,yCAAyC,CAA0F,CAAC;AACzN,eAAO,MAAM,wDAAwD;;;;;;;;;EAAe,CAAC"}

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

@@ -0,0 +1,44 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppointmentCreateManyPatientInputEnvelopeObjectZodSchema = exports.AppointmentCreateManyPatientInputEnvelopeObjectSchema = void 0;
+const z = __importStar(require("zod"));
+const AppointmentCreateManyPatientInput_schema_1 = require("./AppointmentCreateManyPatientInput.schema");
+const makeSchema = () => z.object({
+    data: z.union([z.lazy(() => AppointmentCreateManyPatientInput_schema_1.AppointmentCreateManyPatientInputObjectSchema), z.lazy(() => AppointmentCreateManyPatientInput_schema_1.AppointmentCreateManyPatientInputObjectSchema).array()]),
+    skipDuplicates: z.boolean().optional()
+}).strict();
+exports.AppointmentCreateManyPatientInputEnvelopeObjectSchema = makeSchema();
+exports.AppointmentCreateManyPatientInputEnvelopeObjectZodSchema = makeSchema();

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

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

packages/db/shared/schemas/objects/AppointmentCreateManyStaffInput.schema.d.ts

@@ -0,0 +1,47 @@
+import * as z from 'zod';
+import type { Prisma } from '../../../generated/prisma';
+export declare const AppointmentCreateManyStaffInputObjectSchema: z.ZodType<Prisma.AppointmentCreateManyStaffInput>;
+export declare const AppointmentCreateManyStaffInputObjectZodSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodNumber>;
+    patientId: z.ZodNumber;
+    userId: z.ZodNumber;
+    title: z.ZodString;
+    date: z.ZodDate;
+    startTime: z.ZodString;
+    endTime: z.ZodString;
+    type: z.ZodString;
+    notes: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    procedureCodeNotes: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    status: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodOptional<z.ZodDate>;
+    eligibilityStatus: z.ZodOptional<z.ZodEnum<["ACTIVE", "INACTIVE", "UNKNOWN"]>>;
+}, "strict", z.ZodTypeAny, {
+    type: string;
+    userId: number;
+    date: Date;
+    title: string;
+    patientId: number;
+    startTime: string;
+    endTime: string;
+    status?: string | undefined;
+    createdAt?: Date | undefined;
+    id?: number | undefined;
+    notes?: string | null | undefined;
+    procedureCodeNotes?: string | null | undefined;
+    eligibilityStatus?: "ACTIVE" | "INACTIVE" | "UNKNOWN" | undefined;
+}, {
+    type: string;
+    userId: number;
+    date: Date;
+    title: string;
+    patientId: number;
+    startTime: string;
+    endTime: string;
+    status?: string | undefined;
+    createdAt?: Date | undefined;
+    id?: number | undefined;
+    notes?: string | null | undefined;
+    procedureCodeNotes?: string | null | undefined;
+    eligibilityStatus?: "ACTIVE" | "INACTIVE" | "UNKNOWN" | undefined;
+}>;
+//# sourceMappingURL=AppointmentCreateManyStaffInput.schema.d.ts.map

packages/db/shared/schemas/objects/AppointmentCreateManyStaffInput.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AppointmentCreateManyStaffInput.schema.d.ts","sourceRoot":"","sources":["AppointmentCreateManyStaffInput.schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AACzB,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,2BAA2B,CAAC;AAkBxD,eAAO,MAAM,2CAA2C,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,+BAA+B,CAAgF,CAAC;AAC3L,eAAO,MAAM,8CAA8C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAe,CAAC"}

packages/db/shared/schemas/objects/AppointmentCreateManyStaffInput.schema.js

@@ -0,0 +1,55 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppointmentCreateManyStaffInputObjectZodSchema = exports.AppointmentCreateManyStaffInputObjectSchema = void 0;
+const z = __importStar(require("zod"));
+const PatientStatus_schema_1 = require("../enums/PatientStatus.schema");
+const makeSchema = () => z.object({
+    id: z.number().int().optional(),
+    patientId: z.number().int(),
+    userId: z.number().int(),
+    title: z.string(),
+    date: z.coerce.date(),
+    startTime: z.string(),
+    endTime: z.string(),
+    type: z.string(),
+    notes: z.string().optional().nullable(),
+    procedureCodeNotes: z.string().optional().nullable(),
+    status: z.string().optional(),
+    createdAt: z.coerce.date().optional(),
+    eligibilityStatus: PatientStatus_schema_1.PatientStatusSchema.optional()
+}).strict();
+exports.AppointmentCreateManyStaffInputObjectSchema = makeSchema();
+exports.AppointmentCreateManyStaffInputObjectZodSchema = makeSchema();

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

@@ -0,0 +1,21 @@
+import * as z from 'zod';
+import type { Prisma } from '../../../generated/prisma';
+import { PatientStatusSchema } from '../enums/PatientStatus.schema'
+
+const makeSchema = () => z.object({
+  id: z.number().int().optional(),
+  patientId: z.number().int(),
+  userId: z.number().int(),
+  title: z.string(),
+  date: z.coerce.date(),
+  startTime: z.string(),
+  endTime: z.string(),
+  type: z.string(),
+  notes: z.string().optional().nullable(),
+  procedureCodeNotes: z.string().optional().nullable(),
+  status: z.string().optional(),
+  createdAt: z.coerce.date().optional(),
+  eligibilityStatus: PatientStatusSchema.optional()
+}).strict();
+export const AppointmentCreateManyStaffInputObjectSchema: z.ZodType<Prisma.AppointmentCreateManyStaffInput> = makeSchema() as unknown as z.ZodType<Prisma.AppointmentCreateManyStaffInput>;
+export const AppointmentCreateManyStaffInputObjectZodSchema = makeSchema();

packages/db/shared/schemas/objects/AppointmentCreateManyStaffInputEnvelope.schema.d.ts

@@ -0,0 +1,14 @@
+import * as z from 'zod';
+import type { Prisma } from '../../../generated/prisma';
+export declare const AppointmentCreateManyStaffInputEnvelopeObjectSchema: z.ZodType<Prisma.AppointmentCreateManyStaffInputEnvelope>;
+export declare const AppointmentCreateManyStaffInputEnvelopeObjectZodSchema: z.ZodObject<{
+    data: z.ZodUnion<[z.ZodLazy<z.ZodType<Prisma.AppointmentCreateManyStaffInput, z.ZodTypeDef, Prisma.AppointmentCreateManyStaffInput>>, z.ZodArray<z.ZodLazy<z.ZodType<Prisma.AppointmentCreateManyStaffInput, z.ZodTypeDef, Prisma.AppointmentCreateManyStaffInput>>, "many">]>;
+    skipDuplicates: z.ZodOptional<z.ZodBoolean>;
+}, "strict", z.ZodTypeAny, {
+    data: Prisma.AppointmentCreateManyStaffInput | Prisma.AppointmentCreateManyStaffInput[];
+    skipDuplicates?: boolean | undefined;
+}, {
+    data: Prisma.AppointmentCreateManyStaffInput | Prisma.AppointmentCreateManyStaffInput[];
+    skipDuplicates?: boolean | undefined;
+}>;
+//# sourceMappingURL=AppointmentCreateManyStaffInputEnvelope.schema.d.ts.map

packages/db/shared/schemas/objects/AppointmentCreateManyStaffInputEnvelope.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AppointmentCreateManyStaffInputEnvelope.schema.d.ts","sourceRoot":"","sources":["AppointmentCreateManyStaffInputEnvelope.schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AACzB,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,2BAA2B,CAAC;AAOxD,eAAO,MAAM,mDAAmD,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,uCAAuC,CAAwF,CAAC;AACnN,eAAO,MAAM,sDAAsD;;;;;;;;;EAAe,CAAC"}

packages/db/shared/schemas/objects/AppointmentCreateManyStaffInputEnvelope.schema.js

@@ -0,0 +1,44 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppointmentCreateManyStaffInputEnvelopeObjectZodSchema = exports.AppointmentCreateManyStaffInputEnvelopeObjectSchema = void 0;
+const z = __importStar(require("zod"));
+const AppointmentCreateManyStaffInput_schema_1 = require("./AppointmentCreateManyStaffInput.schema");
+const makeSchema = () => z.object({
+    data: z.union([z.lazy(() => AppointmentCreateManyStaffInput_schema_1.AppointmentCreateManyStaffInputObjectSchema), z.lazy(() => AppointmentCreateManyStaffInput_schema_1.AppointmentCreateManyStaffInputObjectSchema).array()]),
+    skipDuplicates: z.boolean().optional()
+}).strict();
+exports.AppointmentCreateManyStaffInputEnvelopeObjectSchema = makeSchema();
+exports.AppointmentCreateManyStaffInputEnvelopeObjectZodSchema = makeSchema();

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

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

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

@@ -0,0 +1,47 @@
+import * as z from 'zod';
+import type { Prisma } from '../../../generated/prisma';
+export declare const AppointmentCreateManyUserInputObjectSchema: z.ZodType<Prisma.AppointmentCreateManyUserInput>;
+export declare const AppointmentCreateManyUserInputObjectZodSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodNumber>;
+    patientId: z.ZodNumber;
+    staffId: z.ZodNumber;
+    title: z.ZodString;
+    date: z.ZodDate;
+    startTime: z.ZodString;
+    endTime: z.ZodString;
+    type: z.ZodString;
+    notes: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    procedureCodeNotes: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    status: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodOptional<z.ZodDate>;
+    eligibilityStatus: z.ZodOptional<z.ZodEnum<["ACTIVE", "INACTIVE", "UNKNOWN"]>>;
+}, "strict", z.ZodTypeAny, {
+    type: string;
+    date: Date;
+    title: string;
+    patientId: number;
+    startTime: string;
+    endTime: string;
+    staffId: number;
+    status?: string | undefined;
+    createdAt?: Date | undefined;
+    id?: number | undefined;
+    notes?: string | null | undefined;
+    procedureCodeNotes?: string | null | undefined;
+    eligibilityStatus?: "ACTIVE" | "INACTIVE" | "UNKNOWN" | undefined;
+}, {
+    type: string;
+    date: Date;
+    title: string;
+    patientId: number;
+    startTime: string;
+    endTime: string;
+    staffId: number;
+    status?: string | undefined;
+    createdAt?: Date | undefined;
+    id?: number | undefined;
+    notes?: string | null | undefined;
+    procedureCodeNotes?: string | null | undefined;
+    eligibilityStatus?: "ACTIVE" | "INACTIVE" | "UNKNOWN" | undefined;
+}>;
+//# sourceMappingURL=AppointmentCreateManyUserInput.schema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"AppointmentCreateManyUserInput.schema.d.ts","sourceRoot":"","sources":["AppointmentCreateManyUserInput.schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AACzB,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,2BAA2B,CAAC;AAkBxD,eAAO,MAAM,0CAA0C,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,8BAA8B,CAA+E,CAAC;AACxL,eAAO,MAAM,6CAA6C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAe,CAAC"}

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

@@ -0,0 +1,55 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppointmentCreateManyUserInputObjectZodSchema = exports.AppointmentCreateManyUserInputObjectSchema = void 0;
+const z = __importStar(require("zod"));
+const PatientStatus_schema_1 = require("../enums/PatientStatus.schema");
+const makeSchema = () => z.object({
+    id: z.number().int().optional(),
+    patientId: z.number().int(),
+    staffId: z.number().int(),
+    title: z.string(),
+    date: z.coerce.date(),
+    startTime: z.string(),
+    endTime: z.string(),
+    type: z.string(),
+    notes: z.string().optional().nullable(),
+    procedureCodeNotes: z.string().optional().nullable(),
+    status: z.string().optional(),
+    createdAt: z.coerce.date().optional(),
+    eligibilityStatus: PatientStatus_schema_1.PatientStatusSchema.optional()
+}).strict();
+exports.AppointmentCreateManyUserInputObjectSchema = makeSchema();
+exports.AppointmentCreateManyUserInputObjectZodSchema = makeSchema();

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

@@ -0,0 +1,21 @@
+import * as z from 'zod';
+import type { Prisma } from '../../../generated/prisma';
+import { PatientStatusSchema } from '../enums/PatientStatus.schema'
+
+const makeSchema = () => z.object({
+  id: z.number().int().optional(),
+  patientId: z.number().int(),
+  staffId: z.number().int(),
+  title: z.string(),
+  date: z.coerce.date(),
+  startTime: z.string(),
+  endTime: z.string(),
+  type: z.string(),
+  notes: z.string().optional().nullable(),
+  procedureCodeNotes: z.string().optional().nullable(),
+  status: z.string().optional(),
+  createdAt: z.coerce.date().optional(),
+  eligibilityStatus: PatientStatusSchema.optional()
+}).strict();
+export const AppointmentCreateManyUserInputObjectSchema: z.ZodType<Prisma.AppointmentCreateManyUserInput> = makeSchema() as unknown as z.ZodType<Prisma.AppointmentCreateManyUserInput>;
+export const AppointmentCreateManyUserInputObjectZodSchema = makeSchema();

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

@@ -0,0 +1,14 @@
+import * as z from 'zod';
+import type { Prisma } from '../../../generated/prisma';
+export declare const AppointmentCreateManyUserInputEnvelopeObjectSchema: z.ZodType<Prisma.AppointmentCreateManyUserInputEnvelope>;
+export declare const AppointmentCreateManyUserInputEnvelopeObjectZodSchema: z.ZodObject<{
+    data: z.ZodUnion<[z.ZodLazy<z.ZodType<Prisma.AppointmentCreateManyUserInput, z.ZodTypeDef, Prisma.AppointmentCreateManyUserInput>>, z.ZodArray<z.ZodLazy<z.ZodType<Prisma.AppointmentCreateManyUserInput, z.ZodTypeDef, Prisma.AppointmentCreateManyUserInput>>, "many">]>;
+    skipDuplicates: z.ZodOptional<z.ZodBoolean>;
+}, "strict", z.ZodTypeAny, {
+    data: Prisma.AppointmentCreateManyUserInput | Prisma.AppointmentCreateManyUserInput[];
+    skipDuplicates?: boolean | undefined;
+}, {
+    data: Prisma.AppointmentCreateManyUserInput | Prisma.AppointmentCreateManyUserInput[];
+    skipDuplicates?: boolean | undefined;
+}>;
+//# sourceMappingURL=AppointmentCreateManyUserInputEnvelope.schema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"AppointmentCreateManyUserInputEnvelope.schema.d.ts","sourceRoot":"","sources":["AppointmentCreateManyUserInputEnvelope.schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AACzB,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,2BAA2B,CAAC;AAOxD,eAAO,MAAM,kDAAkD,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,sCAAsC,CAAuF,CAAC;AAChN,eAAO,MAAM,qDAAqD;;;;;;;;;EAAe,CAAC"}

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

@@ -0,0 +1,44 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppointmentCreateManyUserInputEnvelopeObjectZodSchema = exports.AppointmentCreateManyUserInputEnvelopeObjectSchema = void 0;
+const z = __importStar(require("zod"));
+const AppointmentCreateManyUserInput_schema_1 = require("./AppointmentCreateManyUserInput.schema");
+const makeSchema = () => z.object({
+    data: z.union([z.lazy(() => AppointmentCreateManyUserInput_schema_1.AppointmentCreateManyUserInputObjectSchema), z.lazy(() => AppointmentCreateManyUserInput_schema_1.AppointmentCreateManyUserInputObjectSchema).array()]),
+    skipDuplicates: z.boolean().optional()
+}).strict();
+exports.AppointmentCreateManyUserInputEnvelopeObjectSchema = makeSchema();
+exports.AppointmentCreateManyUserInputEnvelopeObjectZodSchema = makeSchema();

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

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

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

@@ -0,0 +1,20 @@
+import * as z from 'zod';
+import type { Prisma } from '../../../generated/prisma';
+export declare const AppointmentCreateNestedManyWithoutPatientInputObjectSchema: z.ZodType<Prisma.AppointmentCreateNestedManyWithoutPatientInput>;
+export declare const AppointmentCreateNestedManyWithoutPatientInputObjectZodSchema: z.ZodObject<{
+    create: z.ZodOptional<z.ZodUnion<[z.ZodLazy<z.ZodType<Prisma.AppointmentCreateWithoutPatientInput, z.ZodTypeDef, Prisma.AppointmentCreateWithoutPatientInput>>, z.ZodArray<z.ZodLazy<z.ZodType<Prisma.AppointmentCreateWithoutPatientInput, z.ZodTypeDef, Prisma.AppointmentCreateWithoutPatientInput>>, "many">, z.ZodLazy<z.ZodType<Prisma.AppointmentUncheckedCreateWithoutPatientInput, z.ZodTypeDef, Prisma.AppointmentUncheckedCreateWithoutPatientInput>>, z.ZodArray<z.ZodLazy<z.ZodType<Prisma.AppointmentUncheckedCreateWithoutPatientInput, z.ZodTypeDef, Prisma.AppointmentUncheckedCreateWithoutPatientInput>>, "many">]>>;
+    connectOrCreate: z.ZodOptional<z.ZodUnion<[z.ZodLazy<z.ZodType<Prisma.AppointmentCreateOrConnectWithoutPatientInput, z.ZodTypeDef, Prisma.AppointmentCreateOrConnectWithoutPatientInput>>, z.ZodArray<z.ZodLazy<z.ZodType<Prisma.AppointmentCreateOrConnectWithoutPatientInput, z.ZodTypeDef, Prisma.AppointmentCreateOrConnectWithoutPatientInput>>, "many">]>>;
+    createMany: z.ZodOptional<z.ZodLazy<z.ZodType<Prisma.AppointmentCreateManyPatientInputEnvelope, z.ZodTypeDef, Prisma.AppointmentCreateManyPatientInputEnvelope>>>;
+    connect: z.ZodOptional<z.ZodUnion<[z.ZodLazy<z.ZodType<Prisma.AppointmentWhereUniqueInput, z.ZodTypeDef, Prisma.AppointmentWhereUniqueInput>>, z.ZodArray<z.ZodLazy<z.ZodType<Prisma.AppointmentWhereUniqueInput, z.ZodTypeDef, Prisma.AppointmentWhereUniqueInput>>, "many">]>>;
+}, "strict", z.ZodTypeAny, {
+    create?: Prisma.AppointmentUncheckedCreateWithoutPatientInput | Prisma.AppointmentCreateWithoutPatientInput | Prisma.AppointmentCreateWithoutPatientInput[] | Prisma.AppointmentUncheckedCreateWithoutPatientInput[] | undefined;
+    connectOrCreate?: Prisma.AppointmentCreateOrConnectWithoutPatientInput | Prisma.AppointmentCreateOrConnectWithoutPatientInput[] | undefined;
+    createMany?: Prisma.AppointmentCreateManyPatientInputEnvelope | undefined;
+    connect?: Prisma.AppointmentWhereUniqueInput | Prisma.AppointmentWhereUniqueInput[] | undefined;
+}, {
+    create?: Prisma.AppointmentUncheckedCreateWithoutPatientInput | Prisma.AppointmentCreateWithoutPatientInput | Prisma.AppointmentCreateWithoutPatientInput[] | Prisma.AppointmentUncheckedCreateWithoutPatientInput[] | undefined;
+    connectOrCreate?: Prisma.AppointmentCreateOrConnectWithoutPatientInput | Prisma.AppointmentCreateOrConnectWithoutPatientInput[] | undefined;
+    createMany?: Prisma.AppointmentCreateManyPatientInputEnvelope | undefined;
+    connect?: Prisma.AppointmentWhereUniqueInput | Prisma.AppointmentWhereUniqueInput[] | undefined;
+}>;
+//# sourceMappingURL=AppointmentCreateNestedManyWithoutPatientInput.schema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"AppointmentCreateNestedManyWithoutPatientInput.schema.d.ts","sourceRoot":"","sources":["AppointmentCreateNestedManyWithoutPatientInput.schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AACzB,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,2BAA2B,CAAC;AAaxD,eAAO,MAAM,0DAA0D,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,8CAA8C,CAA+F,CAAC;AACxO,eAAO,MAAM,6DAA6D;;;;;;;;;;;;;;;EAAe,CAAC"}

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

@@ -0,0 +1,50 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppointmentCreateNestedManyWithoutPatientInputObjectZodSchema = exports.AppointmentCreateNestedManyWithoutPatientInputObjectSchema = void 0;
+const z = __importStar(require("zod"));
+const AppointmentCreateWithoutPatientInput_schema_1 = require("./AppointmentCreateWithoutPatientInput.schema");
+const AppointmentUncheckedCreateWithoutPatientInput_schema_1 = require("./AppointmentUncheckedCreateWithoutPatientInput.schema");
+const AppointmentCreateOrConnectWithoutPatientInput_schema_1 = require("./AppointmentCreateOrConnectWithoutPatientInput.schema");
+const AppointmentCreateManyPatientInputEnvelope_schema_1 = require("./AppointmentCreateManyPatientInputEnvelope.schema");
+const AppointmentWhereUniqueInput_schema_1 = require("./AppointmentWhereUniqueInput.schema");
+const makeSchema = () => z.object({
+    create: z.union([z.lazy(() => AppointmentCreateWithoutPatientInput_schema_1.AppointmentCreateWithoutPatientInputObjectSchema), z.lazy(() => AppointmentCreateWithoutPatientInput_schema_1.AppointmentCreateWithoutPatientInputObjectSchema).array(), z.lazy(() => AppointmentUncheckedCreateWithoutPatientInput_schema_1.AppointmentUncheckedCreateWithoutPatientInputObjectSchema), z.lazy(() => AppointmentUncheckedCreateWithoutPatientInput_schema_1.AppointmentUncheckedCreateWithoutPatientInputObjectSchema).array()]).optional(),
+    connectOrCreate: z.union([z.lazy(() => AppointmentCreateOrConnectWithoutPatientInput_schema_1.AppointmentCreateOrConnectWithoutPatientInputObjectSchema), z.lazy(() => AppointmentCreateOrConnectWithoutPatientInput_schema_1.AppointmentCreateOrConnectWithoutPatientInputObjectSchema).array()]).optional(),
+    createMany: z.lazy(() => AppointmentCreateManyPatientInputEnvelope_schema_1.AppointmentCreateManyPatientInputEnvelopeObjectSchema).optional(),
+    connect: z.union([z.lazy(() => AppointmentWhereUniqueInput_schema_1.AppointmentWhereUniqueInputObjectSchema), z.lazy(() => AppointmentWhereUniqueInput_schema_1.AppointmentWhereUniqueInputObjectSchema).array()]).optional()
+}).strict();
+exports.AppointmentCreateNestedManyWithoutPatientInputObjectSchema = makeSchema();
+exports.AppointmentCreateNestedManyWithoutPatientInputObjectZodSchema = makeSchema();

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

@@ -0,0 +1,16 @@
+import * as z from 'zod';
+import type { Prisma } from '../../../generated/prisma';
+import { AppointmentCreateWithoutPatientInputObjectSchema as AppointmentCreateWithoutPatientInputObjectSchema } from './AppointmentCreateWithoutPatientInput.schema';
+import { AppointmentUncheckedCreateWithoutPatientInputObjectSchema as AppointmentUncheckedCreateWithoutPatientInputObjectSchema } from './AppointmentUncheckedCreateWithoutPatientInput.schema';
+import { AppointmentCreateOrConnectWithoutPatientInputObjectSchema as AppointmentCreateOrConnectWithoutPatientInputObjectSchema } from './AppointmentCreateOrConnectWithoutPatientInput.schema';
+import { AppointmentCreateManyPatientInputEnvelopeObjectSchema as AppointmentCreateManyPatientInputEnvelopeObjectSchema } from './AppointmentCreateManyPatientInputEnvelope.schema';
+import { AppointmentWhereUniqueInputObjectSchema as AppointmentWhereUniqueInputObjectSchema } from './AppointmentWhereUniqueInput.schema'
+
+const makeSchema = () => 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: z.ZodType<Prisma.AppointmentCreateNestedManyWithoutPatientInput> = makeSchema() as unknown as z.ZodType<Prisma.AppointmentCreateNestedManyWithoutPatientInput>;
+export const AppointmentCreateNestedManyWithoutPatientInputObjectZodSchema = makeSchema();

packages/db/shared/schemas/objects/AppointmentCreateNestedManyWithoutStaffInput.schema.d.ts

@@ -0,0 +1,20 @@
+import * as z from 'zod';
+import type { Prisma } from '../../../generated/prisma';
+export declare const AppointmentCreateNestedManyWithoutStaffInputObjectSchema: z.ZodType<Prisma.AppointmentCreateNestedManyWithoutStaffInput>;
+export declare const AppointmentCreateNestedManyWithoutStaffInputObjectZodSchema: z.ZodObject<{
+    create: z.ZodOptional<z.ZodUnion<[z.ZodLazy<z.ZodType<Prisma.AppointmentCreateWithoutStaffInput, z.ZodTypeDef, Prisma.AppointmentCreateWithoutStaffInput>>, z.ZodArray<z.ZodLazy<z.ZodType<Prisma.AppointmentCreateWithoutStaffInput, z.ZodTypeDef, Prisma.AppointmentCreateWithoutStaffInput>>, "many">, z.ZodLazy<z.ZodType<Prisma.AppointmentUncheckedCreateWithoutStaffInput, z.ZodTypeDef, Prisma.AppointmentUncheckedCreateWithoutStaffInput>>, z.ZodArray<z.ZodLazy<z.ZodType<Prisma.AppointmentUncheckedCreateWithoutStaffInput, z.ZodTypeDef, Prisma.AppointmentUncheckedCreateWithoutStaffInput>>, "many">]>>;
+    connectOrCreate: z.ZodOptional<z.ZodUnion<[z.ZodLazy<z.ZodType<Prisma.AppointmentCreateOrConnectWithoutStaffInput, z.ZodTypeDef, Prisma.AppointmentCreateOrConnectWithoutStaffInput>>, z.ZodArray<z.ZodLazy<z.ZodType<Prisma.AppointmentCreateOrConnectWithoutStaffInput, z.ZodTypeDef, Prisma.AppointmentCreateOrConnectWithoutStaffInput>>, "many">]>>;
+    createMany: z.ZodOptional<z.ZodLazy<z.ZodType<Prisma.AppointmentCreateManyStaffInputEnvelope, z.ZodTypeDef, Prisma.AppointmentCreateManyStaffInputEnvelope>>>;
+    connect: z.ZodOptional<z.ZodUnion<[z.ZodLazy<z.ZodType<Prisma.AppointmentWhereUniqueInput, z.ZodTypeDef, Prisma.AppointmentWhereUniqueInput>>, z.ZodArray<z.ZodLazy<z.ZodType<Prisma.AppointmentWhereUniqueInput, z.ZodTypeDef, Prisma.AppointmentWhereUniqueInput>>, "many">]>>;
+}, "strict", z.ZodTypeAny, {
+    create?: Prisma.AppointmentUncheckedCreateWithoutStaffInput | Prisma.AppointmentCreateWithoutStaffInput | Prisma.AppointmentCreateWithoutStaffInput[] | Prisma.AppointmentUncheckedCreateWithoutStaffInput[] | undefined;
+    connectOrCreate?: Prisma.AppointmentCreateOrConnectWithoutStaffInput | Prisma.AppointmentCreateOrConnectWithoutStaffInput[] | undefined;
+    createMany?: Prisma.AppointmentCreateManyStaffInputEnvelope | undefined;
+    connect?: Prisma.AppointmentWhereUniqueInput | Prisma.AppointmentWhereUniqueInput[] | undefined;
+}, {
+    create?: Prisma.AppointmentUncheckedCreateWithoutStaffInput | Prisma.AppointmentCreateWithoutStaffInput | Prisma.AppointmentCreateWithoutStaffInput[] | Prisma.AppointmentUncheckedCreateWithoutStaffInput[] | undefined;
+    connectOrCreate?: Prisma.AppointmentCreateOrConnectWithoutStaffInput | Prisma.AppointmentCreateOrConnectWithoutStaffInput[] | undefined;
+    createMany?: Prisma.AppointmentCreateManyStaffInputEnvelope | undefined;
+    connect?: Prisma.AppointmentWhereUniqueInput | Prisma.AppointmentWhereUniqueInput[] | undefined;
+}>;
+//# sourceMappingURL=AppointmentCreateNestedManyWithoutStaffInput.schema.d.ts.map

packages/db/shared/schemas/objects/AppointmentCreateNestedManyWithoutStaffInput.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AppointmentCreateNestedManyWithoutStaffInput.schema.d.ts","sourceRoot":"","sources":["AppointmentCreateNestedManyWithoutStaffInput.schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AACzB,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,2BAA2B,CAAC;AAaxD,eAAO,MAAM,wDAAwD,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,4CAA4C,CAA6F,CAAC;AAClO,eAAO,MAAM,2DAA2D;;;;;;;;;;;;;;;EAAe,CAAC"}

packages/db/shared/schemas/objects/AppointmentCreateNestedManyWithoutStaffInput.schema.js

@@ -0,0 +1,50 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppointmentCreateNestedManyWithoutStaffInputObjectZodSchema = exports.AppointmentCreateNestedManyWithoutStaffInputObjectSchema = void 0;
+const z = __importStar(require("zod"));
+const AppointmentCreateWithoutStaffInput_schema_1 = require("./AppointmentCreateWithoutStaffInput.schema");
+const AppointmentUncheckedCreateWithoutStaffInput_schema_1 = require("./AppointmentUncheckedCreateWithoutStaffInput.schema");
+const AppointmentCreateOrConnectWithoutStaffInput_schema_1 = require("./AppointmentCreateOrConnectWithoutStaffInput.schema");
+const AppointmentCreateManyStaffInputEnvelope_schema_1 = require("./AppointmentCreateManyStaffInputEnvelope.schema");
+const AppointmentWhereUniqueInput_schema_1 = require("./AppointmentWhereUniqueInput.schema");
+const makeSchema = () => z.object({
+    create: z.union([z.lazy(() => AppointmentCreateWithoutStaffInput_schema_1.AppointmentCreateWithoutStaffInputObjectSchema), z.lazy(() => AppointmentCreateWithoutStaffInput_schema_1.AppointmentCreateWithoutStaffInputObjectSchema).array(), z.lazy(() => AppointmentUncheckedCreateWithoutStaffInput_schema_1.AppointmentUncheckedCreateWithoutStaffInputObjectSchema), z.lazy(() => AppointmentUncheckedCreateWithoutStaffInput_schema_1.AppointmentUncheckedCreateWithoutStaffInputObjectSchema).array()]).optional(),
+    connectOrCreate: z.union([z.lazy(() => AppointmentCreateOrConnectWithoutStaffInput_schema_1.AppointmentCreateOrConnectWithoutStaffInputObjectSchema), z.lazy(() => AppointmentCreateOrConnectWithoutStaffInput_schema_1.AppointmentCreateOrConnectWithoutStaffInputObjectSchema).array()]).optional(),
+    createMany: z.lazy(() => AppointmentCreateManyStaffInputEnvelope_schema_1.AppointmentCreateManyStaffInputEnvelopeObjectSchema).optional(),
+    connect: z.union([z.lazy(() => AppointmentWhereUniqueInput_schema_1.AppointmentWhereUniqueInputObjectSchema), z.lazy(() => AppointmentWhereUniqueInput_schema_1.AppointmentWhereUniqueInputObjectSchema).array()]).optional()
+}).strict();
+exports.AppointmentCreateNestedManyWithoutStaffInputObjectSchema = makeSchema();
+exports.AppointmentCreateNestedManyWithoutStaffInputObjectZodSchema = makeSchema();

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

@@ -0,0 +1,16 @@
+import * as z from 'zod';
+import type { Prisma } from '../../../generated/prisma';
+import { AppointmentCreateWithoutStaffInputObjectSchema as AppointmentCreateWithoutStaffInputObjectSchema } from './AppointmentCreateWithoutStaffInput.schema';
+import { AppointmentUncheckedCreateWithoutStaffInputObjectSchema as AppointmentUncheckedCreateWithoutStaffInputObjectSchema } from './AppointmentUncheckedCreateWithoutStaffInput.schema';
+import { AppointmentCreateOrConnectWithoutStaffInputObjectSchema as AppointmentCreateOrConnectWithoutStaffInputObjectSchema } from './AppointmentCreateOrConnectWithoutStaffInput.schema';
+import { AppointmentCreateManyStaffInputEnvelopeObjectSchema as AppointmentCreateManyStaffInputEnvelopeObjectSchema } from './AppointmentCreateManyStaffInputEnvelope.schema';
+import { AppointmentWhereUniqueInputObjectSchema as AppointmentWhereUniqueInputObjectSchema } from './AppointmentWhereUniqueInput.schema'
+
+const makeSchema = () => z.object({
+  create: z.union([z.lazy(() => AppointmentCreateWithoutStaffInputObjectSchema), z.lazy(() => AppointmentCreateWithoutStaffInputObjectSchema).array(), z.lazy(() => AppointmentUncheckedCreateWithoutStaffInputObjectSchema), z.lazy(() => AppointmentUncheckedCreateWithoutStaffInputObjectSchema).array()]).optional(),
+  connectOrCreate: z.union([z.lazy(() => AppointmentCreateOrConnectWithoutStaffInputObjectSchema), z.lazy(() => AppointmentCreateOrConnectWithoutStaffInputObjectSchema).array()]).optional(),
+  createMany: z.lazy(() => AppointmentCreateManyStaffInputEnvelopeObjectSchema).optional(),
+  connect: z.union([z.lazy(() => AppointmentWhereUniqueInputObjectSchema), z.lazy(() => AppointmentWhereUniqueInputObjectSchema).array()]).optional()
+}).strict();
+export const AppointmentCreateNestedManyWithoutStaffInputObjectSchema: z.ZodType<Prisma.AppointmentCreateNestedManyWithoutStaffInput> = makeSchema() as unknown as z.ZodType<Prisma.AppointmentCreateNestedManyWithoutStaffInput>;
+export const AppointmentCreateNestedManyWithoutStaffInputObjectZodSchema = makeSchema();

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

@@ -0,0 +1,20 @@
+import * as z from 'zod';
+import type { Prisma } from '../../../generated/prisma';
+export declare const AppointmentCreateNestedManyWithoutUserInputObjectSchema: z.ZodType<Prisma.AppointmentCreateNestedManyWithoutUserInput>;
+export declare const AppointmentCreateNestedManyWithoutUserInputObjectZodSchema: z.ZodObject<{
+    create: z.ZodOptional<z.ZodUnion<[z.ZodLazy<z.ZodType<Prisma.AppointmentCreateWithoutUserInput, z.ZodTypeDef, Prisma.AppointmentCreateWithoutUserInput>>, z.ZodArray<z.ZodLazy<z.ZodType<Prisma.AppointmentCreateWithoutUserInput, z.ZodTypeDef, Prisma.AppointmentCreateWithoutUserInput>>, "many">, z.ZodLazy<z.ZodType<Prisma.AppointmentUncheckedCreateWithoutUserInput, z.ZodTypeDef, Prisma.AppointmentUncheckedCreateWithoutUserInput>>, z.ZodArray<z.ZodLazy<z.ZodType<Prisma.AppointmentUncheckedCreateWithoutUserInput, z.ZodTypeDef, Prisma.AppointmentUncheckedCreateWithoutUserInput>>, "many">]>>;
+    connectOrCreate: z.ZodOptional<z.ZodUnion<[z.ZodLazy<z.ZodType<Prisma.AppointmentCreateOrConnectWithoutUserInput, z.ZodTypeDef, Prisma.AppointmentCreateOrConnectWithoutUserInput>>, z.ZodArray<z.ZodLazy<z.ZodType<Prisma.AppointmentCreateOrConnectWithoutUserInput, z.ZodTypeDef, Prisma.AppointmentCreateOrConnectWithoutUserInput>>, "many">]>>;
+    createMany: z.ZodOptional<z.ZodLazy<z.ZodType<Prisma.AppointmentCreateManyUserInputEnvelope, z.ZodTypeDef, Prisma.AppointmentCreateManyUserInputEnvelope>>>;
+    connect: z.ZodOptional<z.ZodUnion<[z.ZodLazy<z.ZodType<Prisma.AppointmentWhereUniqueInput, z.ZodTypeDef, Prisma.AppointmentWhereUniqueInput>>, z.ZodArray<z.ZodLazy<z.ZodType<Prisma.AppointmentWhereUniqueInput, z.ZodTypeDef, Prisma.AppointmentWhereUniqueInput>>, "many">]>>;
+}, "strict", z.ZodTypeAny, {
+    create?: Prisma.AppointmentUncheckedCreateWithoutUserInput | Prisma.AppointmentCreateWithoutUserInput | Prisma.AppointmentCreateWithoutUserInput[] | Prisma.AppointmentUncheckedCreateWithoutUserInput[] | undefined;
+    connectOrCreate?: Prisma.AppointmentCreateOrConnectWithoutUserInput | Prisma.AppointmentCreateOrConnectWithoutUserInput[] | undefined;
+    createMany?: Prisma.AppointmentCreateManyUserInputEnvelope | undefined;
+    connect?: Prisma.AppointmentWhereUniqueInput | Prisma.AppointmentWhereUniqueInput[] | undefined;
+}, {
+    create?: Prisma.AppointmentUncheckedCreateWithoutUserInput | Prisma.AppointmentCreateWithoutUserInput | Prisma.AppointmentCreateWithoutUserInput[] | Prisma.AppointmentUncheckedCreateWithoutUserInput[] | undefined;
+    connectOrCreate?: Prisma.AppointmentCreateOrConnectWithoutUserInput | Prisma.AppointmentCreateOrConnectWithoutUserInput[] | undefined;
+    createMany?: Prisma.AppointmentCreateManyUserInputEnvelope | undefined;
+    connect?: Prisma.AppointmentWhereUniqueInput | Prisma.AppointmentWhereUniqueInput[] | undefined;
+}>;
+//# sourceMappingURL=AppointmentCreateNestedManyWithoutUserInput.schema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"AppointmentCreateNestedManyWithoutUserInput.schema.d.ts","sourceRoot":"","sources":["AppointmentCreateNestedManyWithoutUserInput.schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AACzB,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,2BAA2B,CAAC;AAaxD,eAAO,MAAM,uDAAuD,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,2CAA2C,CAA4F,CAAC;AAC/N,eAAO,MAAM,0DAA0D;;;;;;;;;;;;;;;EAAe,CAAC"}

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

@@ -0,0 +1,50 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppointmentCreateNestedManyWithoutUserInputObjectZodSchema = exports.AppointmentCreateNestedManyWithoutUserInputObjectSchema = void 0;
+const z = __importStar(require("zod"));
+const AppointmentCreateWithoutUserInput_schema_1 = require("./AppointmentCreateWithoutUserInput.schema");
+const AppointmentUncheckedCreateWithoutUserInput_schema_1 = require("./AppointmentUncheckedCreateWithoutUserInput.schema");
+const AppointmentCreateOrConnectWithoutUserInput_schema_1 = require("./AppointmentCreateOrConnectWithoutUserInput.schema");
+const AppointmentCreateManyUserInputEnvelope_schema_1 = require("./AppointmentCreateManyUserInputEnvelope.schema");
+const AppointmentWhereUniqueInput_schema_1 = require("./AppointmentWhereUniqueInput.schema");
+const makeSchema = () => z.object({
+    create: z.union([z.lazy(() => AppointmentCreateWithoutUserInput_schema_1.AppointmentCreateWithoutUserInputObjectSchema), z.lazy(() => AppointmentCreateWithoutUserInput_schema_1.AppointmentCreateWithoutUserInputObjectSchema).array(), z.lazy(() => AppointmentUncheckedCreateWithoutUserInput_schema_1.AppointmentUncheckedCreateWithoutUserInputObjectSchema), z.lazy(() => AppointmentUncheckedCreateWithoutUserInput_schema_1.AppointmentUncheckedCreateWithoutUserInputObjectSchema).array()]).optional(),
+    connectOrCreate: z.union([z.lazy(() => AppointmentCreateOrConnectWithoutUserInput_schema_1.AppointmentCreateOrConnectWithoutUserInputObjectSchema), z.lazy(() => AppointmentCreateOrConnectWithoutUserInput_schema_1.AppointmentCreateOrConnectWithoutUserInputObjectSchema).array()]).optional(),
+    createMany: z.lazy(() => AppointmentCreateManyUserInputEnvelope_schema_1.AppointmentCreateManyUserInputEnvelopeObjectSchema).optional(),
+    connect: z.union([z.lazy(() => AppointmentWhereUniqueInput_schema_1.AppointmentWhereUniqueInputObjectSchema), z.lazy(() => AppointmentWhereUniqueInput_schema_1.AppointmentWhereUniqueInputObjectSchema).array()]).optional()
+}).strict();
+exports.AppointmentCreateNestedManyWithoutUserInputObjectSchema = makeSchema();
+exports.AppointmentCreateNestedManyWithoutUserInputObjectZodSchema = makeSchema();

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

@@ -0,0 +1,16 @@
+import * as z from 'zod';
+import type { Prisma } from '../../../generated/prisma';
+import { AppointmentCreateWithoutUserInputObjectSchema as AppointmentCreateWithoutUserInputObjectSchema } from './AppointmentCreateWithoutUserInput.schema';
+import { AppointmentUncheckedCreateWithoutUserInputObjectSchema as AppointmentUncheckedCreateWithoutUserInputObjectSchema } from './AppointmentUncheckedCreateWithoutUserInput.schema';
+import { AppointmentCreateOrConnectWithoutUserInputObjectSchema as AppointmentCreateOrConnectWithoutUserInputObjectSchema } from './AppointmentCreateOrConnectWithoutUserInput.schema';
+import { AppointmentCreateManyUserInputEnvelopeObjectSchema as AppointmentCreateManyUserInputEnvelopeObjectSchema } from './AppointmentCreateManyUserInputEnvelope.schema';
+import { AppointmentWhereUniqueInputObjectSchema as AppointmentWhereUniqueInputObjectSchema } from './AppointmentWhereUniqueInput.schema'
+
+const makeSchema = () => 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: z.ZodType<Prisma.AppointmentCreateNestedManyWithoutUserInput> = makeSchema() as unknown as z.ZodType<Prisma.AppointmentCreateNestedManyWithoutUserInput>;
+export const AppointmentCreateNestedManyWithoutUserInputObjectZodSchema = makeSchema();

packages/db/shared/schemas/objects/AppointmentCreateNestedOneWithoutClaimsInput.schema.d.ts

@@ -0,0 +1,17 @@
+import * as z from 'zod';
+import type { Prisma } from '../../../generated/prisma';
+export declare const AppointmentCreateNestedOneWithoutClaimsInputObjectSchema: z.ZodType<Prisma.AppointmentCreateNestedOneWithoutClaimsInput>;
+export declare const AppointmentCreateNestedOneWithoutClaimsInputObjectZodSchema: z.ZodObject<{
+    create: z.ZodOptional<z.ZodUnion<[z.ZodLazy<z.ZodType<Prisma.AppointmentCreateWithoutClaimsInput, z.ZodTypeDef, Prisma.AppointmentCreateWithoutClaimsInput>>, z.ZodLazy<z.ZodType<Prisma.AppointmentUncheckedCreateWithoutClaimsInput, z.ZodTypeDef, Prisma.AppointmentUncheckedCreateWithoutClaimsInput>>]>>;
+    connectOrCreate: z.ZodOptional<z.ZodLazy<z.ZodType<Prisma.AppointmentCreateOrConnectWithoutClaimsInput, z.ZodTypeDef, Prisma.AppointmentCreateOrConnectWithoutClaimsInput>>>;
+    connect: z.ZodOptional<z.ZodLazy<z.ZodType<Prisma.AppointmentWhereUniqueInput, z.ZodTypeDef, Prisma.AppointmentWhereUniqueInput>>>;
+}, "strict", z.ZodTypeAny, {
+    create?: Prisma.AppointmentCreateWithoutClaimsInput | Prisma.AppointmentUncheckedCreateWithoutClaimsInput | undefined;
+    connectOrCreate?: Prisma.AppointmentCreateOrConnectWithoutClaimsInput | undefined;
+    connect?: Prisma.AppointmentWhereUniqueInput | undefined;
+}, {
+    create?: Prisma.AppointmentCreateWithoutClaimsInput | Prisma.AppointmentUncheckedCreateWithoutClaimsInput | undefined;
+    connectOrCreate?: Prisma.AppointmentCreateOrConnectWithoutClaimsInput | undefined;
+    connect?: Prisma.AppointmentWhereUniqueInput | undefined;
+}>;
+//# sourceMappingURL=AppointmentCreateNestedOneWithoutClaimsInput.schema.d.ts.map

packages/db/shared/schemas/objects/AppointmentCreateNestedOneWithoutClaimsInput.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AppointmentCreateNestedOneWithoutClaimsInput.schema.d.ts","sourceRoot":"","sources":["AppointmentCreateNestedOneWithoutClaimsInput.schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AACzB,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,2BAA2B,CAAC;AAWxD,eAAO,MAAM,wDAAwD,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,4CAA4C,CAA6F,CAAC;AAClO,eAAO,MAAM,2DAA2D;;;;;;;;;;;;EAAe,CAAC"}

packages/db/shared/schemas/objects/AppointmentCreateNestedOneWithoutClaimsInput.schema.js

@@ -0,0 +1,48 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppointmentCreateNestedOneWithoutClaimsInputObjectZodSchema = exports.AppointmentCreateNestedOneWithoutClaimsInputObjectSchema = void 0;
+const z = __importStar(require("zod"));
+const AppointmentCreateWithoutClaimsInput_schema_1 = require("./AppointmentCreateWithoutClaimsInput.schema");
+const AppointmentUncheckedCreateWithoutClaimsInput_schema_1 = require("./AppointmentUncheckedCreateWithoutClaimsInput.schema");
+const AppointmentCreateOrConnectWithoutClaimsInput_schema_1 = require("./AppointmentCreateOrConnectWithoutClaimsInput.schema");
+const AppointmentWhereUniqueInput_schema_1 = require("./AppointmentWhereUniqueInput.schema");
+const makeSchema = () => z.object({
+    create: z.union([z.lazy(() => AppointmentCreateWithoutClaimsInput_schema_1.AppointmentCreateWithoutClaimsInputObjectSchema), z.lazy(() => AppointmentUncheckedCreateWithoutClaimsInput_schema_1.AppointmentUncheckedCreateWithoutClaimsInputObjectSchema)]).optional(),
+    connectOrCreate: z.lazy(() => AppointmentCreateOrConnectWithoutClaimsInput_schema_1.AppointmentCreateOrConnectWithoutClaimsInputObjectSchema).optional(),
+    connect: z.lazy(() => AppointmentWhereUniqueInput_schema_1.AppointmentWhereUniqueInputObjectSchema).optional()
+}).strict();
+exports.AppointmentCreateNestedOneWithoutClaimsInputObjectSchema = makeSchema();
+exports.AppointmentCreateNestedOneWithoutClaimsInputObjectZodSchema = makeSchema();

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

@@ -0,0 +1,14 @@
+import * as z from 'zod';
+import type { Prisma } from '../../../generated/prisma';
+import { AppointmentCreateWithoutClaimsInputObjectSchema as AppointmentCreateWithoutClaimsInputObjectSchema } from './AppointmentCreateWithoutClaimsInput.schema';
+import { AppointmentUncheckedCreateWithoutClaimsInputObjectSchema as AppointmentUncheckedCreateWithoutClaimsInputObjectSchema } from './AppointmentUncheckedCreateWithoutClaimsInput.schema';
+import { AppointmentCreateOrConnectWithoutClaimsInputObjectSchema as AppointmentCreateOrConnectWithoutClaimsInputObjectSchema } from './AppointmentCreateOrConnectWithoutClaimsInput.schema';
+import { AppointmentWhereUniqueInputObjectSchema as AppointmentWhereUniqueInputObjectSchema } from './AppointmentWhereUniqueInput.schema'
+
+const makeSchema = () => z.object({
+  create: z.union([z.lazy(() => AppointmentCreateWithoutClaimsInputObjectSchema), z.lazy(() => AppointmentUncheckedCreateWithoutClaimsInputObjectSchema)]).optional(),
+  connectOrCreate: z.lazy(() => AppointmentCreateOrConnectWithoutClaimsInputObjectSchema).optional(),
+  connect: z.lazy(() => AppointmentWhereUniqueInputObjectSchema).optional()
+}).strict();
+export const AppointmentCreateNestedOneWithoutClaimsInputObjectSchema: z.ZodType<Prisma.AppointmentCreateNestedOneWithoutClaimsInput> = makeSchema() as unknown as z.ZodType<Prisma.AppointmentCreateNestedOneWithoutClaimsInput>;
+export const AppointmentCreateNestedOneWithoutClaimsInputObjectZodSchema = makeSchema();

packages/db/shared/schemas/objects/AppointmentCreateNestedOneWithoutProceduresInput.schema.d.ts

@@ -0,0 +1,17 @@
+import * as z from 'zod';
+import type { Prisma } from '../../../generated/prisma';
+export declare const AppointmentCreateNestedOneWithoutProceduresInputObjectSchema: z.ZodType<Prisma.AppointmentCreateNestedOneWithoutProceduresInput>;
+export declare const AppointmentCreateNestedOneWithoutProceduresInputObjectZodSchema: z.ZodObject<{
+    create: z.ZodOptional<z.ZodUnion<[z.ZodLazy<z.ZodType<Prisma.AppointmentCreateWithoutProceduresInput, z.ZodTypeDef, Prisma.AppointmentCreateWithoutProceduresInput>>, z.ZodLazy<z.ZodType<Prisma.AppointmentUncheckedCreateWithoutProceduresInput, z.ZodTypeDef, Prisma.AppointmentUncheckedCreateWithoutProceduresInput>>]>>;
+    connectOrCreate: z.ZodOptional<z.ZodLazy<z.ZodType<Prisma.AppointmentCreateOrConnectWithoutProceduresInput, z.ZodTypeDef, Prisma.AppointmentCreateOrConnectWithoutProceduresInput>>>;
+    connect: z.ZodOptional<z.ZodLazy<z.ZodType<Prisma.AppointmentWhereUniqueInput, z.ZodTypeDef, Prisma.AppointmentWhereUniqueInput>>>;
+}, "strict", z.ZodTypeAny, {
+    create?: Prisma.AppointmentCreateWithoutProceduresInput | Prisma.AppointmentUncheckedCreateWithoutProceduresInput | undefined;
+    connectOrCreate?: Prisma.AppointmentCreateOrConnectWithoutProceduresInput | undefined;
+    connect?: Prisma.AppointmentWhereUniqueInput | undefined;
+}, {
+    create?: Prisma.AppointmentCreateWithoutProceduresInput | Prisma.AppointmentUncheckedCreateWithoutProceduresInput | undefined;
+    connectOrCreate?: Prisma.AppointmentCreateOrConnectWithoutProceduresInput | undefined;
+    connect?: Prisma.AppointmentWhereUniqueInput | undefined;
+}>;
+//# sourceMappingURL=AppointmentCreateNestedOneWithoutProceduresInput.schema.d.ts.map

packages/db/shared/schemas/objects/AppointmentCreateNestedOneWithoutProceduresInput.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AppointmentCreateNestedOneWithoutProceduresInput.schema.d.ts","sourceRoot":"","sources":["AppointmentCreateNestedOneWithoutProceduresInput.schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AACzB,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,2BAA2B,CAAC;AAWxD,eAAO,MAAM,4DAA4D,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,gDAAgD,CAAiG,CAAC;AAC9O,eAAO,MAAM,+DAA+D;;;;;;;;;;;;EAAe,CAAC"}

packages/db/shared/schemas/objects/AppointmentCreateNestedOneWithoutProceduresInput.schema.js

@@ -0,0 +1,48 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppointmentCreateNestedOneWithoutProceduresInputObjectZodSchema = exports.AppointmentCreateNestedOneWithoutProceduresInputObjectSchema = void 0;
+const z = __importStar(require("zod"));
+const AppointmentCreateWithoutProceduresInput_schema_1 = require("./AppointmentCreateWithoutProceduresInput.schema");
+const AppointmentUncheckedCreateWithoutProceduresInput_schema_1 = require("./AppointmentUncheckedCreateWithoutProceduresInput.schema");
+const AppointmentCreateOrConnectWithoutProceduresInput_schema_1 = require("./AppointmentCreateOrConnectWithoutProceduresInput.schema");
+const AppointmentWhereUniqueInput_schema_1 = require("./AppointmentWhereUniqueInput.schema");
+const makeSchema = () => z.object({
+    create: z.union([z.lazy(() => AppointmentCreateWithoutProceduresInput_schema_1.AppointmentCreateWithoutProceduresInputObjectSchema), z.lazy(() => AppointmentUncheckedCreateWithoutProceduresInput_schema_1.AppointmentUncheckedCreateWithoutProceduresInputObjectSchema)]).optional(),
+    connectOrCreate: z.lazy(() => AppointmentCreateOrConnectWithoutProceduresInput_schema_1.AppointmentCreateOrConnectWithoutProceduresInputObjectSchema).optional(),
+    connect: z.lazy(() => AppointmentWhereUniqueInput_schema_1.AppointmentWhereUniqueInputObjectSchema).optional()
+}).strict();
+exports.AppointmentCreateNestedOneWithoutProceduresInputObjectSchema = makeSchema();
+exports.AppointmentCreateNestedOneWithoutProceduresInputObjectZodSchema = makeSchema();

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

@@ -0,0 +1,14 @@
+import * as z from 'zod';
+import type { Prisma } from '../../../generated/prisma';
+import { AppointmentCreateWithoutProceduresInputObjectSchema as AppointmentCreateWithoutProceduresInputObjectSchema } from './AppointmentCreateWithoutProceduresInput.schema';
+import { AppointmentUncheckedCreateWithoutProceduresInputObjectSchema as AppointmentUncheckedCreateWithoutProceduresInputObjectSchema } from './AppointmentUncheckedCreateWithoutProceduresInput.schema';
+import { AppointmentCreateOrConnectWithoutProceduresInputObjectSchema as AppointmentCreateOrConnectWithoutProceduresInputObjectSchema } from './AppointmentCreateOrConnectWithoutProceduresInput.schema';
+import { AppointmentWhereUniqueInputObjectSchema as AppointmentWhereUniqueInputObjectSchema } from './AppointmentWhereUniqueInput.schema'
+
+const makeSchema = () => z.object({
+  create: z.union([z.lazy(() => AppointmentCreateWithoutProceduresInputObjectSchema), z.lazy(() => AppointmentUncheckedCreateWithoutProceduresInputObjectSchema)]).optional(),
+  connectOrCreate: z.lazy(() => AppointmentCreateOrConnectWithoutProceduresInputObjectSchema).optional(),
+  connect: z.lazy(() => AppointmentWhereUniqueInputObjectSchema).optional()
+}).strict();
+export const AppointmentCreateNestedOneWithoutProceduresInputObjectSchema: z.ZodType<Prisma.AppointmentCreateNestedOneWithoutProceduresInput> = makeSchema() as unknown as z.ZodType<Prisma.AppointmentCreateNestedOneWithoutProceduresInput>;
+export const AppointmentCreateNestedOneWithoutProceduresInputObjectZodSchema = makeSchema();

packages/db/shared/schemas/objects/AppointmentCreateOrConnectWithoutClaimsInput.schema.d.ts

@@ -0,0 +1,14 @@
+import * as z from 'zod';
+import type { Prisma } from '../../../generated/prisma';
+export declare const AppointmentCreateOrConnectWithoutClaimsInputObjectSchema: z.ZodType<Prisma.AppointmentCreateOrConnectWithoutClaimsInput>;
+export declare const AppointmentCreateOrConnectWithoutClaimsInputObjectZodSchema: z.ZodObject<{
+    where: z.ZodLazy<z.ZodType<Prisma.AppointmentWhereUniqueInput, z.ZodTypeDef, Prisma.AppointmentWhereUniqueInput>>;
+    create: z.ZodUnion<[z.ZodLazy<z.ZodType<Prisma.AppointmentCreateWithoutClaimsInput, z.ZodTypeDef, Prisma.AppointmentCreateWithoutClaimsInput>>, z.ZodLazy<z.ZodType<Prisma.AppointmentUncheckedCreateWithoutClaimsInput, z.ZodTypeDef, Prisma.AppointmentUncheckedCreateWithoutClaimsInput>>]>;
+}, "strict", z.ZodTypeAny, {
+    create: Prisma.AppointmentCreateWithoutClaimsInput | Prisma.AppointmentUncheckedCreateWithoutClaimsInput;
+    where: Prisma.AppointmentWhereUniqueInput;
+}, {
+    create: Prisma.AppointmentCreateWithoutClaimsInput | Prisma.AppointmentUncheckedCreateWithoutClaimsInput;
+    where: Prisma.AppointmentWhereUniqueInput;
+}>;
+//# sourceMappingURL=AppointmentCreateOrConnectWithoutClaimsInput.schema.d.ts.map

packages/db/shared/schemas/objects/AppointmentCreateOrConnectWithoutClaimsInput.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AppointmentCreateOrConnectWithoutClaimsInput.schema.d.ts","sourceRoot":"","sources":["AppointmentCreateOrConnectWithoutClaimsInput.schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AACzB,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,2BAA2B,CAAC;AASxD,eAAO,MAAM,wDAAwD,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,4CAA4C,CAA6F,CAAC;AAClO,eAAO,MAAM,2DAA2D;;;;;;;;;EAAe,CAAC"}

packages/db/shared/schemas/objects/AppointmentCreateOrConnectWithoutClaimsInput.schema.js

@@ -0,0 +1,46 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppointmentCreateOrConnectWithoutClaimsInputObjectZodSchema = exports.AppointmentCreateOrConnectWithoutClaimsInputObjectSchema = void 0;
+const z = __importStar(require("zod"));
+const AppointmentWhereUniqueInput_schema_1 = require("./AppointmentWhereUniqueInput.schema");
+const AppointmentCreateWithoutClaimsInput_schema_1 = require("./AppointmentCreateWithoutClaimsInput.schema");
+const AppointmentUncheckedCreateWithoutClaimsInput_schema_1 = require("./AppointmentUncheckedCreateWithoutClaimsInput.schema");
+const makeSchema = () => z.object({
+    where: z.lazy(() => AppointmentWhereUniqueInput_schema_1.AppointmentWhereUniqueInputObjectSchema),
+    create: z.union([z.lazy(() => AppointmentCreateWithoutClaimsInput_schema_1.AppointmentCreateWithoutClaimsInputObjectSchema), z.lazy(() => AppointmentUncheckedCreateWithoutClaimsInput_schema_1.AppointmentUncheckedCreateWithoutClaimsInputObjectSchema)])
+}).strict();
+exports.AppointmentCreateOrConnectWithoutClaimsInputObjectSchema = makeSchema();
+exports.AppointmentCreateOrConnectWithoutClaimsInputObjectZodSchema = makeSchema();

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

@@ -0,0 +1,12 @@
+import * as z from 'zod';
+import type { Prisma } from '../../../generated/prisma';
+import { AppointmentWhereUniqueInputObjectSchema as AppointmentWhereUniqueInputObjectSchema } from './AppointmentWhereUniqueInput.schema';
+import { AppointmentCreateWithoutClaimsInputObjectSchema as AppointmentCreateWithoutClaimsInputObjectSchema } from './AppointmentCreateWithoutClaimsInput.schema';
+import { AppointmentUncheckedCreateWithoutClaimsInputObjectSchema as AppointmentUncheckedCreateWithoutClaimsInputObjectSchema } from './AppointmentUncheckedCreateWithoutClaimsInput.schema'
+
+const makeSchema = () => z.object({
+  where: z.lazy(() => AppointmentWhereUniqueInputObjectSchema),
+  create: z.union([z.lazy(() => AppointmentCreateWithoutClaimsInputObjectSchema), z.lazy(() => AppointmentUncheckedCreateWithoutClaimsInputObjectSchema)])
+}).strict();
+export const AppointmentCreateOrConnectWithoutClaimsInputObjectSchema: z.ZodType<Prisma.AppointmentCreateOrConnectWithoutClaimsInput> = makeSchema() as unknown as z.ZodType<Prisma.AppointmentCreateOrConnectWithoutClaimsInput>;
+export const AppointmentCreateOrConnectWithoutClaimsInputObjectZodSchema = makeSchema();

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

@@ -0,0 +1,14 @@
+import * as z from 'zod';
+import type { Prisma } from '../../../generated/prisma';
+export declare const AppointmentCreateOrConnectWithoutPatientInputObjectSchema: z.ZodType<Prisma.AppointmentCreateOrConnectWithoutPatientInput>;
+export declare const AppointmentCreateOrConnectWithoutPatientInputObjectZodSchema: z.ZodObject<{
+    where: z.ZodLazy<z.ZodType<Prisma.AppointmentWhereUniqueInput, z.ZodTypeDef, Prisma.AppointmentWhereUniqueInput>>;
+    create: z.ZodUnion<[z.ZodLazy<z.ZodType<Prisma.AppointmentCreateWithoutPatientInput, z.ZodTypeDef, Prisma.AppointmentCreateWithoutPatientInput>>, z.ZodLazy<z.ZodType<Prisma.AppointmentUncheckedCreateWithoutPatientInput, z.ZodTypeDef, Prisma.AppointmentUncheckedCreateWithoutPatientInput>>]>;
+}, "strict", z.ZodTypeAny, {
+    create: Prisma.AppointmentUncheckedCreateWithoutPatientInput | Prisma.AppointmentCreateWithoutPatientInput;
+    where: Prisma.AppointmentWhereUniqueInput;
+}, {
+    create: Prisma.AppointmentUncheckedCreateWithoutPatientInput | Prisma.AppointmentCreateWithoutPatientInput;
+    where: Prisma.AppointmentWhereUniqueInput;
+}>;
+//# sourceMappingURL=AppointmentCreateOrConnectWithoutPatientInput.schema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"AppointmentCreateOrConnectWithoutPatientInput.schema.d.ts","sourceRoot":"","sources":["AppointmentCreateOrConnectWithoutPatientInput.schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AACzB,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,2BAA2B,CAAC;AASxD,eAAO,MAAM,yDAAyD,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,6CAA6C,CAA8F,CAAC;AACrO,eAAO,MAAM,4DAA4D;;;;;;;;;EAAe,CAAC"}

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

@@ -0,0 +1,46 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppointmentCreateOrConnectWithoutPatientInputObjectZodSchema = exports.AppointmentCreateOrConnectWithoutPatientInputObjectSchema = void 0;
+const z = __importStar(require("zod"));
+const AppointmentWhereUniqueInput_schema_1 = require("./AppointmentWhereUniqueInput.schema");
+const AppointmentCreateWithoutPatientInput_schema_1 = require("./AppointmentCreateWithoutPatientInput.schema");
+const AppointmentUncheckedCreateWithoutPatientInput_schema_1 = require("./AppointmentUncheckedCreateWithoutPatientInput.schema");
+const makeSchema = () => z.object({
+    where: z.lazy(() => AppointmentWhereUniqueInput_schema_1.AppointmentWhereUniqueInputObjectSchema),
+    create: z.union([z.lazy(() => AppointmentCreateWithoutPatientInput_schema_1.AppointmentCreateWithoutPatientInputObjectSchema), z.lazy(() => AppointmentUncheckedCreateWithoutPatientInput_schema_1.AppointmentUncheckedCreateWithoutPatientInputObjectSchema)])
+}).strict();
+exports.AppointmentCreateOrConnectWithoutPatientInputObjectSchema = makeSchema();
+exports.AppointmentCreateOrConnectWithoutPatientInputObjectZodSchema = makeSchema();

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

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

packages/db/shared/schemas/objects/AppointmentCreateOrConnectWithoutProceduresInput.schema.d.ts

@@ -0,0 +1,14 @@
+import * as z from 'zod';
+import type { Prisma } from '../../../generated/prisma';
+export declare const AppointmentCreateOrConnectWithoutProceduresInputObjectSchema: z.ZodType<Prisma.AppointmentCreateOrConnectWithoutProceduresInput>;
+export declare const AppointmentCreateOrConnectWithoutProceduresInputObjectZodSchema: z.ZodObject<{
+    where: z.ZodLazy<z.ZodType<Prisma.AppointmentWhereUniqueInput, z.ZodTypeDef, Prisma.AppointmentWhereUniqueInput>>;
+    create: z.ZodUnion<[z.ZodLazy<z.ZodType<Prisma.AppointmentCreateWithoutProceduresInput, z.ZodTypeDef, Prisma.AppointmentCreateWithoutProceduresInput>>, z.ZodLazy<z.ZodType<Prisma.AppointmentUncheckedCreateWithoutProceduresInput, z.ZodTypeDef, Prisma.AppointmentUncheckedCreateWithoutProceduresInput>>]>;
+}, "strict", z.ZodTypeAny, {
+    create: Prisma.AppointmentCreateWithoutProceduresInput | Prisma.AppointmentUncheckedCreateWithoutProceduresInput;
+    where: Prisma.AppointmentWhereUniqueInput;
+}, {
+    create: Prisma.AppointmentCreateWithoutProceduresInput | Prisma.AppointmentUncheckedCreateWithoutProceduresInput;
+    where: Prisma.AppointmentWhereUniqueInput;
+}>;
+//# sourceMappingURL=AppointmentCreateOrConnectWithoutProceduresInput.schema.d.ts.map

packages/db/shared/schemas/objects/AppointmentCreateOrConnectWithoutProceduresInput.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AppointmentCreateOrConnectWithoutProceduresInput.schema.d.ts","sourceRoot":"","sources":["AppointmentCreateOrConnectWithoutProceduresInput.schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AACzB,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,2BAA2B,CAAC;AASxD,eAAO,MAAM,4DAA4D,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,gDAAgD,CAAiG,CAAC;AAC9O,eAAO,MAAM,+DAA+D;;;;;;;;;EAAe,CAAC"}

packages/db/shared/schemas/objects/AppointmentCreateOrConnectWithoutProceduresInput.schema.js

@@ -0,0 +1,46 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppointmentCreateOrConnectWithoutProceduresInputObjectZodSchema = exports.AppointmentCreateOrConnectWithoutProceduresInputObjectSchema = void 0;
+const z = __importStar(require("zod"));
+const AppointmentWhereUniqueInput_schema_1 = require("./AppointmentWhereUniqueInput.schema");
+const AppointmentCreateWithoutProceduresInput_schema_1 = require("./AppointmentCreateWithoutProceduresInput.schema");
+const AppointmentUncheckedCreateWithoutProceduresInput_schema_1 = require("./AppointmentUncheckedCreateWithoutProceduresInput.schema");
+const makeSchema = () => z.object({
+    where: z.lazy(() => AppointmentWhereUniqueInput_schema_1.AppointmentWhereUniqueInputObjectSchema),
+    create: z.union([z.lazy(() => AppointmentCreateWithoutProceduresInput_schema_1.AppointmentCreateWithoutProceduresInputObjectSchema), z.lazy(() => AppointmentUncheckedCreateWithoutProceduresInput_schema_1.AppointmentUncheckedCreateWithoutProceduresInputObjectSchema)])
+}).strict();
+exports.AppointmentCreateOrConnectWithoutProceduresInputObjectSchema = makeSchema();
+exports.AppointmentCreateOrConnectWithoutProceduresInputObjectZodSchema = makeSchema();

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

@@ -0,0 +1,12 @@
+import * as z from 'zod';
+import type { Prisma } from '../../../generated/prisma';
+import { AppointmentWhereUniqueInputObjectSchema as AppointmentWhereUniqueInputObjectSchema } from './AppointmentWhereUniqueInput.schema';
+import { AppointmentCreateWithoutProceduresInputObjectSchema as AppointmentCreateWithoutProceduresInputObjectSchema } from './AppointmentCreateWithoutProceduresInput.schema';
+import { AppointmentUncheckedCreateWithoutProceduresInputObjectSchema as AppointmentUncheckedCreateWithoutProceduresInputObjectSchema } from './AppointmentUncheckedCreateWithoutProceduresInput.schema'
+
+const makeSchema = () => z.object({
+  where: z.lazy(() => AppointmentWhereUniqueInputObjectSchema),
+  create: z.union([z.lazy(() => AppointmentCreateWithoutProceduresInputObjectSchema), z.lazy(() => AppointmentUncheckedCreateWithoutProceduresInputObjectSchema)])
+}).strict();
+export const AppointmentCreateOrConnectWithoutProceduresInputObjectSchema: z.ZodType<Prisma.AppointmentCreateOrConnectWithoutProceduresInput> = makeSchema() as unknown as z.ZodType<Prisma.AppointmentCreateOrConnectWithoutProceduresInput>;
+export const AppointmentCreateOrConnectWithoutProceduresInputObjectZodSchema = makeSchema();