initial commit

packages/db/shared/helpers/decimal-helpers.d.ts

@@ -0,0 +1,6 @@
+import * as z from 'zod';
+import type { Prisma } from '../../generated/prisma';
+export declare const DecimalJSLikeSchema: z.ZodType<Prisma.DecimalJsLike>;
+export declare const DECIMAL_STRING_REGEX: RegExp;
+export declare const isValidDecimalInput: (v?: null | string | number | Prisma.DecimalJsLike) => v is string | number | Prisma.DecimalJsLike;
+//# sourceMappingURL=decimal-helpers.d.ts.map

packages/db/shared/helpers/decimal-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decimal-helpers.d.ts","sourceRoot":"","sources":["decimal-helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAEzB,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAOrD,eAAO,MAAM,mBAAmB,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,aAAa,CAM9D,CAAC;AAGH,eAAO,MAAM,oBAAoB,QAAuE,CAAC;AAEzG,eAAO,MAAM,mBAAmB,GAC9B,IAAI,IAAI,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,CAAC,aAAa,KAChD,CAAC,IAAI,MAAM,GAAG,MAAM,GAAG,MAAM,CAAC,aAiBhC,CAAC"}

packages/db/shared/helpers/decimal-helpers.js

@@ -0,0 +1,71 @@
+"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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValidDecimalInput = exports.DECIMAL_STRING_REGEX = exports.DecimalJSLikeSchema = void 0;
+const z = __importStar(require("zod"));
+const decimal_js_1 = __importDefault(require("decimal.js"));
+// DECIMAL HELPERS
+//------------------------------------------------------
+exports.DecimalJSLikeSchema = z.object({
+    d: z.array(z.number()),
+    e: z.number(),
+    s: z.number(),
+    // Zod v3/v4 compatible callable check
+    toFixed: z.custom((v) => typeof v === 'function'),
+});
+// Accept canonical decimal strings (+/-, optional fraction, optional exponent), or Infinity/NaN.
+exports.DECIMAL_STRING_REGEX = /^(?:[+-]?(?:[0-9]+(?:.[0-9]+)?(?:[eE][+-]?[0-9]+)?|Infinity)|NaN)$/;
+const isValidDecimalInput = (v) => {
+    if (v === undefined || v === null)
+        return false;
+    return (
+    // Explicit instance checks first
+    v instanceof decimal_js_1.default ||
+        // If Decimal.js is present and imported by the generator, this symbol exists at runtime
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore - Decimal may be undefined when not installed; codegen controls the import
+        (typeof decimal_js_1.default !== 'undefined' && v instanceof decimal_js_1.default) ||
+        (typeof v === 'object' &&
+            'd' in v &&
+            'e' in v &&
+            's' in v &&
+            'toFixed' in v) ||
+        (typeof v === 'string' && exports.DECIMAL_STRING_REGEX.test(v)) ||
+        typeof v === 'number');
+};
+exports.isValidDecimalInput = isValidDecimalInput;

packages/db/shared/helpers/decimal-helpers.ts

@@ -0,0 +1,40 @@
+import * as z from 'zod';
+
+import type { Prisma } from '../../generated/prisma';
+
+import Decimal from "decimal.js";
+
+// DECIMAL HELPERS
+//------------------------------------------------------
+
+export const DecimalJSLikeSchema: z.ZodType<Prisma.DecimalJsLike> = z.object({
+  d: z.array(z.number()),
+  e: z.number(),
+  s: z.number(),
+  // Zod v3/v4 compatible callable check
+  toFixed: z.custom<Prisma.DecimalJsLike['toFixed']>((v) => typeof v === 'function'),
+});
+
+// Accept canonical decimal strings (+/-, optional fraction, optional exponent), or Infinity/NaN.
+export const DECIMAL_STRING_REGEX = /^(?:[+-]?(?:[0-9]+(?:.[0-9]+)?(?:[eE][+-]?[0-9]+)?|Infinity)|NaN)$/;
+
+export const isValidDecimalInput = (
+  v?: null | string | number | Prisma.DecimalJsLike,
+): v is string | number | Prisma.DecimalJsLike => {
+  if (v === undefined || v === null) return false;
+  return (
+    // Explicit instance checks first
+    v instanceof Decimal ||
+    // If Decimal.js is present and imported by the generator, this symbol exists at runtime
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore - Decimal may be undefined when not installed; codegen controls the import
+    (typeof Decimal !== 'undefined' && v instanceof Decimal) ||
+    (typeof v === 'object' &&
+      'd' in v &&
+      'e' in v &&
+      's' in v &&
+      'toFixed' in v) ||
+    (typeof v === 'string' && DECIMAL_STRING_REGEX.test(v)) ||
+    typeof v === 'number'
+  );
+};

packages/db/shared/helpers/json-helpers.d.ts

@@ -0,0 +1,16 @@
+import * as z from 'zod';
+export type JsonPrimitive = string | number | boolean | null;
+export type JsonValue = JsonPrimitive | JsonValue[] | {
+    [k: string]: JsonValue;
+};
+export type InputJsonValue = JsonPrimitive | InputJsonValue[] | {
+    [k: string]: InputJsonValue | null;
+};
+export type NullableJsonInput = JsonValue | 'JsonNull' | 'DbNull' | null;
+export declare const transformJsonNull: (v?: NullableJsonInput) => JsonValue;
+export declare const JsonValueSchema: z.ZodType<JsonValue>;
+export declare const InputJsonValueSchema: z.ZodType<InputJsonValue>;
+export declare const NullableJsonValue: z.ZodEffects<z.ZodUnion<[z.ZodType<JsonValue, z.ZodTypeDef, JsonValue>, z.ZodLiteral<"DbNull">, z.ZodLiteral<"JsonNull">, z.ZodLiteral<null>]>, string | number | boolean | JsonValue[] | {
+    [k: string]: JsonValue;
+} | null, JsonValue>;
+//# sourceMappingURL=json-helpers.d.ts.map

packages/db/shared/helpers/json-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json-helpers.d.ts","sourceRoot":"","sources":["json-helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAEzB,MAAM,MAAM,aAAa,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,CAAC;AAC7D,MAAM,MAAM,SAAS,GAAG,aAAa,GAAG,SAAS,EAAE,GAAG;IAAE,CAAC,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;CAAE,CAAC;AACjF,MAAM,MAAM,cAAc,GAAG,aAAa,GAAG,cAAc,EAAE,GAAG;IAAE,CAAC,CAAC,EAAE,MAAM,GAAG,cAAc,GAAG,IAAI,CAAA;CAAE,CAAC;AACvG,MAAM,MAAM,iBAAiB,GAAG,SAAS,GAAG,UAAU,GAAG,QAAQ,GAAG,IAAI,CAAC;AACzE,eAAO,MAAM,iBAAiB,GAAI,IAAI,iBAAiB,cAItD,CAAC;AACF,eAAO,MAAM,eAAe,EAAE,CAAC,CAAC,OAAO,CAAC,SAAS,CAMxB,CAAC;AAC1B,eAAO,MAAM,oBAAoB,EAAE,CAAC,CAAC,OAAO,CAAC,cAAc,CAM7B,CAAC;AAC/B,eAAO,MAAM,iBAAiB;;oBAEgC,CAAC"}

packages/db/shared/helpers/json-helpers.js

@@ -0,0 +1,58 @@
+"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.NullableJsonValue = exports.InputJsonValueSchema = exports.JsonValueSchema = exports.transformJsonNull = void 0;
+const z = __importStar(require("zod"));
+const transformJsonNull = (v) => {
+    if (v == null || v === 'DbNull')
+        return null;
+    if (v === 'JsonNull')
+        return null;
+    return v;
+};
+exports.transformJsonNull = transformJsonNull;
+exports.JsonValueSchema = z.lazy(() => z.union([
+    z.string(), z.number(), z.boolean(), z.literal(null),
+    z.record(z.string(), z.lazy(() => exports.JsonValueSchema.optional())),
+    z.array(z.lazy(() => exports.JsonValueSchema)),
+]));
+exports.InputJsonValueSchema = z.lazy(() => z.union([
+    z.string(), z.number(), z.boolean(),
+    z.record(z.string(), z.lazy(() => z.union([exports.InputJsonValueSchema, z.literal(null)]))),
+    z.array(z.lazy(() => z.union([exports.InputJsonValueSchema, z.literal(null)]))),
+]));
+exports.NullableJsonValue = z
+    .union([exports.JsonValueSchema, z.literal('DbNull'), z.literal('JsonNull'), z.literal(null)])
+    .transform((v) => (0, exports.transformJsonNull)(v));

packages/db/shared/helpers/json-helpers.ts

@@ -0,0 +1,28 @@
+import * as z from 'zod';
+
+export type JsonPrimitive = string | number | boolean | null;
+export type JsonValue = JsonPrimitive | JsonValue[] | { [k: string]: JsonValue };
+export type InputJsonValue = JsonPrimitive | InputJsonValue[] | { [k: string]: InputJsonValue | null };
+export type NullableJsonInput = JsonValue | 'JsonNull' | 'DbNull' | null;
+export const transformJsonNull = (v?: NullableJsonInput) => {
+  if (v == null || v === 'DbNull') return null;
+  if (v === 'JsonNull') return null;
+  return v as JsonValue;
+};
+export const JsonValueSchema: z.ZodType<JsonValue> = z.lazy(() =>
+  z.union([
+    z.string(), z.number(), z.boolean(), z.literal(null),
+    z.record(z.string(), z.lazy(() => JsonValueSchema.optional())),
+    z.array(z.lazy(() => JsonValueSchema)),
+  ])
+) as z.ZodType<JsonValue>;
+export const InputJsonValueSchema: z.ZodType<InputJsonValue> = z.lazy(() =>
+  z.union([
+    z.string(), z.number(), z.boolean(),
+    z.record(z.string(), z.lazy(() => z.union([InputJsonValueSchema, z.literal(null)]))),
+    z.array(z.lazy(() => z.union([InputJsonValueSchema, z.literal(null)]))),
+  ])
+) as z.ZodType<InputJsonValue>;
+export const NullableJsonValue = z
+  .union([JsonValueSchema, z.literal('DbNull'), z.literal('JsonNull'), z.literal(null)])
+  .transform((v) => transformJsonNull(v as NullableJsonInput));

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

@@ -0,0 +1,38 @@
+import type { Prisma } from '../../generated/prisma';
+import * as z from 'zod';
+export declare const AppointmentAggregateSchema: z.ZodType<Prisma.AppointmentAggregateArgs>;
+export declare const AppointmentAggregateZodSchema: z.ZodObject<{
+    orderBy: z.ZodOptional<z.ZodUnion<[z.ZodType<Prisma.AppointmentOrderByWithRelationInput, z.ZodTypeDef, Prisma.AppointmentOrderByWithRelationInput>, z.ZodArray<z.ZodType<Prisma.AppointmentOrderByWithRelationInput, z.ZodTypeDef, Prisma.AppointmentOrderByWithRelationInput>, "many">]>>;
+    where: z.ZodOptional<z.ZodType<Prisma.AppointmentWhereInput, z.ZodTypeDef, Prisma.AppointmentWhereInput>>;
+    cursor: z.ZodOptional<z.ZodType<Prisma.AppointmentWhereUniqueInput, z.ZodTypeDef, Prisma.AppointmentWhereUniqueInput>>;
+    take: z.ZodOptional<z.ZodNumber>;
+    skip: z.ZodOptional<z.ZodNumber>;
+    _count: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<true>, z.ZodType<Prisma.AppointmentCountAggregateInputType, z.ZodTypeDef, Prisma.AppointmentCountAggregateInputType>]>>;
+    _min: z.ZodOptional<z.ZodType<Prisma.AppointmentMinAggregateInputType, z.ZodTypeDef, Prisma.AppointmentMinAggregateInputType>>;
+    _max: z.ZodOptional<z.ZodType<Prisma.AppointmentMaxAggregateInputType, z.ZodTypeDef, Prisma.AppointmentMaxAggregateInputType>>;
+    _avg: z.ZodOptional<z.ZodType<Prisma.AppointmentAvgAggregateInputType, z.ZodTypeDef, Prisma.AppointmentAvgAggregateInputType>>;
+    _sum: z.ZodOptional<z.ZodType<Prisma.AppointmentSumAggregateInputType, z.ZodTypeDef, Prisma.AppointmentSumAggregateInputType>>;
+}, "strict", z.ZodTypeAny, {
+    where?: Prisma.AppointmentWhereInput | undefined;
+    _count?: true | Prisma.AppointmentCountAggregateInputType | undefined;
+    orderBy?: Prisma.AppointmentOrderByWithRelationInput | Prisma.AppointmentOrderByWithRelationInput[] | undefined;
+    cursor?: Prisma.AppointmentWhereUniqueInput | undefined;
+    take?: number | undefined;
+    skip?: number | undefined;
+    _min?: Prisma.AppointmentMinAggregateInputType | undefined;
+    _max?: Prisma.AppointmentMaxAggregateInputType | undefined;
+    _avg?: Prisma.AppointmentAvgAggregateInputType | undefined;
+    _sum?: Prisma.AppointmentSumAggregateInputType | undefined;
+}, {
+    where?: Prisma.AppointmentWhereInput | undefined;
+    _count?: true | Prisma.AppointmentCountAggregateInputType | undefined;
+    orderBy?: Prisma.AppointmentOrderByWithRelationInput | Prisma.AppointmentOrderByWithRelationInput[] | undefined;
+    cursor?: Prisma.AppointmentWhereUniqueInput | undefined;
+    take?: number | undefined;
+    skip?: number | undefined;
+    _min?: Prisma.AppointmentMinAggregateInputType | undefined;
+    _max?: Prisma.AppointmentMaxAggregateInputType | undefined;
+    _avg?: Prisma.AppointmentAvgAggregateInputType | undefined;
+    _sum?: Prisma.AppointmentSumAggregateInputType | undefined;
+}>;
+//# sourceMappingURL=aggregateAppointment.schema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"aggregateAppointment.schema.d.ts","sourceRoot":"","sources":["aggregateAppointment.schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAUzB,eAAO,MAAM,0BAA0B,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,wBAAwB,CAA+sB,CAAC;AAElyB,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAqpB,CAAC"}

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

@@ -0,0 +1,47 @@
+"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.AppointmentAggregateZodSchema = exports.AppointmentAggregateSchema = void 0;
+const z = __importStar(require("zod"));
+const AppointmentOrderByWithRelationInput_schema_1 = require("./objects/AppointmentOrderByWithRelationInput.schema");
+const AppointmentWhereInput_schema_1 = require("./objects/AppointmentWhereInput.schema");
+const AppointmentWhereUniqueInput_schema_1 = require("./objects/AppointmentWhereUniqueInput.schema");
+const AppointmentCountAggregateInput_schema_1 = require("./objects/AppointmentCountAggregateInput.schema");
+const AppointmentMinAggregateInput_schema_1 = require("./objects/AppointmentMinAggregateInput.schema");
+const AppointmentMaxAggregateInput_schema_1 = require("./objects/AppointmentMaxAggregateInput.schema");
+const AppointmentAvgAggregateInput_schema_1 = require("./objects/AppointmentAvgAggregateInput.schema");
+const AppointmentSumAggregateInput_schema_1 = require("./objects/AppointmentSumAggregateInput.schema");
+exports.AppointmentAggregateSchema = z.object({ orderBy: z.union([AppointmentOrderByWithRelationInput_schema_1.AppointmentOrderByWithRelationInputObjectSchema, AppointmentOrderByWithRelationInput_schema_1.AppointmentOrderByWithRelationInputObjectSchema.array()]).optional(), where: AppointmentWhereInput_schema_1.AppointmentWhereInputObjectSchema.optional(), cursor: AppointmentWhereUniqueInput_schema_1.AppointmentWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), _count: z.union([z.literal(true), AppointmentCountAggregateInput_schema_1.AppointmentCountAggregateInputObjectSchema]).optional(), _min: AppointmentMinAggregateInput_schema_1.AppointmentMinAggregateInputObjectSchema.optional(), _max: AppointmentMaxAggregateInput_schema_1.AppointmentMaxAggregateInputObjectSchema.optional(), _avg: AppointmentAvgAggregateInput_schema_1.AppointmentAvgAggregateInputObjectSchema.optional(), _sum: AppointmentSumAggregateInput_schema_1.AppointmentSumAggregateInputObjectSchema.optional() }).strict();
+exports.AppointmentAggregateZodSchema = z.object({ orderBy: z.union([AppointmentOrderByWithRelationInput_schema_1.AppointmentOrderByWithRelationInputObjectSchema, AppointmentOrderByWithRelationInput_schema_1.AppointmentOrderByWithRelationInputObjectSchema.array()]).optional(), where: AppointmentWhereInput_schema_1.AppointmentWhereInputObjectSchema.optional(), cursor: AppointmentWhereUniqueInput_schema_1.AppointmentWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), _count: z.union([z.literal(true), AppointmentCountAggregateInput_schema_1.AppointmentCountAggregateInputObjectSchema]).optional(), _min: AppointmentMinAggregateInput_schema_1.AppointmentMinAggregateInputObjectSchema.optional(), _max: AppointmentMaxAggregateInput_schema_1.AppointmentMaxAggregateInputObjectSchema.optional(), _avg: AppointmentAvgAggregateInput_schema_1.AppointmentAvgAggregateInputObjectSchema.optional(), _sum: AppointmentSumAggregateInput_schema_1.AppointmentSumAggregateInputObjectSchema.optional() }).strict();

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

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

packages/db/shared/schemas/aggregateAppointmentProcedure.schema.d.ts

@@ -0,0 +1,38 @@
+import type { Prisma } from '../../generated/prisma';
+import * as z from 'zod';
+export declare const AppointmentProcedureAggregateSchema: z.ZodType<Prisma.AppointmentProcedureAggregateArgs>;
+export declare const AppointmentProcedureAggregateZodSchema: z.ZodObject<{
+    orderBy: z.ZodOptional<z.ZodUnion<[z.ZodType<Prisma.AppointmentProcedureOrderByWithRelationInput, z.ZodTypeDef, Prisma.AppointmentProcedureOrderByWithRelationInput>, z.ZodArray<z.ZodType<Prisma.AppointmentProcedureOrderByWithRelationInput, z.ZodTypeDef, Prisma.AppointmentProcedureOrderByWithRelationInput>, "many">]>>;
+    where: z.ZodOptional<z.ZodType<Prisma.AppointmentProcedureWhereInput, z.ZodTypeDef, Prisma.AppointmentProcedureWhereInput>>;
+    cursor: z.ZodOptional<z.ZodType<Prisma.AppointmentProcedureWhereUniqueInput, z.ZodTypeDef, Prisma.AppointmentProcedureWhereUniqueInput>>;
+    take: z.ZodOptional<z.ZodNumber>;
+    skip: z.ZodOptional<z.ZodNumber>;
+    _count: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<true>, z.ZodType<Prisma.AppointmentProcedureCountAggregateInputType, z.ZodTypeDef, Prisma.AppointmentProcedureCountAggregateInputType>]>>;
+    _min: z.ZodOptional<z.ZodType<Prisma.AppointmentProcedureMinAggregateInputType, z.ZodTypeDef, Prisma.AppointmentProcedureMinAggregateInputType>>;
+    _max: z.ZodOptional<z.ZodType<Prisma.AppointmentProcedureMaxAggregateInputType, z.ZodTypeDef, Prisma.AppointmentProcedureMaxAggregateInputType>>;
+    _avg: z.ZodOptional<z.ZodType<Prisma.AppointmentProcedureAvgAggregateInputType, z.ZodTypeDef, Prisma.AppointmentProcedureAvgAggregateInputType>>;
+    _sum: z.ZodOptional<z.ZodType<Prisma.AppointmentProcedureSumAggregateInputType, z.ZodTypeDef, Prisma.AppointmentProcedureSumAggregateInputType>>;
+}, "strict", z.ZodTypeAny, {
+    where?: Prisma.AppointmentProcedureWhereInput | undefined;
+    _count?: true | Prisma.AppointmentProcedureCountAggregateInputType | undefined;
+    orderBy?: Prisma.AppointmentProcedureOrderByWithRelationInput | Prisma.AppointmentProcedureOrderByWithRelationInput[] | undefined;
+    cursor?: Prisma.AppointmentProcedureWhereUniqueInput | undefined;
+    take?: number | undefined;
+    skip?: number | undefined;
+    _min?: Prisma.AppointmentProcedureMinAggregateInputType | undefined;
+    _max?: Prisma.AppointmentProcedureMaxAggregateInputType | undefined;
+    _avg?: Prisma.AppointmentProcedureAvgAggregateInputType | undefined;
+    _sum?: Prisma.AppointmentProcedureSumAggregateInputType | undefined;
+}, {
+    where?: Prisma.AppointmentProcedureWhereInput | undefined;
+    _count?: true | Prisma.AppointmentProcedureCountAggregateInputType | undefined;
+    orderBy?: Prisma.AppointmentProcedureOrderByWithRelationInput | Prisma.AppointmentProcedureOrderByWithRelationInput[] | undefined;
+    cursor?: Prisma.AppointmentProcedureWhereUniqueInput | undefined;
+    take?: number | undefined;
+    skip?: number | undefined;
+    _min?: Prisma.AppointmentProcedureMinAggregateInputType | undefined;
+    _max?: Prisma.AppointmentProcedureMaxAggregateInputType | undefined;
+    _avg?: Prisma.AppointmentProcedureAvgAggregateInputType | undefined;
+    _sum?: Prisma.AppointmentProcedureSumAggregateInputType | undefined;
+}>;
+//# sourceMappingURL=aggregateAppointmentProcedure.schema.d.ts.map

packages/db/shared/schemas/aggregateAppointmentProcedure.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aggregateAppointmentProcedure.schema.d.ts","sourceRoot":"","sources":["aggregateAppointmentProcedure.schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAUzB,eAAO,MAAM,mCAAmC,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,iCAAiC,CAAyyB,CAAC;AAE94B,eAAO,MAAM,sCAAsC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAsuB,CAAC"}

packages/db/shared/schemas/aggregateAppointmentProcedure.schema.js

@@ -0,0 +1,47 @@
+"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.AppointmentProcedureAggregateZodSchema = exports.AppointmentProcedureAggregateSchema = void 0;
+const z = __importStar(require("zod"));
+const AppointmentProcedureOrderByWithRelationInput_schema_1 = require("./objects/AppointmentProcedureOrderByWithRelationInput.schema");
+const AppointmentProcedureWhereInput_schema_1 = require("./objects/AppointmentProcedureWhereInput.schema");
+const AppointmentProcedureWhereUniqueInput_schema_1 = require("./objects/AppointmentProcedureWhereUniqueInput.schema");
+const AppointmentProcedureCountAggregateInput_schema_1 = require("./objects/AppointmentProcedureCountAggregateInput.schema");
+const AppointmentProcedureMinAggregateInput_schema_1 = require("./objects/AppointmentProcedureMinAggregateInput.schema");
+const AppointmentProcedureMaxAggregateInput_schema_1 = require("./objects/AppointmentProcedureMaxAggregateInput.schema");
+const AppointmentProcedureAvgAggregateInput_schema_1 = require("./objects/AppointmentProcedureAvgAggregateInput.schema");
+const AppointmentProcedureSumAggregateInput_schema_1 = require("./objects/AppointmentProcedureSumAggregateInput.schema");
+exports.AppointmentProcedureAggregateSchema = z.object({ orderBy: z.union([AppointmentProcedureOrderByWithRelationInput_schema_1.AppointmentProcedureOrderByWithRelationInputObjectSchema, AppointmentProcedureOrderByWithRelationInput_schema_1.AppointmentProcedureOrderByWithRelationInputObjectSchema.array()]).optional(), where: AppointmentProcedureWhereInput_schema_1.AppointmentProcedureWhereInputObjectSchema.optional(), cursor: AppointmentProcedureWhereUniqueInput_schema_1.AppointmentProcedureWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), _count: z.union([z.literal(true), AppointmentProcedureCountAggregateInput_schema_1.AppointmentProcedureCountAggregateInputObjectSchema]).optional(), _min: AppointmentProcedureMinAggregateInput_schema_1.AppointmentProcedureMinAggregateInputObjectSchema.optional(), _max: AppointmentProcedureMaxAggregateInput_schema_1.AppointmentProcedureMaxAggregateInputObjectSchema.optional(), _avg: AppointmentProcedureAvgAggregateInput_schema_1.AppointmentProcedureAvgAggregateInputObjectSchema.optional(), _sum: AppointmentProcedureSumAggregateInput_schema_1.AppointmentProcedureSumAggregateInputObjectSchema.optional() }).strict();
+exports.AppointmentProcedureAggregateZodSchema = z.object({ orderBy: z.union([AppointmentProcedureOrderByWithRelationInput_schema_1.AppointmentProcedureOrderByWithRelationInputObjectSchema, AppointmentProcedureOrderByWithRelationInput_schema_1.AppointmentProcedureOrderByWithRelationInputObjectSchema.array()]).optional(), where: AppointmentProcedureWhereInput_schema_1.AppointmentProcedureWhereInputObjectSchema.optional(), cursor: AppointmentProcedureWhereUniqueInput_schema_1.AppointmentProcedureWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), _count: z.union([z.literal(true), AppointmentProcedureCountAggregateInput_schema_1.AppointmentProcedureCountAggregateInputObjectSchema]).optional(), _min: AppointmentProcedureMinAggregateInput_schema_1.AppointmentProcedureMinAggregateInputObjectSchema.optional(), _max: AppointmentProcedureMaxAggregateInput_schema_1.AppointmentProcedureMaxAggregateInputObjectSchema.optional(), _avg: AppointmentProcedureAvgAggregateInput_schema_1.AppointmentProcedureAvgAggregateInputObjectSchema.optional(), _sum: AppointmentProcedureSumAggregateInput_schema_1.AppointmentProcedureSumAggregateInputObjectSchema.optional() }).strict();

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

@@ -0,0 +1,14 @@
+import type { Prisma } from '../../generated/prisma';
+import * as z from 'zod';
+import { AppointmentProcedureOrderByWithRelationInputObjectSchema as AppointmentProcedureOrderByWithRelationInputObjectSchema } from './objects/AppointmentProcedureOrderByWithRelationInput.schema';
+import { AppointmentProcedureWhereInputObjectSchema as AppointmentProcedureWhereInputObjectSchema } from './objects/AppointmentProcedureWhereInput.schema';
+import { AppointmentProcedureWhereUniqueInputObjectSchema as AppointmentProcedureWhereUniqueInputObjectSchema } from './objects/AppointmentProcedureWhereUniqueInput.schema';
+import { AppointmentProcedureCountAggregateInputObjectSchema as AppointmentProcedureCountAggregateInputObjectSchema } from './objects/AppointmentProcedureCountAggregateInput.schema';
+import { AppointmentProcedureMinAggregateInputObjectSchema as AppointmentProcedureMinAggregateInputObjectSchema } from './objects/AppointmentProcedureMinAggregateInput.schema';
+import { AppointmentProcedureMaxAggregateInputObjectSchema as AppointmentProcedureMaxAggregateInputObjectSchema } from './objects/AppointmentProcedureMaxAggregateInput.schema';
+import { AppointmentProcedureAvgAggregateInputObjectSchema as AppointmentProcedureAvgAggregateInputObjectSchema } from './objects/AppointmentProcedureAvgAggregateInput.schema';
+import { AppointmentProcedureSumAggregateInputObjectSchema as AppointmentProcedureSumAggregateInputObjectSchema } from './objects/AppointmentProcedureSumAggregateInput.schema';
+
+export const AppointmentProcedureAggregateSchema: z.ZodType<Prisma.AppointmentProcedureAggregateArgs> = z.object({ orderBy: z.union([AppointmentProcedureOrderByWithRelationInputObjectSchema, AppointmentProcedureOrderByWithRelationInputObjectSchema.array()]).optional(), where: AppointmentProcedureWhereInputObjectSchema.optional(), cursor: AppointmentProcedureWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), _count: z.union([ z.literal(true), AppointmentProcedureCountAggregateInputObjectSchema ]).optional(), _min: AppointmentProcedureMinAggregateInputObjectSchema.optional(), _max: AppointmentProcedureMaxAggregateInputObjectSchema.optional(), _avg: AppointmentProcedureAvgAggregateInputObjectSchema.optional(), _sum: AppointmentProcedureSumAggregateInputObjectSchema.optional() }).strict() as unknown as z.ZodType<Prisma.AppointmentProcedureAggregateArgs>;
+
+export const AppointmentProcedureAggregateZodSchema = z.object({ orderBy: z.union([AppointmentProcedureOrderByWithRelationInputObjectSchema, AppointmentProcedureOrderByWithRelationInputObjectSchema.array()]).optional(), where: AppointmentProcedureWhereInputObjectSchema.optional(), cursor: AppointmentProcedureWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), _count: z.union([ z.literal(true), AppointmentProcedureCountAggregateInputObjectSchema ]).optional(), _min: AppointmentProcedureMinAggregateInputObjectSchema.optional(), _max: AppointmentProcedureMaxAggregateInputObjectSchema.optional(), _avg: AppointmentProcedureAvgAggregateInputObjectSchema.optional(), _sum: AppointmentProcedureSumAggregateInputObjectSchema.optional() }).strict();

packages/db/shared/schemas/aggregateBackupDestination.schema.d.ts

@@ -0,0 +1,38 @@
+import type { Prisma } from '../../generated/prisma';
+import * as z from 'zod';
+export declare const BackupDestinationAggregateSchema: z.ZodType<Prisma.BackupDestinationAggregateArgs>;
+export declare const BackupDestinationAggregateZodSchema: z.ZodObject<{
+    orderBy: z.ZodOptional<z.ZodUnion<[z.ZodType<Prisma.BackupDestinationOrderByWithRelationInput, z.ZodTypeDef, Prisma.BackupDestinationOrderByWithRelationInput>, z.ZodArray<z.ZodType<Prisma.BackupDestinationOrderByWithRelationInput, z.ZodTypeDef, Prisma.BackupDestinationOrderByWithRelationInput>, "many">]>>;
+    where: z.ZodOptional<z.ZodType<Prisma.BackupDestinationWhereInput, z.ZodTypeDef, Prisma.BackupDestinationWhereInput>>;
+    cursor: z.ZodOptional<z.ZodType<Prisma.BackupDestinationWhereUniqueInput, z.ZodTypeDef, Prisma.BackupDestinationWhereUniqueInput>>;
+    take: z.ZodOptional<z.ZodNumber>;
+    skip: z.ZodOptional<z.ZodNumber>;
+    _count: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<true>, z.ZodType<Prisma.BackupDestinationCountAggregateInputType, z.ZodTypeDef, Prisma.BackupDestinationCountAggregateInputType>]>>;
+    _min: z.ZodOptional<z.ZodType<Prisma.BackupDestinationMinAggregateInputType, z.ZodTypeDef, Prisma.BackupDestinationMinAggregateInputType>>;
+    _max: z.ZodOptional<z.ZodType<Prisma.BackupDestinationMaxAggregateInputType, z.ZodTypeDef, Prisma.BackupDestinationMaxAggregateInputType>>;
+    _avg: z.ZodOptional<z.ZodType<Prisma.BackupDestinationAvgAggregateInputType, z.ZodTypeDef, Prisma.BackupDestinationAvgAggregateInputType>>;
+    _sum: z.ZodOptional<z.ZodType<Prisma.BackupDestinationSumAggregateInputType, z.ZodTypeDef, Prisma.BackupDestinationSumAggregateInputType>>;
+}, "strict", z.ZodTypeAny, {
+    where?: Prisma.BackupDestinationWhereInput | undefined;
+    _count?: true | Prisma.BackupDestinationCountAggregateInputType | undefined;
+    orderBy?: Prisma.BackupDestinationOrderByWithRelationInput | Prisma.BackupDestinationOrderByWithRelationInput[] | undefined;
+    cursor?: Prisma.BackupDestinationWhereUniqueInput | undefined;
+    take?: number | undefined;
+    skip?: number | undefined;
+    _min?: Prisma.BackupDestinationMinAggregateInputType | undefined;
+    _max?: Prisma.BackupDestinationMaxAggregateInputType | undefined;
+    _avg?: Prisma.BackupDestinationAvgAggregateInputType | undefined;
+    _sum?: Prisma.BackupDestinationSumAggregateInputType | undefined;
+}, {
+    where?: Prisma.BackupDestinationWhereInput | undefined;
+    _count?: true | Prisma.BackupDestinationCountAggregateInputType | undefined;
+    orderBy?: Prisma.BackupDestinationOrderByWithRelationInput | Prisma.BackupDestinationOrderByWithRelationInput[] | undefined;
+    cursor?: Prisma.BackupDestinationWhereUniqueInput | undefined;
+    take?: number | undefined;
+    skip?: number | undefined;
+    _min?: Prisma.BackupDestinationMinAggregateInputType | undefined;
+    _max?: Prisma.BackupDestinationMaxAggregateInputType | undefined;
+    _avg?: Prisma.BackupDestinationAvgAggregateInputType | undefined;
+    _sum?: Prisma.BackupDestinationSumAggregateInputType | undefined;
+}>;
+//# sourceMappingURL=aggregateBackupDestination.schema.d.ts.map

packages/db/shared/schemas/aggregateBackupDestination.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aggregateBackupDestination.schema.d.ts","sourceRoot":"","sources":["aggregateBackupDestination.schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAUzB,eAAO,MAAM,gCAAgC,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,8BAA8B,CAA2wB,CAAC;AAE12B,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAA2sB,CAAC"}

packages/db/shared/schemas/aggregateBackupDestination.schema.js

@@ -0,0 +1,47 @@
+"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.BackupDestinationAggregateZodSchema = exports.BackupDestinationAggregateSchema = void 0;
+const z = __importStar(require("zod"));
+const BackupDestinationOrderByWithRelationInput_schema_1 = require("./objects/BackupDestinationOrderByWithRelationInput.schema");
+const BackupDestinationWhereInput_schema_1 = require("./objects/BackupDestinationWhereInput.schema");
+const BackupDestinationWhereUniqueInput_schema_1 = require("./objects/BackupDestinationWhereUniqueInput.schema");
+const BackupDestinationCountAggregateInput_schema_1 = require("./objects/BackupDestinationCountAggregateInput.schema");
+const BackupDestinationMinAggregateInput_schema_1 = require("./objects/BackupDestinationMinAggregateInput.schema");
+const BackupDestinationMaxAggregateInput_schema_1 = require("./objects/BackupDestinationMaxAggregateInput.schema");
+const BackupDestinationAvgAggregateInput_schema_1 = require("./objects/BackupDestinationAvgAggregateInput.schema");
+const BackupDestinationSumAggregateInput_schema_1 = require("./objects/BackupDestinationSumAggregateInput.schema");
+exports.BackupDestinationAggregateSchema = z.object({ orderBy: z.union([BackupDestinationOrderByWithRelationInput_schema_1.BackupDestinationOrderByWithRelationInputObjectSchema, BackupDestinationOrderByWithRelationInput_schema_1.BackupDestinationOrderByWithRelationInputObjectSchema.array()]).optional(), where: BackupDestinationWhereInput_schema_1.BackupDestinationWhereInputObjectSchema.optional(), cursor: BackupDestinationWhereUniqueInput_schema_1.BackupDestinationWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), _count: z.union([z.literal(true), BackupDestinationCountAggregateInput_schema_1.BackupDestinationCountAggregateInputObjectSchema]).optional(), _min: BackupDestinationMinAggregateInput_schema_1.BackupDestinationMinAggregateInputObjectSchema.optional(), _max: BackupDestinationMaxAggregateInput_schema_1.BackupDestinationMaxAggregateInputObjectSchema.optional(), _avg: BackupDestinationAvgAggregateInput_schema_1.BackupDestinationAvgAggregateInputObjectSchema.optional(), _sum: BackupDestinationSumAggregateInput_schema_1.BackupDestinationSumAggregateInputObjectSchema.optional() }).strict();
+exports.BackupDestinationAggregateZodSchema = z.object({ orderBy: z.union([BackupDestinationOrderByWithRelationInput_schema_1.BackupDestinationOrderByWithRelationInputObjectSchema, BackupDestinationOrderByWithRelationInput_schema_1.BackupDestinationOrderByWithRelationInputObjectSchema.array()]).optional(), where: BackupDestinationWhereInput_schema_1.BackupDestinationWhereInputObjectSchema.optional(), cursor: BackupDestinationWhereUniqueInput_schema_1.BackupDestinationWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), _count: z.union([z.literal(true), BackupDestinationCountAggregateInput_schema_1.BackupDestinationCountAggregateInputObjectSchema]).optional(), _min: BackupDestinationMinAggregateInput_schema_1.BackupDestinationMinAggregateInputObjectSchema.optional(), _max: BackupDestinationMaxAggregateInput_schema_1.BackupDestinationMaxAggregateInputObjectSchema.optional(), _avg: BackupDestinationAvgAggregateInput_schema_1.BackupDestinationAvgAggregateInputObjectSchema.optional(), _sum: BackupDestinationSumAggregateInput_schema_1.BackupDestinationSumAggregateInputObjectSchema.optional() }).strict();

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

@@ -0,0 +1,14 @@
+import type { Prisma } from '../../generated/prisma';
+import * as z from 'zod';
+import { BackupDestinationOrderByWithRelationInputObjectSchema as BackupDestinationOrderByWithRelationInputObjectSchema } from './objects/BackupDestinationOrderByWithRelationInput.schema';
+import { BackupDestinationWhereInputObjectSchema as BackupDestinationWhereInputObjectSchema } from './objects/BackupDestinationWhereInput.schema';
+import { BackupDestinationWhereUniqueInputObjectSchema as BackupDestinationWhereUniqueInputObjectSchema } from './objects/BackupDestinationWhereUniqueInput.schema';
+import { BackupDestinationCountAggregateInputObjectSchema as BackupDestinationCountAggregateInputObjectSchema } from './objects/BackupDestinationCountAggregateInput.schema';
+import { BackupDestinationMinAggregateInputObjectSchema as BackupDestinationMinAggregateInputObjectSchema } from './objects/BackupDestinationMinAggregateInput.schema';
+import { BackupDestinationMaxAggregateInputObjectSchema as BackupDestinationMaxAggregateInputObjectSchema } from './objects/BackupDestinationMaxAggregateInput.schema';
+import { BackupDestinationAvgAggregateInputObjectSchema as BackupDestinationAvgAggregateInputObjectSchema } from './objects/BackupDestinationAvgAggregateInput.schema';
+import { BackupDestinationSumAggregateInputObjectSchema as BackupDestinationSumAggregateInputObjectSchema } from './objects/BackupDestinationSumAggregateInput.schema';
+
+export const BackupDestinationAggregateSchema: z.ZodType<Prisma.BackupDestinationAggregateArgs> = z.object({ orderBy: z.union([BackupDestinationOrderByWithRelationInputObjectSchema, BackupDestinationOrderByWithRelationInputObjectSchema.array()]).optional(), where: BackupDestinationWhereInputObjectSchema.optional(), cursor: BackupDestinationWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), _count: z.union([ z.literal(true), BackupDestinationCountAggregateInputObjectSchema ]).optional(), _min: BackupDestinationMinAggregateInputObjectSchema.optional(), _max: BackupDestinationMaxAggregateInputObjectSchema.optional(), _avg: BackupDestinationAvgAggregateInputObjectSchema.optional(), _sum: BackupDestinationSumAggregateInputObjectSchema.optional() }).strict() as unknown as z.ZodType<Prisma.BackupDestinationAggregateArgs>;
+
+export const BackupDestinationAggregateZodSchema = z.object({ orderBy: z.union([BackupDestinationOrderByWithRelationInputObjectSchema, BackupDestinationOrderByWithRelationInputObjectSchema.array()]).optional(), where: BackupDestinationWhereInputObjectSchema.optional(), cursor: BackupDestinationWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), _count: z.union([ z.literal(true), BackupDestinationCountAggregateInputObjectSchema ]).optional(), _min: BackupDestinationMinAggregateInputObjectSchema.optional(), _max: BackupDestinationMaxAggregateInputObjectSchema.optional(), _avg: BackupDestinationAvgAggregateInputObjectSchema.optional(), _sum: BackupDestinationSumAggregateInputObjectSchema.optional() }).strict();

packages/db/shared/schemas/aggregateClaim.schema.d.ts

@@ -0,0 +1,38 @@
+import type { Prisma } from '../../generated/prisma';
+import * as z from 'zod';
+export declare const ClaimAggregateSchema: z.ZodType<Prisma.ClaimAggregateArgs>;
+export declare const ClaimAggregateZodSchema: z.ZodObject<{
+    orderBy: z.ZodOptional<z.ZodUnion<[z.ZodType<Prisma.ClaimOrderByWithRelationInput, z.ZodTypeDef, Prisma.ClaimOrderByWithRelationInput>, z.ZodArray<z.ZodType<Prisma.ClaimOrderByWithRelationInput, z.ZodTypeDef, Prisma.ClaimOrderByWithRelationInput>, "many">]>>;
+    where: z.ZodOptional<z.ZodType<Prisma.ClaimWhereInput, z.ZodTypeDef, Prisma.ClaimWhereInput>>;
+    cursor: z.ZodOptional<z.ZodType<Prisma.ClaimWhereUniqueInput, z.ZodTypeDef, Prisma.ClaimWhereUniqueInput>>;
+    take: z.ZodOptional<z.ZodNumber>;
+    skip: z.ZodOptional<z.ZodNumber>;
+    _count: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<true>, z.ZodType<Prisma.ClaimCountAggregateInputType, z.ZodTypeDef, Prisma.ClaimCountAggregateInputType>]>>;
+    _min: z.ZodOptional<z.ZodType<Prisma.ClaimMinAggregateInputType, z.ZodTypeDef, Prisma.ClaimMinAggregateInputType>>;
+    _max: z.ZodOptional<z.ZodType<Prisma.ClaimMaxAggregateInputType, z.ZodTypeDef, Prisma.ClaimMaxAggregateInputType>>;
+    _avg: z.ZodOptional<z.ZodType<Prisma.ClaimAvgAggregateInputType, z.ZodTypeDef, Prisma.ClaimAvgAggregateInputType>>;
+    _sum: z.ZodOptional<z.ZodType<Prisma.ClaimSumAggregateInputType, z.ZodTypeDef, Prisma.ClaimSumAggregateInputType>>;
+}, "strict", z.ZodTypeAny, {
+    where?: Prisma.ClaimWhereInput | undefined;
+    _count?: true | Prisma.ClaimCountAggregateInputType | undefined;
+    orderBy?: Prisma.ClaimOrderByWithRelationInput | Prisma.ClaimOrderByWithRelationInput[] | undefined;
+    cursor?: Prisma.ClaimWhereUniqueInput | undefined;
+    take?: number | undefined;
+    skip?: number | undefined;
+    _min?: Prisma.ClaimMinAggregateInputType | undefined;
+    _max?: Prisma.ClaimMaxAggregateInputType | undefined;
+    _avg?: Prisma.ClaimAvgAggregateInputType | undefined;
+    _sum?: Prisma.ClaimSumAggregateInputType | undefined;
+}, {
+    where?: Prisma.ClaimWhereInput | undefined;
+    _count?: true | Prisma.ClaimCountAggregateInputType | undefined;
+    orderBy?: Prisma.ClaimOrderByWithRelationInput | Prisma.ClaimOrderByWithRelationInput[] | undefined;
+    cursor?: Prisma.ClaimWhereUniqueInput | undefined;
+    take?: number | undefined;
+    skip?: number | undefined;
+    _min?: Prisma.ClaimMinAggregateInputType | undefined;
+    _max?: Prisma.ClaimMaxAggregateInputType | undefined;
+    _avg?: Prisma.ClaimAvgAggregateInputType | undefined;
+    _sum?: Prisma.ClaimSumAggregateInputType | undefined;
+}>;
+//# sourceMappingURL=aggregateClaim.schema.d.ts.map

packages/db/shared/schemas/aggregateClaim.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aggregateClaim.schema.d.ts","sourceRoot":"","sources":["aggregateClaim.schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAUzB,eAAO,MAAM,oBAAoB,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,kBAAkB,CAAmpB,CAAC;AAE1tB,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAA+lB,CAAC"}

packages/db/shared/schemas/aggregateClaim.schema.js

@@ -0,0 +1,47 @@
+"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.ClaimAggregateZodSchema = exports.ClaimAggregateSchema = void 0;
+const z = __importStar(require("zod"));
+const ClaimOrderByWithRelationInput_schema_1 = require("./objects/ClaimOrderByWithRelationInput.schema");
+const ClaimWhereInput_schema_1 = require("./objects/ClaimWhereInput.schema");
+const ClaimWhereUniqueInput_schema_1 = require("./objects/ClaimWhereUniqueInput.schema");
+const ClaimCountAggregateInput_schema_1 = require("./objects/ClaimCountAggregateInput.schema");
+const ClaimMinAggregateInput_schema_1 = require("./objects/ClaimMinAggregateInput.schema");
+const ClaimMaxAggregateInput_schema_1 = require("./objects/ClaimMaxAggregateInput.schema");
+const ClaimAvgAggregateInput_schema_1 = require("./objects/ClaimAvgAggregateInput.schema");
+const ClaimSumAggregateInput_schema_1 = require("./objects/ClaimSumAggregateInput.schema");
+exports.ClaimAggregateSchema = z.object({ orderBy: z.union([ClaimOrderByWithRelationInput_schema_1.ClaimOrderByWithRelationInputObjectSchema, ClaimOrderByWithRelationInput_schema_1.ClaimOrderByWithRelationInputObjectSchema.array()]).optional(), where: ClaimWhereInput_schema_1.ClaimWhereInputObjectSchema.optional(), cursor: ClaimWhereUniqueInput_schema_1.ClaimWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), _count: z.union([z.literal(true), ClaimCountAggregateInput_schema_1.ClaimCountAggregateInputObjectSchema]).optional(), _min: ClaimMinAggregateInput_schema_1.ClaimMinAggregateInputObjectSchema.optional(), _max: ClaimMaxAggregateInput_schema_1.ClaimMaxAggregateInputObjectSchema.optional(), _avg: ClaimAvgAggregateInput_schema_1.ClaimAvgAggregateInputObjectSchema.optional(), _sum: ClaimSumAggregateInput_schema_1.ClaimSumAggregateInputObjectSchema.optional() }).strict();
+exports.ClaimAggregateZodSchema = z.object({ orderBy: z.union([ClaimOrderByWithRelationInput_schema_1.ClaimOrderByWithRelationInputObjectSchema, ClaimOrderByWithRelationInput_schema_1.ClaimOrderByWithRelationInputObjectSchema.array()]).optional(), where: ClaimWhereInput_schema_1.ClaimWhereInputObjectSchema.optional(), cursor: ClaimWhereUniqueInput_schema_1.ClaimWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), _count: z.union([z.literal(true), ClaimCountAggregateInput_schema_1.ClaimCountAggregateInputObjectSchema]).optional(), _min: ClaimMinAggregateInput_schema_1.ClaimMinAggregateInputObjectSchema.optional(), _max: ClaimMaxAggregateInput_schema_1.ClaimMaxAggregateInputObjectSchema.optional(), _avg: ClaimAvgAggregateInput_schema_1.ClaimAvgAggregateInputObjectSchema.optional(), _sum: ClaimSumAggregateInput_schema_1.ClaimSumAggregateInputObjectSchema.optional() }).strict();

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

@@ -0,0 +1,14 @@
+import type { Prisma } from '../../generated/prisma';
+import * as z from 'zod';
+import { ClaimOrderByWithRelationInputObjectSchema as ClaimOrderByWithRelationInputObjectSchema } from './objects/ClaimOrderByWithRelationInput.schema';
+import { ClaimWhereInputObjectSchema as ClaimWhereInputObjectSchema } from './objects/ClaimWhereInput.schema';
+import { ClaimWhereUniqueInputObjectSchema as ClaimWhereUniqueInputObjectSchema } from './objects/ClaimWhereUniqueInput.schema';
+import { ClaimCountAggregateInputObjectSchema as ClaimCountAggregateInputObjectSchema } from './objects/ClaimCountAggregateInput.schema';
+import { ClaimMinAggregateInputObjectSchema as ClaimMinAggregateInputObjectSchema } from './objects/ClaimMinAggregateInput.schema';
+import { ClaimMaxAggregateInputObjectSchema as ClaimMaxAggregateInputObjectSchema } from './objects/ClaimMaxAggregateInput.schema';
+import { ClaimAvgAggregateInputObjectSchema as ClaimAvgAggregateInputObjectSchema } from './objects/ClaimAvgAggregateInput.schema';
+import { ClaimSumAggregateInputObjectSchema as ClaimSumAggregateInputObjectSchema } from './objects/ClaimSumAggregateInput.schema';
+
+export const ClaimAggregateSchema: z.ZodType<Prisma.ClaimAggregateArgs> = z.object({ orderBy: z.union([ClaimOrderByWithRelationInputObjectSchema, ClaimOrderByWithRelationInputObjectSchema.array()]).optional(), where: ClaimWhereInputObjectSchema.optional(), cursor: ClaimWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), _count: z.union([ z.literal(true), ClaimCountAggregateInputObjectSchema ]).optional(), _min: ClaimMinAggregateInputObjectSchema.optional(), _max: ClaimMaxAggregateInputObjectSchema.optional(), _avg: ClaimAvgAggregateInputObjectSchema.optional(), _sum: ClaimSumAggregateInputObjectSchema.optional() }).strict() as unknown as z.ZodType<Prisma.ClaimAggregateArgs>;
+
+export const ClaimAggregateZodSchema = z.object({ orderBy: z.union([ClaimOrderByWithRelationInputObjectSchema, ClaimOrderByWithRelationInputObjectSchema.array()]).optional(), where: ClaimWhereInputObjectSchema.optional(), cursor: ClaimWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), _count: z.union([ z.literal(true), ClaimCountAggregateInputObjectSchema ]).optional(), _min: ClaimMinAggregateInputObjectSchema.optional(), _max: ClaimMaxAggregateInputObjectSchema.optional(), _avg: ClaimAvgAggregateInputObjectSchema.optional(), _sum: ClaimSumAggregateInputObjectSchema.optional() }).strict();

packages/db/shared/schemas/aggregateClaimFile.schema.d.ts

@@ -0,0 +1,38 @@
+import type { Prisma } from '../../generated/prisma';
+import * as z from 'zod';
+export declare const ClaimFileAggregateSchema: z.ZodType<Prisma.ClaimFileAggregateArgs>;
+export declare const ClaimFileAggregateZodSchema: z.ZodObject<{
+    orderBy: z.ZodOptional<z.ZodUnion<[z.ZodType<Prisma.ClaimFileOrderByWithRelationInput, z.ZodTypeDef, Prisma.ClaimFileOrderByWithRelationInput>, z.ZodArray<z.ZodType<Prisma.ClaimFileOrderByWithRelationInput, z.ZodTypeDef, Prisma.ClaimFileOrderByWithRelationInput>, "many">]>>;
+    where: z.ZodOptional<z.ZodType<Prisma.ClaimFileWhereInput, z.ZodTypeDef, Prisma.ClaimFileWhereInput>>;
+    cursor: z.ZodOptional<z.ZodType<Prisma.ClaimFileWhereUniqueInput, z.ZodTypeDef, Prisma.ClaimFileWhereUniqueInput>>;
+    take: z.ZodOptional<z.ZodNumber>;
+    skip: z.ZodOptional<z.ZodNumber>;
+    _count: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<true>, z.ZodType<Prisma.ClaimFileCountAggregateInputType, z.ZodTypeDef, Prisma.ClaimFileCountAggregateInputType>]>>;
+    _min: z.ZodOptional<z.ZodType<Prisma.ClaimFileMinAggregateInputType, z.ZodTypeDef, Prisma.ClaimFileMinAggregateInputType>>;
+    _max: z.ZodOptional<z.ZodType<Prisma.ClaimFileMaxAggregateInputType, z.ZodTypeDef, Prisma.ClaimFileMaxAggregateInputType>>;
+    _avg: z.ZodOptional<z.ZodType<Prisma.ClaimFileAvgAggregateInputType, z.ZodTypeDef, Prisma.ClaimFileAvgAggregateInputType>>;
+    _sum: z.ZodOptional<z.ZodType<Prisma.ClaimFileSumAggregateInputType, z.ZodTypeDef, Prisma.ClaimFileSumAggregateInputType>>;
+}, "strict", z.ZodTypeAny, {
+    where?: Prisma.ClaimFileWhereInput | undefined;
+    _count?: true | Prisma.ClaimFileCountAggregateInputType | undefined;
+    orderBy?: Prisma.ClaimFileOrderByWithRelationInput | Prisma.ClaimFileOrderByWithRelationInput[] | undefined;
+    cursor?: Prisma.ClaimFileWhereUniqueInput | undefined;
+    take?: number | undefined;
+    skip?: number | undefined;
+    _min?: Prisma.ClaimFileMinAggregateInputType | undefined;
+    _max?: Prisma.ClaimFileMaxAggregateInputType | undefined;
+    _avg?: Prisma.ClaimFileAvgAggregateInputType | undefined;
+    _sum?: Prisma.ClaimFileSumAggregateInputType | undefined;
+}, {
+    where?: Prisma.ClaimFileWhereInput | undefined;
+    _count?: true | Prisma.ClaimFileCountAggregateInputType | undefined;
+    orderBy?: Prisma.ClaimFileOrderByWithRelationInput | Prisma.ClaimFileOrderByWithRelationInput[] | undefined;
+    cursor?: Prisma.ClaimFileWhereUniqueInput | undefined;
+    take?: number | undefined;
+    skip?: number | undefined;
+    _min?: Prisma.ClaimFileMinAggregateInputType | undefined;
+    _max?: Prisma.ClaimFileMaxAggregateInputType | undefined;
+    _avg?: Prisma.ClaimFileAvgAggregateInputType | undefined;
+    _sum?: Prisma.ClaimFileSumAggregateInputType | undefined;
+}>;
+//# sourceMappingURL=aggregateClaimFile.schema.d.ts.map

packages/db/shared/schemas/aggregateClaimFile.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aggregateClaimFile.schema.d.ts","sourceRoot":"","sources":["aggregateClaimFile.schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAUzB,eAAO,MAAM,wBAAwB,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,sBAAsB,CAA2rB,CAAC;AAE1wB,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAmoB,CAAC"}

packages/db/shared/schemas/aggregateClaimFile.schema.js

@@ -0,0 +1,47 @@
+"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.ClaimFileAggregateZodSchema = exports.ClaimFileAggregateSchema = void 0;
+const z = __importStar(require("zod"));
+const ClaimFileOrderByWithRelationInput_schema_1 = require("./objects/ClaimFileOrderByWithRelationInput.schema");
+const ClaimFileWhereInput_schema_1 = require("./objects/ClaimFileWhereInput.schema");
+const ClaimFileWhereUniqueInput_schema_1 = require("./objects/ClaimFileWhereUniqueInput.schema");
+const ClaimFileCountAggregateInput_schema_1 = require("./objects/ClaimFileCountAggregateInput.schema");
+const ClaimFileMinAggregateInput_schema_1 = require("./objects/ClaimFileMinAggregateInput.schema");
+const ClaimFileMaxAggregateInput_schema_1 = require("./objects/ClaimFileMaxAggregateInput.schema");
+const ClaimFileAvgAggregateInput_schema_1 = require("./objects/ClaimFileAvgAggregateInput.schema");
+const ClaimFileSumAggregateInput_schema_1 = require("./objects/ClaimFileSumAggregateInput.schema");
+exports.ClaimFileAggregateSchema = z.object({ orderBy: z.union([ClaimFileOrderByWithRelationInput_schema_1.ClaimFileOrderByWithRelationInputObjectSchema, ClaimFileOrderByWithRelationInput_schema_1.ClaimFileOrderByWithRelationInputObjectSchema.array()]).optional(), where: ClaimFileWhereInput_schema_1.ClaimFileWhereInputObjectSchema.optional(), cursor: ClaimFileWhereUniqueInput_schema_1.ClaimFileWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), _count: z.union([z.literal(true), ClaimFileCountAggregateInput_schema_1.ClaimFileCountAggregateInputObjectSchema]).optional(), _min: ClaimFileMinAggregateInput_schema_1.ClaimFileMinAggregateInputObjectSchema.optional(), _max: ClaimFileMaxAggregateInput_schema_1.ClaimFileMaxAggregateInputObjectSchema.optional(), _avg: ClaimFileAvgAggregateInput_schema_1.ClaimFileAvgAggregateInputObjectSchema.optional(), _sum: ClaimFileSumAggregateInput_schema_1.ClaimFileSumAggregateInputObjectSchema.optional() }).strict();
+exports.ClaimFileAggregateZodSchema = z.object({ orderBy: z.union([ClaimFileOrderByWithRelationInput_schema_1.ClaimFileOrderByWithRelationInputObjectSchema, ClaimFileOrderByWithRelationInput_schema_1.ClaimFileOrderByWithRelationInputObjectSchema.array()]).optional(), where: ClaimFileWhereInput_schema_1.ClaimFileWhereInputObjectSchema.optional(), cursor: ClaimFileWhereUniqueInput_schema_1.ClaimFileWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), _count: z.union([z.literal(true), ClaimFileCountAggregateInput_schema_1.ClaimFileCountAggregateInputObjectSchema]).optional(), _min: ClaimFileMinAggregateInput_schema_1.ClaimFileMinAggregateInputObjectSchema.optional(), _max: ClaimFileMaxAggregateInput_schema_1.ClaimFileMaxAggregateInputObjectSchema.optional(), _avg: ClaimFileAvgAggregateInput_schema_1.ClaimFileAvgAggregateInputObjectSchema.optional(), _sum: ClaimFileSumAggregateInput_schema_1.ClaimFileSumAggregateInputObjectSchema.optional() }).strict();

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

@@ -0,0 +1,14 @@
+import type { Prisma } from '../../generated/prisma';
+import * as z from 'zod';
+import { ClaimFileOrderByWithRelationInputObjectSchema as ClaimFileOrderByWithRelationInputObjectSchema } from './objects/ClaimFileOrderByWithRelationInput.schema';
+import { ClaimFileWhereInputObjectSchema as ClaimFileWhereInputObjectSchema } from './objects/ClaimFileWhereInput.schema';
+import { ClaimFileWhereUniqueInputObjectSchema as ClaimFileWhereUniqueInputObjectSchema } from './objects/ClaimFileWhereUniqueInput.schema';
+import { ClaimFileCountAggregateInputObjectSchema as ClaimFileCountAggregateInputObjectSchema } from './objects/ClaimFileCountAggregateInput.schema';
+import { ClaimFileMinAggregateInputObjectSchema as ClaimFileMinAggregateInputObjectSchema } from './objects/ClaimFileMinAggregateInput.schema';
+import { ClaimFileMaxAggregateInputObjectSchema as ClaimFileMaxAggregateInputObjectSchema } from './objects/ClaimFileMaxAggregateInput.schema';
+import { ClaimFileAvgAggregateInputObjectSchema as ClaimFileAvgAggregateInputObjectSchema } from './objects/ClaimFileAvgAggregateInput.schema';
+import { ClaimFileSumAggregateInputObjectSchema as ClaimFileSumAggregateInputObjectSchema } from './objects/ClaimFileSumAggregateInput.schema';
+
+export const ClaimFileAggregateSchema: z.ZodType<Prisma.ClaimFileAggregateArgs> = z.object({ orderBy: z.union([ClaimFileOrderByWithRelationInputObjectSchema, ClaimFileOrderByWithRelationInputObjectSchema.array()]).optional(), where: ClaimFileWhereInputObjectSchema.optional(), cursor: ClaimFileWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), _count: z.union([ z.literal(true), ClaimFileCountAggregateInputObjectSchema ]).optional(), _min: ClaimFileMinAggregateInputObjectSchema.optional(), _max: ClaimFileMaxAggregateInputObjectSchema.optional(), _avg: ClaimFileAvgAggregateInputObjectSchema.optional(), _sum: ClaimFileSumAggregateInputObjectSchema.optional() }).strict() as unknown as z.ZodType<Prisma.ClaimFileAggregateArgs>;
+
+export const ClaimFileAggregateZodSchema = z.object({ orderBy: z.union([ClaimFileOrderByWithRelationInputObjectSchema, ClaimFileOrderByWithRelationInputObjectSchema.array()]).optional(), where: ClaimFileWhereInputObjectSchema.optional(), cursor: ClaimFileWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), _count: z.union([ z.literal(true), ClaimFileCountAggregateInputObjectSchema ]).optional(), _min: ClaimFileMinAggregateInputObjectSchema.optional(), _max: ClaimFileMaxAggregateInputObjectSchema.optional(), _avg: ClaimFileAvgAggregateInputObjectSchema.optional(), _sum: ClaimFileSumAggregateInputObjectSchema.optional() }).strict();

packages/db/shared/schemas/aggregateCloudFile.schema.d.ts

@@ -0,0 +1,38 @@
+import type { Prisma } from '../../generated/prisma';
+import * as z from 'zod';
+export declare const CloudFileAggregateSchema: z.ZodType<Prisma.CloudFileAggregateArgs>;
+export declare const CloudFileAggregateZodSchema: z.ZodObject<{
+    orderBy: z.ZodOptional<z.ZodUnion<[z.ZodType<Prisma.CloudFileOrderByWithRelationInput, z.ZodTypeDef, Prisma.CloudFileOrderByWithRelationInput>, z.ZodArray<z.ZodType<Prisma.CloudFileOrderByWithRelationInput, z.ZodTypeDef, Prisma.CloudFileOrderByWithRelationInput>, "many">]>>;
+    where: z.ZodOptional<z.ZodType<Prisma.CloudFileWhereInput, z.ZodTypeDef, Prisma.CloudFileWhereInput>>;
+    cursor: z.ZodOptional<z.ZodType<Prisma.CloudFileWhereUniqueInput, z.ZodTypeDef, Prisma.CloudFileWhereUniqueInput>>;
+    take: z.ZodOptional<z.ZodNumber>;
+    skip: z.ZodOptional<z.ZodNumber>;
+    _count: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<true>, z.ZodType<Prisma.CloudFileCountAggregateInputType, z.ZodTypeDef, Prisma.CloudFileCountAggregateInputType>]>>;
+    _min: z.ZodOptional<z.ZodType<Prisma.CloudFileMinAggregateInputType, z.ZodTypeDef, Prisma.CloudFileMinAggregateInputType>>;
+    _max: z.ZodOptional<z.ZodType<Prisma.CloudFileMaxAggregateInputType, z.ZodTypeDef, Prisma.CloudFileMaxAggregateInputType>>;
+    _avg: z.ZodOptional<z.ZodType<Prisma.CloudFileAvgAggregateInputType, z.ZodTypeDef, Prisma.CloudFileAvgAggregateInputType>>;
+    _sum: z.ZodOptional<z.ZodType<Prisma.CloudFileSumAggregateInputType, z.ZodTypeDef, Prisma.CloudFileSumAggregateInputType>>;
+}, "strict", z.ZodTypeAny, {
+    where?: Prisma.CloudFileWhereInput | undefined;
+    _count?: true | Prisma.CloudFileCountAggregateInputType | undefined;
+    orderBy?: Prisma.CloudFileOrderByWithRelationInput | Prisma.CloudFileOrderByWithRelationInput[] | undefined;
+    cursor?: Prisma.CloudFileWhereUniqueInput | undefined;
+    take?: number | undefined;
+    skip?: number | undefined;
+    _min?: Prisma.CloudFileMinAggregateInputType | undefined;
+    _max?: Prisma.CloudFileMaxAggregateInputType | undefined;
+    _avg?: Prisma.CloudFileAvgAggregateInputType | undefined;
+    _sum?: Prisma.CloudFileSumAggregateInputType | undefined;
+}, {
+    where?: Prisma.CloudFileWhereInput | undefined;
+    _count?: true | Prisma.CloudFileCountAggregateInputType | undefined;
+    orderBy?: Prisma.CloudFileOrderByWithRelationInput | Prisma.CloudFileOrderByWithRelationInput[] | undefined;
+    cursor?: Prisma.CloudFileWhereUniqueInput | undefined;
+    take?: number | undefined;
+    skip?: number | undefined;
+    _min?: Prisma.CloudFileMinAggregateInputType | undefined;
+    _max?: Prisma.CloudFileMaxAggregateInputType | undefined;
+    _avg?: Prisma.CloudFileAvgAggregateInputType | undefined;
+    _sum?: Prisma.CloudFileSumAggregateInputType | undefined;
+}>;
+//# sourceMappingURL=aggregateCloudFile.schema.d.ts.map

packages/db/shared/schemas/aggregateCloudFile.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aggregateCloudFile.schema.d.ts","sourceRoot":"","sources":["aggregateCloudFile.schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAUzB,eAAO,MAAM,wBAAwB,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,sBAAsB,CAA2rB,CAAC;AAE1wB,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAmoB,CAAC"}

packages/db/shared/schemas/aggregateCloudFile.schema.js

@@ -0,0 +1,47 @@
+"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.CloudFileAggregateZodSchema = exports.CloudFileAggregateSchema = void 0;
+const z = __importStar(require("zod"));
+const CloudFileOrderByWithRelationInput_schema_1 = require("./objects/CloudFileOrderByWithRelationInput.schema");
+const CloudFileWhereInput_schema_1 = require("./objects/CloudFileWhereInput.schema");
+const CloudFileWhereUniqueInput_schema_1 = require("./objects/CloudFileWhereUniqueInput.schema");
+const CloudFileCountAggregateInput_schema_1 = require("./objects/CloudFileCountAggregateInput.schema");
+const CloudFileMinAggregateInput_schema_1 = require("./objects/CloudFileMinAggregateInput.schema");
+const CloudFileMaxAggregateInput_schema_1 = require("./objects/CloudFileMaxAggregateInput.schema");
+const CloudFileAvgAggregateInput_schema_1 = require("./objects/CloudFileAvgAggregateInput.schema");
+const CloudFileSumAggregateInput_schema_1 = require("./objects/CloudFileSumAggregateInput.schema");
+exports.CloudFileAggregateSchema = z.object({ orderBy: z.union([CloudFileOrderByWithRelationInput_schema_1.CloudFileOrderByWithRelationInputObjectSchema, CloudFileOrderByWithRelationInput_schema_1.CloudFileOrderByWithRelationInputObjectSchema.array()]).optional(), where: CloudFileWhereInput_schema_1.CloudFileWhereInputObjectSchema.optional(), cursor: CloudFileWhereUniqueInput_schema_1.CloudFileWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), _count: z.union([z.literal(true), CloudFileCountAggregateInput_schema_1.CloudFileCountAggregateInputObjectSchema]).optional(), _min: CloudFileMinAggregateInput_schema_1.CloudFileMinAggregateInputObjectSchema.optional(), _max: CloudFileMaxAggregateInput_schema_1.CloudFileMaxAggregateInputObjectSchema.optional(), _avg: CloudFileAvgAggregateInput_schema_1.CloudFileAvgAggregateInputObjectSchema.optional(), _sum: CloudFileSumAggregateInput_schema_1.CloudFileSumAggregateInputObjectSchema.optional() }).strict();
+exports.CloudFileAggregateZodSchema = z.object({ orderBy: z.union([CloudFileOrderByWithRelationInput_schema_1.CloudFileOrderByWithRelationInputObjectSchema, CloudFileOrderByWithRelationInput_schema_1.CloudFileOrderByWithRelationInputObjectSchema.array()]).optional(), where: CloudFileWhereInput_schema_1.CloudFileWhereInputObjectSchema.optional(), cursor: CloudFileWhereUniqueInput_schema_1.CloudFileWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), _count: z.union([z.literal(true), CloudFileCountAggregateInput_schema_1.CloudFileCountAggregateInputObjectSchema]).optional(), _min: CloudFileMinAggregateInput_schema_1.CloudFileMinAggregateInputObjectSchema.optional(), _max: CloudFileMaxAggregateInput_schema_1.CloudFileMaxAggregateInputObjectSchema.optional(), _avg: CloudFileAvgAggregateInput_schema_1.CloudFileAvgAggregateInputObjectSchema.optional(), _sum: CloudFileSumAggregateInput_schema_1.CloudFileSumAggregateInputObjectSchema.optional() }).strict();

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

@@ -0,0 +1,14 @@
+import type { Prisma } from '../../generated/prisma';
+import * as z from 'zod';
+import { CloudFileOrderByWithRelationInputObjectSchema as CloudFileOrderByWithRelationInputObjectSchema } from './objects/CloudFileOrderByWithRelationInput.schema';
+import { CloudFileWhereInputObjectSchema as CloudFileWhereInputObjectSchema } from './objects/CloudFileWhereInput.schema';
+import { CloudFileWhereUniqueInputObjectSchema as CloudFileWhereUniqueInputObjectSchema } from './objects/CloudFileWhereUniqueInput.schema';
+import { CloudFileCountAggregateInputObjectSchema as CloudFileCountAggregateInputObjectSchema } from './objects/CloudFileCountAggregateInput.schema';
+import { CloudFileMinAggregateInputObjectSchema as CloudFileMinAggregateInputObjectSchema } from './objects/CloudFileMinAggregateInput.schema';
+import { CloudFileMaxAggregateInputObjectSchema as CloudFileMaxAggregateInputObjectSchema } from './objects/CloudFileMaxAggregateInput.schema';
+import { CloudFileAvgAggregateInputObjectSchema as CloudFileAvgAggregateInputObjectSchema } from './objects/CloudFileAvgAggregateInput.schema';
+import { CloudFileSumAggregateInputObjectSchema as CloudFileSumAggregateInputObjectSchema } from './objects/CloudFileSumAggregateInput.schema';
+
+export const CloudFileAggregateSchema: z.ZodType<Prisma.CloudFileAggregateArgs> = z.object({ orderBy: z.union([CloudFileOrderByWithRelationInputObjectSchema, CloudFileOrderByWithRelationInputObjectSchema.array()]).optional(), where: CloudFileWhereInputObjectSchema.optional(), cursor: CloudFileWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), _count: z.union([ z.literal(true), CloudFileCountAggregateInputObjectSchema ]).optional(), _min: CloudFileMinAggregateInputObjectSchema.optional(), _max: CloudFileMaxAggregateInputObjectSchema.optional(), _avg: CloudFileAvgAggregateInputObjectSchema.optional(), _sum: CloudFileSumAggregateInputObjectSchema.optional() }).strict() as unknown as z.ZodType<Prisma.CloudFileAggregateArgs>;
+
+export const CloudFileAggregateZodSchema = z.object({ orderBy: z.union([CloudFileOrderByWithRelationInputObjectSchema, CloudFileOrderByWithRelationInputObjectSchema.array()]).optional(), where: CloudFileWhereInputObjectSchema.optional(), cursor: CloudFileWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), _count: z.union([ z.literal(true), CloudFileCountAggregateInputObjectSchema ]).optional(), _min: CloudFileMinAggregateInputObjectSchema.optional(), _max: CloudFileMaxAggregateInputObjectSchema.optional(), _avg: CloudFileAvgAggregateInputObjectSchema.optional(), _sum: CloudFileSumAggregateInputObjectSchema.optional() }).strict();

packages/db/shared/schemas/aggregateCloudFileChunk.schema.d.ts

@@ -0,0 +1,38 @@
+import type { Prisma } from '../../generated/prisma';
+import * as z from 'zod';
+export declare const CloudFileChunkAggregateSchema: z.ZodType<Prisma.CloudFileChunkAggregateArgs>;
+export declare const CloudFileChunkAggregateZodSchema: z.ZodObject<{
+    orderBy: z.ZodOptional<z.ZodUnion<[z.ZodType<Prisma.CloudFileChunkOrderByWithRelationInput, z.ZodTypeDef, Prisma.CloudFileChunkOrderByWithRelationInput>, z.ZodArray<z.ZodType<Prisma.CloudFileChunkOrderByWithRelationInput, z.ZodTypeDef, Prisma.CloudFileChunkOrderByWithRelationInput>, "many">]>>;
+    where: z.ZodOptional<z.ZodType<Prisma.CloudFileChunkWhereInput, z.ZodTypeDef, Prisma.CloudFileChunkWhereInput>>;
+    cursor: z.ZodOptional<z.ZodType<Prisma.CloudFileChunkWhereUniqueInput, z.ZodTypeDef, Prisma.CloudFileChunkWhereUniqueInput>>;
+    take: z.ZodOptional<z.ZodNumber>;
+    skip: z.ZodOptional<z.ZodNumber>;
+    _count: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<true>, z.ZodType<Prisma.CloudFileChunkCountAggregateInputType, z.ZodTypeDef, Prisma.CloudFileChunkCountAggregateInputType>]>>;
+    _min: z.ZodOptional<z.ZodType<Prisma.CloudFileChunkMinAggregateInputType, z.ZodTypeDef, Prisma.CloudFileChunkMinAggregateInputType>>;
+    _max: z.ZodOptional<z.ZodType<Prisma.CloudFileChunkMaxAggregateInputType, z.ZodTypeDef, Prisma.CloudFileChunkMaxAggregateInputType>>;
+    _avg: z.ZodOptional<z.ZodType<Prisma.CloudFileChunkAvgAggregateInputType, z.ZodTypeDef, Prisma.CloudFileChunkAvgAggregateInputType>>;
+    _sum: z.ZodOptional<z.ZodType<Prisma.CloudFileChunkSumAggregateInputType, z.ZodTypeDef, Prisma.CloudFileChunkSumAggregateInputType>>;
+}, "strict", z.ZodTypeAny, {
+    where?: Prisma.CloudFileChunkWhereInput | undefined;
+    _count?: true | Prisma.CloudFileChunkCountAggregateInputType | undefined;
+    orderBy?: Prisma.CloudFileChunkOrderByWithRelationInput | Prisma.CloudFileChunkOrderByWithRelationInput[] | undefined;
+    cursor?: Prisma.CloudFileChunkWhereUniqueInput | undefined;
+    take?: number | undefined;
+    skip?: number | undefined;
+    _min?: Prisma.CloudFileChunkMinAggregateInputType | undefined;
+    _max?: Prisma.CloudFileChunkMaxAggregateInputType | undefined;
+    _avg?: Prisma.CloudFileChunkAvgAggregateInputType | undefined;
+    _sum?: Prisma.CloudFileChunkSumAggregateInputType | undefined;
+}, {
+    where?: Prisma.CloudFileChunkWhereInput | undefined;
+    _count?: true | Prisma.CloudFileChunkCountAggregateInputType | undefined;
+    orderBy?: Prisma.CloudFileChunkOrderByWithRelationInput | Prisma.CloudFileChunkOrderByWithRelationInput[] | undefined;
+    cursor?: Prisma.CloudFileChunkWhereUniqueInput | undefined;
+    take?: number | undefined;
+    skip?: number | undefined;
+    _min?: Prisma.CloudFileChunkMinAggregateInputType | undefined;
+    _max?: Prisma.CloudFileChunkMaxAggregateInputType | undefined;
+    _avg?: Prisma.CloudFileChunkAvgAggregateInputType | undefined;
+    _sum?: Prisma.CloudFileChunkSumAggregateInputType | undefined;
+}>;
+//# sourceMappingURL=aggregateCloudFileChunk.schema.d.ts.map

packages/db/shared/schemas/aggregateCloudFileChunk.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aggregateCloudFileChunk.schema.d.ts","sourceRoot":"","sources":["aggregateCloudFileChunk.schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAUzB,eAAO,MAAM,6BAA6B,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,2BAA2B,CAA6uB,CAAC;AAEt0B,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAgrB,CAAC"}

packages/db/shared/schemas/aggregateCloudFileChunk.schema.js

@@ -0,0 +1,47 @@
+"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.CloudFileChunkAggregateZodSchema = exports.CloudFileChunkAggregateSchema = void 0;
+const z = __importStar(require("zod"));
+const CloudFileChunkOrderByWithRelationInput_schema_1 = require("./objects/CloudFileChunkOrderByWithRelationInput.schema");
+const CloudFileChunkWhereInput_schema_1 = require("./objects/CloudFileChunkWhereInput.schema");
+const CloudFileChunkWhereUniqueInput_schema_1 = require("./objects/CloudFileChunkWhereUniqueInput.schema");
+const CloudFileChunkCountAggregateInput_schema_1 = require("./objects/CloudFileChunkCountAggregateInput.schema");
+const CloudFileChunkMinAggregateInput_schema_1 = require("./objects/CloudFileChunkMinAggregateInput.schema");
+const CloudFileChunkMaxAggregateInput_schema_1 = require("./objects/CloudFileChunkMaxAggregateInput.schema");
+const CloudFileChunkAvgAggregateInput_schema_1 = require("./objects/CloudFileChunkAvgAggregateInput.schema");
+const CloudFileChunkSumAggregateInput_schema_1 = require("./objects/CloudFileChunkSumAggregateInput.schema");
+exports.CloudFileChunkAggregateSchema = z.object({ orderBy: z.union([CloudFileChunkOrderByWithRelationInput_schema_1.CloudFileChunkOrderByWithRelationInputObjectSchema, CloudFileChunkOrderByWithRelationInput_schema_1.CloudFileChunkOrderByWithRelationInputObjectSchema.array()]).optional(), where: CloudFileChunkWhereInput_schema_1.CloudFileChunkWhereInputObjectSchema.optional(), cursor: CloudFileChunkWhereUniqueInput_schema_1.CloudFileChunkWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), _count: z.union([z.literal(true), CloudFileChunkCountAggregateInput_schema_1.CloudFileChunkCountAggregateInputObjectSchema]).optional(), _min: CloudFileChunkMinAggregateInput_schema_1.CloudFileChunkMinAggregateInputObjectSchema.optional(), _max: CloudFileChunkMaxAggregateInput_schema_1.CloudFileChunkMaxAggregateInputObjectSchema.optional(), _avg: CloudFileChunkAvgAggregateInput_schema_1.CloudFileChunkAvgAggregateInputObjectSchema.optional(), _sum: CloudFileChunkSumAggregateInput_schema_1.CloudFileChunkSumAggregateInputObjectSchema.optional() }).strict();
+exports.CloudFileChunkAggregateZodSchema = z.object({ orderBy: z.union([CloudFileChunkOrderByWithRelationInput_schema_1.CloudFileChunkOrderByWithRelationInputObjectSchema, CloudFileChunkOrderByWithRelationInput_schema_1.CloudFileChunkOrderByWithRelationInputObjectSchema.array()]).optional(), where: CloudFileChunkWhereInput_schema_1.CloudFileChunkWhereInputObjectSchema.optional(), cursor: CloudFileChunkWhereUniqueInput_schema_1.CloudFileChunkWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), _count: z.union([z.literal(true), CloudFileChunkCountAggregateInput_schema_1.CloudFileChunkCountAggregateInputObjectSchema]).optional(), _min: CloudFileChunkMinAggregateInput_schema_1.CloudFileChunkMinAggregateInputObjectSchema.optional(), _max: CloudFileChunkMaxAggregateInput_schema_1.CloudFileChunkMaxAggregateInputObjectSchema.optional(), _avg: CloudFileChunkAvgAggregateInput_schema_1.CloudFileChunkAvgAggregateInputObjectSchema.optional(), _sum: CloudFileChunkSumAggregateInput_schema_1.CloudFileChunkSumAggregateInputObjectSchema.optional() }).strict();

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

@@ -0,0 +1,14 @@
+import type { Prisma } from '../../generated/prisma';
+import * as z from 'zod';
+import { CloudFileChunkOrderByWithRelationInputObjectSchema as CloudFileChunkOrderByWithRelationInputObjectSchema } from './objects/CloudFileChunkOrderByWithRelationInput.schema';
+import { CloudFileChunkWhereInputObjectSchema as CloudFileChunkWhereInputObjectSchema } from './objects/CloudFileChunkWhereInput.schema';
+import { CloudFileChunkWhereUniqueInputObjectSchema as CloudFileChunkWhereUniqueInputObjectSchema } from './objects/CloudFileChunkWhereUniqueInput.schema';
+import { CloudFileChunkCountAggregateInputObjectSchema as CloudFileChunkCountAggregateInputObjectSchema } from './objects/CloudFileChunkCountAggregateInput.schema';
+import { CloudFileChunkMinAggregateInputObjectSchema as CloudFileChunkMinAggregateInputObjectSchema } from './objects/CloudFileChunkMinAggregateInput.schema';
+import { CloudFileChunkMaxAggregateInputObjectSchema as CloudFileChunkMaxAggregateInputObjectSchema } from './objects/CloudFileChunkMaxAggregateInput.schema';
+import { CloudFileChunkAvgAggregateInputObjectSchema as CloudFileChunkAvgAggregateInputObjectSchema } from './objects/CloudFileChunkAvgAggregateInput.schema';
+import { CloudFileChunkSumAggregateInputObjectSchema as CloudFileChunkSumAggregateInputObjectSchema } from './objects/CloudFileChunkSumAggregateInput.schema';
+
+export const CloudFileChunkAggregateSchema: z.ZodType<Prisma.CloudFileChunkAggregateArgs> = z.object({ orderBy: z.union([CloudFileChunkOrderByWithRelationInputObjectSchema, CloudFileChunkOrderByWithRelationInputObjectSchema.array()]).optional(), where: CloudFileChunkWhereInputObjectSchema.optional(), cursor: CloudFileChunkWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), _count: z.union([ z.literal(true), CloudFileChunkCountAggregateInputObjectSchema ]).optional(), _min: CloudFileChunkMinAggregateInputObjectSchema.optional(), _max: CloudFileChunkMaxAggregateInputObjectSchema.optional(), _avg: CloudFileChunkAvgAggregateInputObjectSchema.optional(), _sum: CloudFileChunkSumAggregateInputObjectSchema.optional() }).strict() as unknown as z.ZodType<Prisma.CloudFileChunkAggregateArgs>;
+
+export const CloudFileChunkAggregateZodSchema = z.object({ orderBy: z.union([CloudFileChunkOrderByWithRelationInputObjectSchema, CloudFileChunkOrderByWithRelationInputObjectSchema.array()]).optional(), where: CloudFileChunkWhereInputObjectSchema.optional(), cursor: CloudFileChunkWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), _count: z.union([ z.literal(true), CloudFileChunkCountAggregateInputObjectSchema ]).optional(), _min: CloudFileChunkMinAggregateInputObjectSchema.optional(), _max: CloudFileChunkMaxAggregateInputObjectSchema.optional(), _avg: CloudFileChunkAvgAggregateInputObjectSchema.optional(), _sum: CloudFileChunkSumAggregateInputObjectSchema.optional() }).strict();

packages/db/shared/schemas/aggregateCloudFolder.schema.d.ts

@@ -0,0 +1,38 @@
+import type { Prisma } from '../../generated/prisma';
+import * as z from 'zod';
+export declare const CloudFolderAggregateSchema: z.ZodType<Prisma.CloudFolderAggregateArgs>;
+export declare const CloudFolderAggregateZodSchema: z.ZodObject<{
+    orderBy: z.ZodOptional<z.ZodUnion<[z.ZodType<Prisma.CloudFolderOrderByWithRelationInput, z.ZodTypeDef, Prisma.CloudFolderOrderByWithRelationInput>, z.ZodArray<z.ZodType<Prisma.CloudFolderOrderByWithRelationInput, z.ZodTypeDef, Prisma.CloudFolderOrderByWithRelationInput>, "many">]>>;
+    where: z.ZodOptional<z.ZodType<Prisma.CloudFolderWhereInput, z.ZodTypeDef, Prisma.CloudFolderWhereInput>>;
+    cursor: z.ZodOptional<z.ZodType<Prisma.CloudFolderWhereUniqueInput, z.ZodTypeDef, Prisma.CloudFolderWhereUniqueInput>>;
+    take: z.ZodOptional<z.ZodNumber>;
+    skip: z.ZodOptional<z.ZodNumber>;
+    _count: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<true>, z.ZodType<Prisma.CloudFolderCountAggregateInputType, z.ZodTypeDef, Prisma.CloudFolderCountAggregateInputType>]>>;
+    _min: z.ZodOptional<z.ZodType<Prisma.CloudFolderMinAggregateInputType, z.ZodTypeDef, Prisma.CloudFolderMinAggregateInputType>>;
+    _max: z.ZodOptional<z.ZodType<Prisma.CloudFolderMaxAggregateInputType, z.ZodTypeDef, Prisma.CloudFolderMaxAggregateInputType>>;
+    _avg: z.ZodOptional<z.ZodType<Prisma.CloudFolderAvgAggregateInputType, z.ZodTypeDef, Prisma.CloudFolderAvgAggregateInputType>>;
+    _sum: z.ZodOptional<z.ZodType<Prisma.CloudFolderSumAggregateInputType, z.ZodTypeDef, Prisma.CloudFolderSumAggregateInputType>>;
+}, "strict", z.ZodTypeAny, {
+    where?: Prisma.CloudFolderWhereInput | undefined;
+    _count?: true | Prisma.CloudFolderCountAggregateInputType | undefined;
+    orderBy?: Prisma.CloudFolderOrderByWithRelationInput | Prisma.CloudFolderOrderByWithRelationInput[] | undefined;
+    cursor?: Prisma.CloudFolderWhereUniqueInput | undefined;
+    take?: number | undefined;
+    skip?: number | undefined;
+    _min?: Prisma.CloudFolderMinAggregateInputType | undefined;
+    _max?: Prisma.CloudFolderMaxAggregateInputType | undefined;
+    _avg?: Prisma.CloudFolderAvgAggregateInputType | undefined;
+    _sum?: Prisma.CloudFolderSumAggregateInputType | undefined;
+}, {
+    where?: Prisma.CloudFolderWhereInput | undefined;
+    _count?: true | Prisma.CloudFolderCountAggregateInputType | undefined;
+    orderBy?: Prisma.CloudFolderOrderByWithRelationInput | Prisma.CloudFolderOrderByWithRelationInput[] | undefined;
+    cursor?: Prisma.CloudFolderWhereUniqueInput | undefined;
+    take?: number | undefined;
+    skip?: number | undefined;
+    _min?: Prisma.CloudFolderMinAggregateInputType | undefined;
+    _max?: Prisma.CloudFolderMaxAggregateInputType | undefined;
+    _avg?: Prisma.CloudFolderAvgAggregateInputType | undefined;
+    _sum?: Prisma.CloudFolderSumAggregateInputType | undefined;
+}>;
+//# sourceMappingURL=aggregateCloudFolder.schema.d.ts.map

packages/db/shared/schemas/aggregateCloudFolder.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aggregateCloudFolder.schema.d.ts","sourceRoot":"","sources":["aggregateCloudFolder.schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAUzB,eAAO,MAAM,0BAA0B,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,wBAAwB,CAA+sB,CAAC;AAElyB,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAqpB,CAAC"}

packages/db/shared/schemas/aggregateCloudFolder.schema.js

@@ -0,0 +1,47 @@
+"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.CloudFolderAggregateZodSchema = exports.CloudFolderAggregateSchema = void 0;
+const z = __importStar(require("zod"));
+const CloudFolderOrderByWithRelationInput_schema_1 = require("./objects/CloudFolderOrderByWithRelationInput.schema");
+const CloudFolderWhereInput_schema_1 = require("./objects/CloudFolderWhereInput.schema");
+const CloudFolderWhereUniqueInput_schema_1 = require("./objects/CloudFolderWhereUniqueInput.schema");
+const CloudFolderCountAggregateInput_schema_1 = require("./objects/CloudFolderCountAggregateInput.schema");
+const CloudFolderMinAggregateInput_schema_1 = require("./objects/CloudFolderMinAggregateInput.schema");
+const CloudFolderMaxAggregateInput_schema_1 = require("./objects/CloudFolderMaxAggregateInput.schema");
+const CloudFolderAvgAggregateInput_schema_1 = require("./objects/CloudFolderAvgAggregateInput.schema");
+const CloudFolderSumAggregateInput_schema_1 = require("./objects/CloudFolderSumAggregateInput.schema");
+exports.CloudFolderAggregateSchema = z.object({ orderBy: z.union([CloudFolderOrderByWithRelationInput_schema_1.CloudFolderOrderByWithRelationInputObjectSchema, CloudFolderOrderByWithRelationInput_schema_1.CloudFolderOrderByWithRelationInputObjectSchema.array()]).optional(), where: CloudFolderWhereInput_schema_1.CloudFolderWhereInputObjectSchema.optional(), cursor: CloudFolderWhereUniqueInput_schema_1.CloudFolderWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), _count: z.union([z.literal(true), CloudFolderCountAggregateInput_schema_1.CloudFolderCountAggregateInputObjectSchema]).optional(), _min: CloudFolderMinAggregateInput_schema_1.CloudFolderMinAggregateInputObjectSchema.optional(), _max: CloudFolderMaxAggregateInput_schema_1.CloudFolderMaxAggregateInputObjectSchema.optional(), _avg: CloudFolderAvgAggregateInput_schema_1.CloudFolderAvgAggregateInputObjectSchema.optional(), _sum: CloudFolderSumAggregateInput_schema_1.CloudFolderSumAggregateInputObjectSchema.optional() }).strict();
+exports.CloudFolderAggregateZodSchema = z.object({ orderBy: z.union([CloudFolderOrderByWithRelationInput_schema_1.CloudFolderOrderByWithRelationInputObjectSchema, CloudFolderOrderByWithRelationInput_schema_1.CloudFolderOrderByWithRelationInputObjectSchema.array()]).optional(), where: CloudFolderWhereInput_schema_1.CloudFolderWhereInputObjectSchema.optional(), cursor: CloudFolderWhereUniqueInput_schema_1.CloudFolderWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), _count: z.union([z.literal(true), CloudFolderCountAggregateInput_schema_1.CloudFolderCountAggregateInputObjectSchema]).optional(), _min: CloudFolderMinAggregateInput_schema_1.CloudFolderMinAggregateInputObjectSchema.optional(), _max: CloudFolderMaxAggregateInput_schema_1.CloudFolderMaxAggregateInputObjectSchema.optional(), _avg: CloudFolderAvgAggregateInput_schema_1.CloudFolderAvgAggregateInputObjectSchema.optional(), _sum: CloudFolderSumAggregateInput_schema_1.CloudFolderSumAggregateInputObjectSchema.optional() }).strict();

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

@@ -0,0 +1,14 @@
+import type { Prisma } from '../../generated/prisma';
+import * as z from 'zod';
+import { CloudFolderOrderByWithRelationInputObjectSchema as CloudFolderOrderByWithRelationInputObjectSchema } from './objects/CloudFolderOrderByWithRelationInput.schema';
+import { CloudFolderWhereInputObjectSchema as CloudFolderWhereInputObjectSchema } from './objects/CloudFolderWhereInput.schema';
+import { CloudFolderWhereUniqueInputObjectSchema as CloudFolderWhereUniqueInputObjectSchema } from './objects/CloudFolderWhereUniqueInput.schema';
+import { CloudFolderCountAggregateInputObjectSchema as CloudFolderCountAggregateInputObjectSchema } from './objects/CloudFolderCountAggregateInput.schema';
+import { CloudFolderMinAggregateInputObjectSchema as CloudFolderMinAggregateInputObjectSchema } from './objects/CloudFolderMinAggregateInput.schema';
+import { CloudFolderMaxAggregateInputObjectSchema as CloudFolderMaxAggregateInputObjectSchema } from './objects/CloudFolderMaxAggregateInput.schema';
+import { CloudFolderAvgAggregateInputObjectSchema as CloudFolderAvgAggregateInputObjectSchema } from './objects/CloudFolderAvgAggregateInput.schema';
+import { CloudFolderSumAggregateInputObjectSchema as CloudFolderSumAggregateInputObjectSchema } from './objects/CloudFolderSumAggregateInput.schema';
+
+export const CloudFolderAggregateSchema: z.ZodType<Prisma.CloudFolderAggregateArgs> = z.object({ orderBy: z.union([CloudFolderOrderByWithRelationInputObjectSchema, CloudFolderOrderByWithRelationInputObjectSchema.array()]).optional(), where: CloudFolderWhereInputObjectSchema.optional(), cursor: CloudFolderWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), _count: z.union([ z.literal(true), CloudFolderCountAggregateInputObjectSchema ]).optional(), _min: CloudFolderMinAggregateInputObjectSchema.optional(), _max: CloudFolderMaxAggregateInputObjectSchema.optional(), _avg: CloudFolderAvgAggregateInputObjectSchema.optional(), _sum: CloudFolderSumAggregateInputObjectSchema.optional() }).strict() as unknown as z.ZodType<Prisma.CloudFolderAggregateArgs>;
+
+export const CloudFolderAggregateZodSchema = z.object({ orderBy: z.union([CloudFolderOrderByWithRelationInputObjectSchema, CloudFolderOrderByWithRelationInputObjectSchema.array()]).optional(), where: CloudFolderWhereInputObjectSchema.optional(), cursor: CloudFolderWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), _count: z.union([ z.literal(true), CloudFolderCountAggregateInputObjectSchema ]).optional(), _min: CloudFolderMinAggregateInputObjectSchema.optional(), _max: CloudFolderMaxAggregateInputObjectSchema.optional(), _avg: CloudFolderAvgAggregateInputObjectSchema.optional(), _sum: CloudFolderSumAggregateInputObjectSchema.optional() }).strict();

packages/db/shared/schemas/aggregateCommunication.schema.d.ts

@@ -0,0 +1,38 @@
+import type { Prisma } from '../../generated/prisma';
+import * as z from 'zod';
+export declare const CommunicationAggregateSchema: z.ZodType<Prisma.CommunicationAggregateArgs>;
+export declare const CommunicationAggregateZodSchema: z.ZodObject<{
+    orderBy: z.ZodOptional<z.ZodUnion<[z.ZodType<Prisma.CommunicationOrderByWithRelationInput, z.ZodTypeDef, Prisma.CommunicationOrderByWithRelationInput>, z.ZodArray<z.ZodType<Prisma.CommunicationOrderByWithRelationInput, z.ZodTypeDef, Prisma.CommunicationOrderByWithRelationInput>, "many">]>>;
+    where: z.ZodOptional<z.ZodType<Prisma.CommunicationWhereInput, z.ZodTypeDef, Prisma.CommunicationWhereInput>>;
+    cursor: z.ZodOptional<z.ZodType<Prisma.CommunicationWhereUniqueInput, z.ZodTypeDef, Prisma.CommunicationWhereUniqueInput>>;
+    take: z.ZodOptional<z.ZodNumber>;
+    skip: z.ZodOptional<z.ZodNumber>;
+    _count: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<true>, z.ZodType<Prisma.CommunicationCountAggregateInputType, z.ZodTypeDef, Prisma.CommunicationCountAggregateInputType>]>>;
+    _min: z.ZodOptional<z.ZodType<Prisma.CommunicationMinAggregateInputType, z.ZodTypeDef, Prisma.CommunicationMinAggregateInputType>>;
+    _max: z.ZodOptional<z.ZodType<Prisma.CommunicationMaxAggregateInputType, z.ZodTypeDef, Prisma.CommunicationMaxAggregateInputType>>;
+    _avg: z.ZodOptional<z.ZodType<Prisma.CommunicationAvgAggregateInputType, z.ZodTypeDef, Prisma.CommunicationAvgAggregateInputType>>;
+    _sum: z.ZodOptional<z.ZodType<Prisma.CommunicationSumAggregateInputType, z.ZodTypeDef, Prisma.CommunicationSumAggregateInputType>>;
+}, "strict", z.ZodTypeAny, {
+    where?: Prisma.CommunicationWhereInput | undefined;
+    _count?: true | Prisma.CommunicationCountAggregateInputType | undefined;
+    orderBy?: Prisma.CommunicationOrderByWithRelationInput | Prisma.CommunicationOrderByWithRelationInput[] | undefined;
+    cursor?: Prisma.CommunicationWhereUniqueInput | undefined;
+    take?: number | undefined;
+    skip?: number | undefined;
+    _min?: Prisma.CommunicationMinAggregateInputType | undefined;
+    _max?: Prisma.CommunicationMaxAggregateInputType | undefined;
+    _avg?: Prisma.CommunicationAvgAggregateInputType | undefined;
+    _sum?: Prisma.CommunicationSumAggregateInputType | undefined;
+}, {
+    where?: Prisma.CommunicationWhereInput | undefined;
+    _count?: true | Prisma.CommunicationCountAggregateInputType | undefined;
+    orderBy?: Prisma.CommunicationOrderByWithRelationInput | Prisma.CommunicationOrderByWithRelationInput[] | undefined;
+    cursor?: Prisma.CommunicationWhereUniqueInput | undefined;
+    take?: number | undefined;
+    skip?: number | undefined;
+    _min?: Prisma.CommunicationMinAggregateInputType | undefined;
+    _max?: Prisma.CommunicationMaxAggregateInputType | undefined;
+    _avg?: Prisma.CommunicationAvgAggregateInputType | undefined;
+    _sum?: Prisma.CommunicationSumAggregateInputType | undefined;
+}>;
+//# sourceMappingURL=aggregateCommunication.schema.d.ts.map

packages/db/shared/schemas/aggregateCommunication.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aggregateCommunication.schema.d.ts","sourceRoot":"","sources":["aggregateCommunication.schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAUzB,eAAO,MAAM,4BAA4B,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,0BAA0B,CAAmuB,CAAC;AAE1zB,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAuqB,CAAC"}

packages/db/shared/schemas/aggregateCommunication.schema.js

@@ -0,0 +1,47 @@
+"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.CommunicationAggregateZodSchema = exports.CommunicationAggregateSchema = void 0;
+const z = __importStar(require("zod"));
+const CommunicationOrderByWithRelationInput_schema_1 = require("./objects/CommunicationOrderByWithRelationInput.schema");
+const CommunicationWhereInput_schema_1 = require("./objects/CommunicationWhereInput.schema");
+const CommunicationWhereUniqueInput_schema_1 = require("./objects/CommunicationWhereUniqueInput.schema");
+const CommunicationCountAggregateInput_schema_1 = require("./objects/CommunicationCountAggregateInput.schema");
+const CommunicationMinAggregateInput_schema_1 = require("./objects/CommunicationMinAggregateInput.schema");
+const CommunicationMaxAggregateInput_schema_1 = require("./objects/CommunicationMaxAggregateInput.schema");
+const CommunicationAvgAggregateInput_schema_1 = require("./objects/CommunicationAvgAggregateInput.schema");
+const CommunicationSumAggregateInput_schema_1 = require("./objects/CommunicationSumAggregateInput.schema");
+exports.CommunicationAggregateSchema = z.object({ orderBy: z.union([CommunicationOrderByWithRelationInput_schema_1.CommunicationOrderByWithRelationInputObjectSchema, CommunicationOrderByWithRelationInput_schema_1.CommunicationOrderByWithRelationInputObjectSchema.array()]).optional(), where: CommunicationWhereInput_schema_1.CommunicationWhereInputObjectSchema.optional(), cursor: CommunicationWhereUniqueInput_schema_1.CommunicationWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), _count: z.union([z.literal(true), CommunicationCountAggregateInput_schema_1.CommunicationCountAggregateInputObjectSchema]).optional(), _min: CommunicationMinAggregateInput_schema_1.CommunicationMinAggregateInputObjectSchema.optional(), _max: CommunicationMaxAggregateInput_schema_1.CommunicationMaxAggregateInputObjectSchema.optional(), _avg: CommunicationAvgAggregateInput_schema_1.CommunicationAvgAggregateInputObjectSchema.optional(), _sum: CommunicationSumAggregateInput_schema_1.CommunicationSumAggregateInputObjectSchema.optional() }).strict();
+exports.CommunicationAggregateZodSchema = z.object({ orderBy: z.union([CommunicationOrderByWithRelationInput_schema_1.CommunicationOrderByWithRelationInputObjectSchema, CommunicationOrderByWithRelationInput_schema_1.CommunicationOrderByWithRelationInputObjectSchema.array()]).optional(), where: CommunicationWhereInput_schema_1.CommunicationWhereInputObjectSchema.optional(), cursor: CommunicationWhereUniqueInput_schema_1.CommunicationWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), _count: z.union([z.literal(true), CommunicationCountAggregateInput_schema_1.CommunicationCountAggregateInputObjectSchema]).optional(), _min: CommunicationMinAggregateInput_schema_1.CommunicationMinAggregateInputObjectSchema.optional(), _max: CommunicationMaxAggregateInput_schema_1.CommunicationMaxAggregateInputObjectSchema.optional(), _avg: CommunicationAvgAggregateInput_schema_1.CommunicationAvgAggregateInputObjectSchema.optional(), _sum: CommunicationSumAggregateInput_schema_1.CommunicationSumAggregateInputObjectSchema.optional() }).strict();

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

@@ -0,0 +1,14 @@
+import type { Prisma } from '../../generated/prisma';
+import * as z from 'zod';
+import { CommunicationOrderByWithRelationInputObjectSchema as CommunicationOrderByWithRelationInputObjectSchema } from './objects/CommunicationOrderByWithRelationInput.schema';
+import { CommunicationWhereInputObjectSchema as CommunicationWhereInputObjectSchema } from './objects/CommunicationWhereInput.schema';
+import { CommunicationWhereUniqueInputObjectSchema as CommunicationWhereUniqueInputObjectSchema } from './objects/CommunicationWhereUniqueInput.schema';
+import { CommunicationCountAggregateInputObjectSchema as CommunicationCountAggregateInputObjectSchema } from './objects/CommunicationCountAggregateInput.schema';
+import { CommunicationMinAggregateInputObjectSchema as CommunicationMinAggregateInputObjectSchema } from './objects/CommunicationMinAggregateInput.schema';
+import { CommunicationMaxAggregateInputObjectSchema as CommunicationMaxAggregateInputObjectSchema } from './objects/CommunicationMaxAggregateInput.schema';
+import { CommunicationAvgAggregateInputObjectSchema as CommunicationAvgAggregateInputObjectSchema } from './objects/CommunicationAvgAggregateInput.schema';
+import { CommunicationSumAggregateInputObjectSchema as CommunicationSumAggregateInputObjectSchema } from './objects/CommunicationSumAggregateInput.schema';
+
+export const CommunicationAggregateSchema: z.ZodType<Prisma.CommunicationAggregateArgs> = z.object({ orderBy: z.union([CommunicationOrderByWithRelationInputObjectSchema, CommunicationOrderByWithRelationInputObjectSchema.array()]).optional(), where: CommunicationWhereInputObjectSchema.optional(), cursor: CommunicationWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), _count: z.union([ z.literal(true), CommunicationCountAggregateInputObjectSchema ]).optional(), _min: CommunicationMinAggregateInputObjectSchema.optional(), _max: CommunicationMaxAggregateInputObjectSchema.optional(), _avg: CommunicationAvgAggregateInputObjectSchema.optional(), _sum: CommunicationSumAggregateInputObjectSchema.optional() }).strict() as unknown as z.ZodType<Prisma.CommunicationAggregateArgs>;
+
+export const CommunicationAggregateZodSchema = z.object({ orderBy: z.union([CommunicationOrderByWithRelationInputObjectSchema, CommunicationOrderByWithRelationInputObjectSchema.array()]).optional(), where: CommunicationWhereInputObjectSchema.optional(), cursor: CommunicationWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), _count: z.union([ z.literal(true), CommunicationCountAggregateInputObjectSchema ]).optional(), _min: CommunicationMinAggregateInputObjectSchema.optional(), _max: CommunicationMaxAggregateInputObjectSchema.optional(), _avg: CommunicationAvgAggregateInputObjectSchema.optional(), _sum: CommunicationSumAggregateInputObjectSchema.optional() }).strict();

packages/db/shared/schemas/aggregateDatabaseBackup.schema.d.ts

@@ -0,0 +1,38 @@
+import type { Prisma } from '../../generated/prisma';
+import * as z from 'zod';
+export declare const DatabaseBackupAggregateSchema: z.ZodType<Prisma.DatabaseBackupAggregateArgs>;
+export declare const DatabaseBackupAggregateZodSchema: z.ZodObject<{
+    orderBy: z.ZodOptional<z.ZodUnion<[z.ZodType<Prisma.DatabaseBackupOrderByWithRelationInput, z.ZodTypeDef, Prisma.DatabaseBackupOrderByWithRelationInput>, z.ZodArray<z.ZodType<Prisma.DatabaseBackupOrderByWithRelationInput, z.ZodTypeDef, Prisma.DatabaseBackupOrderByWithRelationInput>, "many">]>>;
+    where: z.ZodOptional<z.ZodType<Prisma.DatabaseBackupWhereInput, z.ZodTypeDef, Prisma.DatabaseBackupWhereInput>>;
+    cursor: z.ZodOptional<z.ZodType<Prisma.DatabaseBackupWhereUniqueInput, z.ZodTypeDef, Prisma.DatabaseBackupWhereUniqueInput>>;
+    take: z.ZodOptional<z.ZodNumber>;
+    skip: z.ZodOptional<z.ZodNumber>;
+    _count: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<true>, z.ZodType<Prisma.DatabaseBackupCountAggregateInputType, z.ZodTypeDef, Prisma.DatabaseBackupCountAggregateInputType>]>>;
+    _min: z.ZodOptional<z.ZodType<Prisma.DatabaseBackupMinAggregateInputType, z.ZodTypeDef, Prisma.DatabaseBackupMinAggregateInputType>>;
+    _max: z.ZodOptional<z.ZodType<Prisma.DatabaseBackupMaxAggregateInputType, z.ZodTypeDef, Prisma.DatabaseBackupMaxAggregateInputType>>;
+    _avg: z.ZodOptional<z.ZodType<Prisma.DatabaseBackupAvgAggregateInputType, z.ZodTypeDef, Prisma.DatabaseBackupAvgAggregateInputType>>;
+    _sum: z.ZodOptional<z.ZodType<Prisma.DatabaseBackupSumAggregateInputType, z.ZodTypeDef, Prisma.DatabaseBackupSumAggregateInputType>>;
+}, "strict", z.ZodTypeAny, {
+    where?: Prisma.DatabaseBackupWhereInput | undefined;
+    _count?: true | Prisma.DatabaseBackupCountAggregateInputType | undefined;
+    orderBy?: Prisma.DatabaseBackupOrderByWithRelationInput | Prisma.DatabaseBackupOrderByWithRelationInput[] | undefined;
+    cursor?: Prisma.DatabaseBackupWhereUniqueInput | undefined;
+    take?: number | undefined;
+    skip?: number | undefined;
+    _min?: Prisma.DatabaseBackupMinAggregateInputType | undefined;
+    _max?: Prisma.DatabaseBackupMaxAggregateInputType | undefined;
+    _avg?: Prisma.DatabaseBackupAvgAggregateInputType | undefined;
+    _sum?: Prisma.DatabaseBackupSumAggregateInputType | undefined;
+}, {
+    where?: Prisma.DatabaseBackupWhereInput | undefined;
+    _count?: true | Prisma.DatabaseBackupCountAggregateInputType | undefined;
+    orderBy?: Prisma.DatabaseBackupOrderByWithRelationInput | Prisma.DatabaseBackupOrderByWithRelationInput[] | undefined;
+    cursor?: Prisma.DatabaseBackupWhereUniqueInput | undefined;
+    take?: number | undefined;
+    skip?: number | undefined;
+    _min?: Prisma.DatabaseBackupMinAggregateInputType | undefined;
+    _max?: Prisma.DatabaseBackupMaxAggregateInputType | undefined;
+    _avg?: Prisma.DatabaseBackupAvgAggregateInputType | undefined;
+    _sum?: Prisma.DatabaseBackupSumAggregateInputType | undefined;
+}>;
+//# sourceMappingURL=aggregateDatabaseBackup.schema.d.ts.map

packages/db/shared/schemas/aggregateDatabaseBackup.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aggregateDatabaseBackup.schema.d.ts","sourceRoot":"","sources":["aggregateDatabaseBackup.schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAUzB,eAAO,MAAM,6BAA6B,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,2BAA2B,CAA6uB,CAAC;AAEt0B,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAgrB,CAAC"}

packages/db/shared/schemas/aggregateDatabaseBackup.schema.js

@@ -0,0 +1,47 @@
+"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.DatabaseBackupAggregateZodSchema = exports.DatabaseBackupAggregateSchema = void 0;
+const z = __importStar(require("zod"));
+const DatabaseBackupOrderByWithRelationInput_schema_1 = require("./objects/DatabaseBackupOrderByWithRelationInput.schema");
+const DatabaseBackupWhereInput_schema_1 = require("./objects/DatabaseBackupWhereInput.schema");
+const DatabaseBackupWhereUniqueInput_schema_1 = require("./objects/DatabaseBackupWhereUniqueInput.schema");
+const DatabaseBackupCountAggregateInput_schema_1 = require("./objects/DatabaseBackupCountAggregateInput.schema");
+const DatabaseBackupMinAggregateInput_schema_1 = require("./objects/DatabaseBackupMinAggregateInput.schema");
+const DatabaseBackupMaxAggregateInput_schema_1 = require("./objects/DatabaseBackupMaxAggregateInput.schema");
+const DatabaseBackupAvgAggregateInput_schema_1 = require("./objects/DatabaseBackupAvgAggregateInput.schema");
+const DatabaseBackupSumAggregateInput_schema_1 = require("./objects/DatabaseBackupSumAggregateInput.schema");
+exports.DatabaseBackupAggregateSchema = z.object({ orderBy: z.union([DatabaseBackupOrderByWithRelationInput_schema_1.DatabaseBackupOrderByWithRelationInputObjectSchema, DatabaseBackupOrderByWithRelationInput_schema_1.DatabaseBackupOrderByWithRelationInputObjectSchema.array()]).optional(), where: DatabaseBackupWhereInput_schema_1.DatabaseBackupWhereInputObjectSchema.optional(), cursor: DatabaseBackupWhereUniqueInput_schema_1.DatabaseBackupWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), _count: z.union([z.literal(true), DatabaseBackupCountAggregateInput_schema_1.DatabaseBackupCountAggregateInputObjectSchema]).optional(), _min: DatabaseBackupMinAggregateInput_schema_1.DatabaseBackupMinAggregateInputObjectSchema.optional(), _max: DatabaseBackupMaxAggregateInput_schema_1.DatabaseBackupMaxAggregateInputObjectSchema.optional(), _avg: DatabaseBackupAvgAggregateInput_schema_1.DatabaseBackupAvgAggregateInputObjectSchema.optional(), _sum: DatabaseBackupSumAggregateInput_schema_1.DatabaseBackupSumAggregateInputObjectSchema.optional() }).strict();
+exports.DatabaseBackupAggregateZodSchema = z.object({ orderBy: z.union([DatabaseBackupOrderByWithRelationInput_schema_1.DatabaseBackupOrderByWithRelationInputObjectSchema, DatabaseBackupOrderByWithRelationInput_schema_1.DatabaseBackupOrderByWithRelationInputObjectSchema.array()]).optional(), where: DatabaseBackupWhereInput_schema_1.DatabaseBackupWhereInputObjectSchema.optional(), cursor: DatabaseBackupWhereUniqueInput_schema_1.DatabaseBackupWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), _count: z.union([z.literal(true), DatabaseBackupCountAggregateInput_schema_1.DatabaseBackupCountAggregateInputObjectSchema]).optional(), _min: DatabaseBackupMinAggregateInput_schema_1.DatabaseBackupMinAggregateInputObjectSchema.optional(), _max: DatabaseBackupMaxAggregateInput_schema_1.DatabaseBackupMaxAggregateInputObjectSchema.optional(), _avg: DatabaseBackupAvgAggregateInput_schema_1.DatabaseBackupAvgAggregateInputObjectSchema.optional(), _sum: DatabaseBackupSumAggregateInput_schema_1.DatabaseBackupSumAggregateInputObjectSchema.optional() }).strict();

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

@@ -0,0 +1,14 @@
+import type { Prisma } from '../../generated/prisma';
+import * as z from 'zod';
+import { DatabaseBackupOrderByWithRelationInputObjectSchema as DatabaseBackupOrderByWithRelationInputObjectSchema } from './objects/DatabaseBackupOrderByWithRelationInput.schema';
+import { DatabaseBackupWhereInputObjectSchema as DatabaseBackupWhereInputObjectSchema } from './objects/DatabaseBackupWhereInput.schema';
+import { DatabaseBackupWhereUniqueInputObjectSchema as DatabaseBackupWhereUniqueInputObjectSchema } from './objects/DatabaseBackupWhereUniqueInput.schema';
+import { DatabaseBackupCountAggregateInputObjectSchema as DatabaseBackupCountAggregateInputObjectSchema } from './objects/DatabaseBackupCountAggregateInput.schema';
+import { DatabaseBackupMinAggregateInputObjectSchema as DatabaseBackupMinAggregateInputObjectSchema } from './objects/DatabaseBackupMinAggregateInput.schema';
+import { DatabaseBackupMaxAggregateInputObjectSchema as DatabaseBackupMaxAggregateInputObjectSchema } from './objects/DatabaseBackupMaxAggregateInput.schema';
+import { DatabaseBackupAvgAggregateInputObjectSchema as DatabaseBackupAvgAggregateInputObjectSchema } from './objects/DatabaseBackupAvgAggregateInput.schema';
+import { DatabaseBackupSumAggregateInputObjectSchema as DatabaseBackupSumAggregateInputObjectSchema } from './objects/DatabaseBackupSumAggregateInput.schema';
+
+export const DatabaseBackupAggregateSchema: z.ZodType<Prisma.DatabaseBackupAggregateArgs> = z.object({ orderBy: z.union([DatabaseBackupOrderByWithRelationInputObjectSchema, DatabaseBackupOrderByWithRelationInputObjectSchema.array()]).optional(), where: DatabaseBackupWhereInputObjectSchema.optional(), cursor: DatabaseBackupWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), _count: z.union([ z.literal(true), DatabaseBackupCountAggregateInputObjectSchema ]).optional(), _min: DatabaseBackupMinAggregateInputObjectSchema.optional(), _max: DatabaseBackupMaxAggregateInputObjectSchema.optional(), _avg: DatabaseBackupAvgAggregateInputObjectSchema.optional(), _sum: DatabaseBackupSumAggregateInputObjectSchema.optional() }).strict() as unknown as z.ZodType<Prisma.DatabaseBackupAggregateArgs>;
+
+export const DatabaseBackupAggregateZodSchema = z.object({ orderBy: z.union([DatabaseBackupOrderByWithRelationInputObjectSchema, DatabaseBackupOrderByWithRelationInputObjectSchema.array()]).optional(), where: DatabaseBackupWhereInputObjectSchema.optional(), cursor: DatabaseBackupWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), _count: z.union([ z.literal(true), DatabaseBackupCountAggregateInputObjectSchema ]).optional(), _min: DatabaseBackupMinAggregateInputObjectSchema.optional(), _max: DatabaseBackupMaxAggregateInputObjectSchema.optional(), _avg: DatabaseBackupAvgAggregateInputObjectSchema.optional(), _sum: DatabaseBackupSumAggregateInputObjectSchema.optional() }).strict();

packages/db/shared/schemas/aggregateInsuranceCredential.schema.d.ts

@@ -0,0 +1,38 @@
+import type { Prisma } from '../../generated/prisma';
+import * as z from 'zod';
+export declare const InsuranceCredentialAggregateSchema: z.ZodType<Prisma.InsuranceCredentialAggregateArgs>;
+export declare const InsuranceCredentialAggregateZodSchema: z.ZodObject<{
+    orderBy: z.ZodOptional<z.ZodUnion<[z.ZodType<Prisma.InsuranceCredentialOrderByWithRelationInput, z.ZodTypeDef, Prisma.InsuranceCredentialOrderByWithRelationInput>, z.ZodArray<z.ZodType<Prisma.InsuranceCredentialOrderByWithRelationInput, z.ZodTypeDef, Prisma.InsuranceCredentialOrderByWithRelationInput>, "many">]>>;
+    where: z.ZodOptional<z.ZodType<Prisma.InsuranceCredentialWhereInput, z.ZodTypeDef, Prisma.InsuranceCredentialWhereInput>>;
+    cursor: z.ZodOptional<z.ZodType<Prisma.InsuranceCredentialWhereUniqueInput, z.ZodTypeDef, Prisma.InsuranceCredentialWhereUniqueInput>>;
+    take: z.ZodOptional<z.ZodNumber>;
+    skip: z.ZodOptional<z.ZodNumber>;
+    _count: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<true>, z.ZodType<Prisma.InsuranceCredentialCountAggregateInputType, z.ZodTypeDef, Prisma.InsuranceCredentialCountAggregateInputType>]>>;
+    _min: z.ZodOptional<z.ZodType<Prisma.InsuranceCredentialMinAggregateInputType, z.ZodTypeDef, Prisma.InsuranceCredentialMinAggregateInputType>>;
+    _max: z.ZodOptional<z.ZodType<Prisma.InsuranceCredentialMaxAggregateInputType, z.ZodTypeDef, Prisma.InsuranceCredentialMaxAggregateInputType>>;
+    _avg: z.ZodOptional<z.ZodType<Prisma.InsuranceCredentialAvgAggregateInputType, z.ZodTypeDef, Prisma.InsuranceCredentialAvgAggregateInputType>>;
+    _sum: z.ZodOptional<z.ZodType<Prisma.InsuranceCredentialSumAggregateInputType, z.ZodTypeDef, Prisma.InsuranceCredentialSumAggregateInputType>>;
+}, "strict", z.ZodTypeAny, {
+    where?: Prisma.InsuranceCredentialWhereInput | undefined;
+    _count?: true | Prisma.InsuranceCredentialCountAggregateInputType | undefined;
+    orderBy?: Prisma.InsuranceCredentialOrderByWithRelationInput | Prisma.InsuranceCredentialOrderByWithRelationInput[] | undefined;
+    cursor?: Prisma.InsuranceCredentialWhereUniqueInput | undefined;
+    take?: number | undefined;
+    skip?: number | undefined;
+    _min?: Prisma.InsuranceCredentialMinAggregateInputType | undefined;
+    _max?: Prisma.InsuranceCredentialMaxAggregateInputType | undefined;
+    _avg?: Prisma.InsuranceCredentialAvgAggregateInputType | undefined;
+    _sum?: Prisma.InsuranceCredentialSumAggregateInputType | undefined;
+}, {
+    where?: Prisma.InsuranceCredentialWhereInput | undefined;
+    _count?: true | Prisma.InsuranceCredentialCountAggregateInputType | undefined;
+    orderBy?: Prisma.InsuranceCredentialOrderByWithRelationInput | Prisma.InsuranceCredentialOrderByWithRelationInput[] | undefined;
+    cursor?: Prisma.InsuranceCredentialWhereUniqueInput | undefined;
+    take?: number | undefined;
+    skip?: number | undefined;
+    _min?: Prisma.InsuranceCredentialMinAggregateInputType | undefined;
+    _max?: Prisma.InsuranceCredentialMaxAggregateInputType | undefined;
+    _avg?: Prisma.InsuranceCredentialAvgAggregateInputType | undefined;
+    _sum?: Prisma.InsuranceCredentialSumAggregateInputType | undefined;
+}>;
+//# sourceMappingURL=aggregateInsuranceCredential.schema.d.ts.map

packages/db/shared/schemas/aggregateInsuranceCredential.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aggregateInsuranceCredential.schema.d.ts","sourceRoot":"","sources":["aggregateInsuranceCredential.schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAUzB,eAAO,MAAM,kCAAkC,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,gCAAgC,CAA+xB,CAAC;AAEl4B,eAAO,MAAM,qCAAqC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAA6tB,CAAC"}

packages/db/shared/schemas/aggregateInsuranceCredential.schema.js

@@ -0,0 +1,47 @@
+"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.InsuranceCredentialAggregateZodSchema = exports.InsuranceCredentialAggregateSchema = void 0;
+const z = __importStar(require("zod"));
+const InsuranceCredentialOrderByWithRelationInput_schema_1 = require("./objects/InsuranceCredentialOrderByWithRelationInput.schema");
+const InsuranceCredentialWhereInput_schema_1 = require("./objects/InsuranceCredentialWhereInput.schema");
+const InsuranceCredentialWhereUniqueInput_schema_1 = require("./objects/InsuranceCredentialWhereUniqueInput.schema");
+const InsuranceCredentialCountAggregateInput_schema_1 = require("./objects/InsuranceCredentialCountAggregateInput.schema");
+const InsuranceCredentialMinAggregateInput_schema_1 = require("./objects/InsuranceCredentialMinAggregateInput.schema");
+const InsuranceCredentialMaxAggregateInput_schema_1 = require("./objects/InsuranceCredentialMaxAggregateInput.schema");
+const InsuranceCredentialAvgAggregateInput_schema_1 = require("./objects/InsuranceCredentialAvgAggregateInput.schema");
+const InsuranceCredentialSumAggregateInput_schema_1 = require("./objects/InsuranceCredentialSumAggregateInput.schema");
+exports.InsuranceCredentialAggregateSchema = z.object({ orderBy: z.union([InsuranceCredentialOrderByWithRelationInput_schema_1.InsuranceCredentialOrderByWithRelationInputObjectSchema, InsuranceCredentialOrderByWithRelationInput_schema_1.InsuranceCredentialOrderByWithRelationInputObjectSchema.array()]).optional(), where: InsuranceCredentialWhereInput_schema_1.InsuranceCredentialWhereInputObjectSchema.optional(), cursor: InsuranceCredentialWhereUniqueInput_schema_1.InsuranceCredentialWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), _count: z.union([z.literal(true), InsuranceCredentialCountAggregateInput_schema_1.InsuranceCredentialCountAggregateInputObjectSchema]).optional(), _min: InsuranceCredentialMinAggregateInput_schema_1.InsuranceCredentialMinAggregateInputObjectSchema.optional(), _max: InsuranceCredentialMaxAggregateInput_schema_1.InsuranceCredentialMaxAggregateInputObjectSchema.optional(), _avg: InsuranceCredentialAvgAggregateInput_schema_1.InsuranceCredentialAvgAggregateInputObjectSchema.optional(), _sum: InsuranceCredentialSumAggregateInput_schema_1.InsuranceCredentialSumAggregateInputObjectSchema.optional() }).strict();
+exports.InsuranceCredentialAggregateZodSchema = z.object({ orderBy: z.union([InsuranceCredentialOrderByWithRelationInput_schema_1.InsuranceCredentialOrderByWithRelationInputObjectSchema, InsuranceCredentialOrderByWithRelationInput_schema_1.InsuranceCredentialOrderByWithRelationInputObjectSchema.array()]).optional(), where: InsuranceCredentialWhereInput_schema_1.InsuranceCredentialWhereInputObjectSchema.optional(), cursor: InsuranceCredentialWhereUniqueInput_schema_1.InsuranceCredentialWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), _count: z.union([z.literal(true), InsuranceCredentialCountAggregateInput_schema_1.InsuranceCredentialCountAggregateInputObjectSchema]).optional(), _min: InsuranceCredentialMinAggregateInput_schema_1.InsuranceCredentialMinAggregateInputObjectSchema.optional(), _max: InsuranceCredentialMaxAggregateInput_schema_1.InsuranceCredentialMaxAggregateInputObjectSchema.optional(), _avg: InsuranceCredentialAvgAggregateInput_schema_1.InsuranceCredentialAvgAggregateInputObjectSchema.optional(), _sum: InsuranceCredentialSumAggregateInput_schema_1.InsuranceCredentialSumAggregateInputObjectSchema.optional() }).strict();

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

@@ -0,0 +1,14 @@
+import type { Prisma } from '../../generated/prisma';
+import * as z from 'zod';
+import { InsuranceCredentialOrderByWithRelationInputObjectSchema as InsuranceCredentialOrderByWithRelationInputObjectSchema } from './objects/InsuranceCredentialOrderByWithRelationInput.schema';
+import { InsuranceCredentialWhereInputObjectSchema as InsuranceCredentialWhereInputObjectSchema } from './objects/InsuranceCredentialWhereInput.schema';
+import { InsuranceCredentialWhereUniqueInputObjectSchema as InsuranceCredentialWhereUniqueInputObjectSchema } from './objects/InsuranceCredentialWhereUniqueInput.schema';
+import { InsuranceCredentialCountAggregateInputObjectSchema as InsuranceCredentialCountAggregateInputObjectSchema } from './objects/InsuranceCredentialCountAggregateInput.schema';
+import { InsuranceCredentialMinAggregateInputObjectSchema as InsuranceCredentialMinAggregateInputObjectSchema } from './objects/InsuranceCredentialMinAggregateInput.schema';
+import { InsuranceCredentialMaxAggregateInputObjectSchema as InsuranceCredentialMaxAggregateInputObjectSchema } from './objects/InsuranceCredentialMaxAggregateInput.schema';
+import { InsuranceCredentialAvgAggregateInputObjectSchema as InsuranceCredentialAvgAggregateInputObjectSchema } from './objects/InsuranceCredentialAvgAggregateInput.schema';
+import { InsuranceCredentialSumAggregateInputObjectSchema as InsuranceCredentialSumAggregateInputObjectSchema } from './objects/InsuranceCredentialSumAggregateInput.schema';
+
+export const InsuranceCredentialAggregateSchema: z.ZodType<Prisma.InsuranceCredentialAggregateArgs> = z.object({ orderBy: z.union([InsuranceCredentialOrderByWithRelationInputObjectSchema, InsuranceCredentialOrderByWithRelationInputObjectSchema.array()]).optional(), where: InsuranceCredentialWhereInputObjectSchema.optional(), cursor: InsuranceCredentialWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), _count: z.union([ z.literal(true), InsuranceCredentialCountAggregateInputObjectSchema ]).optional(), _min: InsuranceCredentialMinAggregateInputObjectSchema.optional(), _max: InsuranceCredentialMaxAggregateInputObjectSchema.optional(), _avg: InsuranceCredentialAvgAggregateInputObjectSchema.optional(), _sum: InsuranceCredentialSumAggregateInputObjectSchema.optional() }).strict() as unknown as z.ZodType<Prisma.InsuranceCredentialAggregateArgs>;
+
+export const InsuranceCredentialAggregateZodSchema = z.object({ orderBy: z.union([InsuranceCredentialOrderByWithRelationInputObjectSchema, InsuranceCredentialOrderByWithRelationInputObjectSchema.array()]).optional(), where: InsuranceCredentialWhereInputObjectSchema.optional(), cursor: InsuranceCredentialWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), _count: z.union([ z.literal(true), InsuranceCredentialCountAggregateInputObjectSchema ]).optional(), _min: InsuranceCredentialMinAggregateInputObjectSchema.optional(), _max: InsuranceCredentialMaxAggregateInputObjectSchema.optional(), _avg: InsuranceCredentialAvgAggregateInputObjectSchema.optional(), _sum: InsuranceCredentialSumAggregateInputObjectSchema.optional() }).strict();

packages/db/shared/schemas/aggregateNotification.schema.d.ts

@@ -0,0 +1,38 @@
+import type { Prisma } from '../../generated/prisma';
+import * as z from 'zod';
+export declare const NotificationAggregateSchema: z.ZodType<Prisma.NotificationAggregateArgs>;
+export declare const NotificationAggregateZodSchema: z.ZodObject<{
+    orderBy: z.ZodOptional<z.ZodUnion<[z.ZodType<Prisma.NotificationOrderByWithRelationInput, z.ZodTypeDef, Prisma.NotificationOrderByWithRelationInput>, z.ZodArray<z.ZodType<Prisma.NotificationOrderByWithRelationInput, z.ZodTypeDef, Prisma.NotificationOrderByWithRelationInput>, "many">]>>;
+    where: z.ZodOptional<z.ZodType<Prisma.NotificationWhereInput, z.ZodTypeDef, Prisma.NotificationWhereInput>>;
+    cursor: z.ZodOptional<z.ZodType<Prisma.NotificationWhereUniqueInput, z.ZodTypeDef, Prisma.NotificationWhereUniqueInput>>;
+    take: z.ZodOptional<z.ZodNumber>;
+    skip: z.ZodOptional<z.ZodNumber>;
+    _count: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<true>, z.ZodType<Prisma.NotificationCountAggregateInputType, z.ZodTypeDef, Prisma.NotificationCountAggregateInputType>]>>;
+    _min: z.ZodOptional<z.ZodType<Prisma.NotificationMinAggregateInputType, z.ZodTypeDef, Prisma.NotificationMinAggregateInputType>>;
+    _max: z.ZodOptional<z.ZodType<Prisma.NotificationMaxAggregateInputType, z.ZodTypeDef, Prisma.NotificationMaxAggregateInputType>>;
+    _avg: z.ZodOptional<z.ZodType<Prisma.NotificationAvgAggregateInputType, z.ZodTypeDef, Prisma.NotificationAvgAggregateInputType>>;
+    _sum: z.ZodOptional<z.ZodType<Prisma.NotificationSumAggregateInputType, z.ZodTypeDef, Prisma.NotificationSumAggregateInputType>>;
+}, "strict", z.ZodTypeAny, {
+    where?: Prisma.NotificationWhereInput | undefined;
+    _count?: true | Prisma.NotificationCountAggregateInputType | undefined;
+    orderBy?: Prisma.NotificationOrderByWithRelationInput | Prisma.NotificationOrderByWithRelationInput[] | undefined;
+    cursor?: Prisma.NotificationWhereUniqueInput | undefined;
+    take?: number | undefined;
+    skip?: number | undefined;
+    _min?: Prisma.NotificationMinAggregateInputType | undefined;
+    _max?: Prisma.NotificationMaxAggregateInputType | undefined;
+    _avg?: Prisma.NotificationAvgAggregateInputType | undefined;
+    _sum?: Prisma.NotificationSumAggregateInputType | undefined;
+}, {
+    where?: Prisma.NotificationWhereInput | undefined;
+    _count?: true | Prisma.NotificationCountAggregateInputType | undefined;
+    orderBy?: Prisma.NotificationOrderByWithRelationInput | Prisma.NotificationOrderByWithRelationInput[] | undefined;
+    cursor?: Prisma.NotificationWhereUniqueInput | undefined;
+    take?: number | undefined;
+    skip?: number | undefined;
+    _min?: Prisma.NotificationMinAggregateInputType | undefined;
+    _max?: Prisma.NotificationMaxAggregateInputType | undefined;
+    _avg?: Prisma.NotificationAvgAggregateInputType | undefined;
+    _sum?: Prisma.NotificationSumAggregateInputType | undefined;
+}>;
+//# sourceMappingURL=aggregateNotification.schema.d.ts.map

packages/db/shared/schemas/aggregateNotification.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aggregateNotification.schema.d.ts","sourceRoot":"","sources":["aggregateNotification.schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAUzB,eAAO,MAAM,2BAA2B,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,yBAAyB,CAAytB,CAAC;AAE9yB,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAA8pB,CAAC"}

packages/db/shared/schemas/aggregateNotification.schema.js

@@ -0,0 +1,47 @@
+"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.NotificationAggregateZodSchema = exports.NotificationAggregateSchema = void 0;
+const z = __importStar(require("zod"));
+const NotificationOrderByWithRelationInput_schema_1 = require("./objects/NotificationOrderByWithRelationInput.schema");
+const NotificationWhereInput_schema_1 = require("./objects/NotificationWhereInput.schema");
+const NotificationWhereUniqueInput_schema_1 = require("./objects/NotificationWhereUniqueInput.schema");
+const NotificationCountAggregateInput_schema_1 = require("./objects/NotificationCountAggregateInput.schema");
+const NotificationMinAggregateInput_schema_1 = require("./objects/NotificationMinAggregateInput.schema");
+const NotificationMaxAggregateInput_schema_1 = require("./objects/NotificationMaxAggregateInput.schema");
+const NotificationAvgAggregateInput_schema_1 = require("./objects/NotificationAvgAggregateInput.schema");
+const NotificationSumAggregateInput_schema_1 = require("./objects/NotificationSumAggregateInput.schema");
+exports.NotificationAggregateSchema = z.object({ orderBy: z.union([NotificationOrderByWithRelationInput_schema_1.NotificationOrderByWithRelationInputObjectSchema, NotificationOrderByWithRelationInput_schema_1.NotificationOrderByWithRelationInputObjectSchema.array()]).optional(), where: NotificationWhereInput_schema_1.NotificationWhereInputObjectSchema.optional(), cursor: NotificationWhereUniqueInput_schema_1.NotificationWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), _count: z.union([z.literal(true), NotificationCountAggregateInput_schema_1.NotificationCountAggregateInputObjectSchema]).optional(), _min: NotificationMinAggregateInput_schema_1.NotificationMinAggregateInputObjectSchema.optional(), _max: NotificationMaxAggregateInput_schema_1.NotificationMaxAggregateInputObjectSchema.optional(), _avg: NotificationAvgAggregateInput_schema_1.NotificationAvgAggregateInputObjectSchema.optional(), _sum: NotificationSumAggregateInput_schema_1.NotificationSumAggregateInputObjectSchema.optional() }).strict();
+exports.NotificationAggregateZodSchema = z.object({ orderBy: z.union([NotificationOrderByWithRelationInput_schema_1.NotificationOrderByWithRelationInputObjectSchema, NotificationOrderByWithRelationInput_schema_1.NotificationOrderByWithRelationInputObjectSchema.array()]).optional(), where: NotificationWhereInput_schema_1.NotificationWhereInputObjectSchema.optional(), cursor: NotificationWhereUniqueInput_schema_1.NotificationWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), _count: z.union([z.literal(true), NotificationCountAggregateInput_schema_1.NotificationCountAggregateInputObjectSchema]).optional(), _min: NotificationMinAggregateInput_schema_1.NotificationMinAggregateInputObjectSchema.optional(), _max: NotificationMaxAggregateInput_schema_1.NotificationMaxAggregateInputObjectSchema.optional(), _avg: NotificationAvgAggregateInput_schema_1.NotificationAvgAggregateInputObjectSchema.optional(), _sum: NotificationSumAggregateInput_schema_1.NotificationSumAggregateInputObjectSchema.optional() }).strict();

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

@@ -0,0 +1,14 @@
+import type { Prisma } from '../../generated/prisma';
+import * as z from 'zod';
+import { NotificationOrderByWithRelationInputObjectSchema as NotificationOrderByWithRelationInputObjectSchema } from './objects/NotificationOrderByWithRelationInput.schema';
+import { NotificationWhereInputObjectSchema as NotificationWhereInputObjectSchema } from './objects/NotificationWhereInput.schema';
+import { NotificationWhereUniqueInputObjectSchema as NotificationWhereUniqueInputObjectSchema } from './objects/NotificationWhereUniqueInput.schema';
+import { NotificationCountAggregateInputObjectSchema as NotificationCountAggregateInputObjectSchema } from './objects/NotificationCountAggregateInput.schema';
+import { NotificationMinAggregateInputObjectSchema as NotificationMinAggregateInputObjectSchema } from './objects/NotificationMinAggregateInput.schema';
+import { NotificationMaxAggregateInputObjectSchema as NotificationMaxAggregateInputObjectSchema } from './objects/NotificationMaxAggregateInput.schema';
+import { NotificationAvgAggregateInputObjectSchema as NotificationAvgAggregateInputObjectSchema } from './objects/NotificationAvgAggregateInput.schema';
+import { NotificationSumAggregateInputObjectSchema as NotificationSumAggregateInputObjectSchema } from './objects/NotificationSumAggregateInput.schema';
+
+export const NotificationAggregateSchema: z.ZodType<Prisma.NotificationAggregateArgs> = z.object({ orderBy: z.union([NotificationOrderByWithRelationInputObjectSchema, NotificationOrderByWithRelationInputObjectSchema.array()]).optional(), where: NotificationWhereInputObjectSchema.optional(), cursor: NotificationWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), _count: z.union([ z.literal(true), NotificationCountAggregateInputObjectSchema ]).optional(), _min: NotificationMinAggregateInputObjectSchema.optional(), _max: NotificationMaxAggregateInputObjectSchema.optional(), _avg: NotificationAvgAggregateInputObjectSchema.optional(), _sum: NotificationSumAggregateInputObjectSchema.optional() }).strict() as unknown as z.ZodType<Prisma.NotificationAggregateArgs>;
+
+export const NotificationAggregateZodSchema = z.object({ orderBy: z.union([NotificationOrderByWithRelationInputObjectSchema, NotificationOrderByWithRelationInputObjectSchema.array()]).optional(), where: NotificationWhereInputObjectSchema.optional(), cursor: NotificationWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), _count: z.union([ z.literal(true), NotificationCountAggregateInputObjectSchema ]).optional(), _min: NotificationMinAggregateInputObjectSchema.optional(), _max: NotificationMaxAggregateInputObjectSchema.optional(), _avg: NotificationAvgAggregateInputObjectSchema.optional(), _sum: NotificationSumAggregateInputObjectSchema.optional() }).strict();

packages/db/shared/schemas/aggregateNpiProvider.schema.d.ts

@@ -0,0 +1,38 @@
+import type { Prisma } from '../../generated/prisma';
+import * as z from 'zod';
+export declare const NpiProviderAggregateSchema: z.ZodType<Prisma.NpiProviderAggregateArgs>;
+export declare const NpiProviderAggregateZodSchema: z.ZodObject<{
+    orderBy: z.ZodOptional<z.ZodUnion<[z.ZodType<Prisma.NpiProviderOrderByWithRelationInput, z.ZodTypeDef, Prisma.NpiProviderOrderByWithRelationInput>, z.ZodArray<z.ZodType<Prisma.NpiProviderOrderByWithRelationInput, z.ZodTypeDef, Prisma.NpiProviderOrderByWithRelationInput>, "many">]>>;
+    where: z.ZodOptional<z.ZodType<Prisma.NpiProviderWhereInput, z.ZodTypeDef, Prisma.NpiProviderWhereInput>>;
+    cursor: z.ZodOptional<z.ZodType<Prisma.NpiProviderWhereUniqueInput, z.ZodTypeDef, Prisma.NpiProviderWhereUniqueInput>>;
+    take: z.ZodOptional<z.ZodNumber>;
+    skip: z.ZodOptional<z.ZodNumber>;
+    _count: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<true>, z.ZodType<Prisma.NpiProviderCountAggregateInputType, z.ZodTypeDef, Prisma.NpiProviderCountAggregateInputType>]>>;
+    _min: z.ZodOptional<z.ZodType<Prisma.NpiProviderMinAggregateInputType, z.ZodTypeDef, Prisma.NpiProviderMinAggregateInputType>>;
+    _max: z.ZodOptional<z.ZodType<Prisma.NpiProviderMaxAggregateInputType, z.ZodTypeDef, Prisma.NpiProviderMaxAggregateInputType>>;
+    _avg: z.ZodOptional<z.ZodType<Prisma.NpiProviderAvgAggregateInputType, z.ZodTypeDef, Prisma.NpiProviderAvgAggregateInputType>>;
+    _sum: z.ZodOptional<z.ZodType<Prisma.NpiProviderSumAggregateInputType, z.ZodTypeDef, Prisma.NpiProviderSumAggregateInputType>>;
+}, "strict", z.ZodTypeAny, {
+    where?: Prisma.NpiProviderWhereInput | undefined;
+    _count?: true | Prisma.NpiProviderCountAggregateInputType | undefined;
+    orderBy?: Prisma.NpiProviderOrderByWithRelationInput | Prisma.NpiProviderOrderByWithRelationInput[] | undefined;
+    cursor?: Prisma.NpiProviderWhereUniqueInput | undefined;
+    take?: number | undefined;
+    skip?: number | undefined;
+    _min?: Prisma.NpiProviderMinAggregateInputType | undefined;
+    _max?: Prisma.NpiProviderMaxAggregateInputType | undefined;
+    _avg?: Prisma.NpiProviderAvgAggregateInputType | undefined;
+    _sum?: Prisma.NpiProviderSumAggregateInputType | undefined;
+}, {
+    where?: Prisma.NpiProviderWhereInput | undefined;
+    _count?: true | Prisma.NpiProviderCountAggregateInputType | undefined;
+    orderBy?: Prisma.NpiProviderOrderByWithRelationInput | Prisma.NpiProviderOrderByWithRelationInput[] | undefined;
+    cursor?: Prisma.NpiProviderWhereUniqueInput | undefined;
+    take?: number | undefined;
+    skip?: number | undefined;
+    _min?: Prisma.NpiProviderMinAggregateInputType | undefined;
+    _max?: Prisma.NpiProviderMaxAggregateInputType | undefined;
+    _avg?: Prisma.NpiProviderAvgAggregateInputType | undefined;
+    _sum?: Prisma.NpiProviderSumAggregateInputType | undefined;
+}>;
+//# sourceMappingURL=aggregateNpiProvider.schema.d.ts.map

packages/db/shared/schemas/aggregateNpiProvider.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aggregateNpiProvider.schema.d.ts","sourceRoot":"","sources":["aggregateNpiProvider.schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAUzB,eAAO,MAAM,0BAA0B,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,wBAAwB,CAA+sB,CAAC;AAElyB,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAqpB,CAAC"}

packages/db/shared/schemas/aggregateNpiProvider.schema.js

@@ -0,0 +1,47 @@
+"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.NpiProviderAggregateZodSchema = exports.NpiProviderAggregateSchema = void 0;
+const z = __importStar(require("zod"));
+const NpiProviderOrderByWithRelationInput_schema_1 = require("./objects/NpiProviderOrderByWithRelationInput.schema");
+const NpiProviderWhereInput_schema_1 = require("./objects/NpiProviderWhereInput.schema");
+const NpiProviderWhereUniqueInput_schema_1 = require("./objects/NpiProviderWhereUniqueInput.schema");
+const NpiProviderCountAggregateInput_schema_1 = require("./objects/NpiProviderCountAggregateInput.schema");
+const NpiProviderMinAggregateInput_schema_1 = require("./objects/NpiProviderMinAggregateInput.schema");
+const NpiProviderMaxAggregateInput_schema_1 = require("./objects/NpiProviderMaxAggregateInput.schema");
+const NpiProviderAvgAggregateInput_schema_1 = require("./objects/NpiProviderAvgAggregateInput.schema");
+const NpiProviderSumAggregateInput_schema_1 = require("./objects/NpiProviderSumAggregateInput.schema");
+exports.NpiProviderAggregateSchema = z.object({ orderBy: z.union([NpiProviderOrderByWithRelationInput_schema_1.NpiProviderOrderByWithRelationInputObjectSchema, NpiProviderOrderByWithRelationInput_schema_1.NpiProviderOrderByWithRelationInputObjectSchema.array()]).optional(), where: NpiProviderWhereInput_schema_1.NpiProviderWhereInputObjectSchema.optional(), cursor: NpiProviderWhereUniqueInput_schema_1.NpiProviderWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), _count: z.union([z.literal(true), NpiProviderCountAggregateInput_schema_1.NpiProviderCountAggregateInputObjectSchema]).optional(), _min: NpiProviderMinAggregateInput_schema_1.NpiProviderMinAggregateInputObjectSchema.optional(), _max: NpiProviderMaxAggregateInput_schema_1.NpiProviderMaxAggregateInputObjectSchema.optional(), _avg: NpiProviderAvgAggregateInput_schema_1.NpiProviderAvgAggregateInputObjectSchema.optional(), _sum: NpiProviderSumAggregateInput_schema_1.NpiProviderSumAggregateInputObjectSchema.optional() }).strict();
+exports.NpiProviderAggregateZodSchema = z.object({ orderBy: z.union([NpiProviderOrderByWithRelationInput_schema_1.NpiProviderOrderByWithRelationInputObjectSchema, NpiProviderOrderByWithRelationInput_schema_1.NpiProviderOrderByWithRelationInputObjectSchema.array()]).optional(), where: NpiProviderWhereInput_schema_1.NpiProviderWhereInputObjectSchema.optional(), cursor: NpiProviderWhereUniqueInput_schema_1.NpiProviderWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), _count: z.union([z.literal(true), NpiProviderCountAggregateInput_schema_1.NpiProviderCountAggregateInputObjectSchema]).optional(), _min: NpiProviderMinAggregateInput_schema_1.NpiProviderMinAggregateInputObjectSchema.optional(), _max: NpiProviderMaxAggregateInput_schema_1.NpiProviderMaxAggregateInputObjectSchema.optional(), _avg: NpiProviderAvgAggregateInput_schema_1.NpiProviderAvgAggregateInputObjectSchema.optional(), _sum: NpiProviderSumAggregateInput_schema_1.NpiProviderSumAggregateInputObjectSchema.optional() }).strict();

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

@@ -0,0 +1,14 @@
+import type { Prisma } from '../../generated/prisma';
+import * as z from 'zod';
+import { NpiProviderOrderByWithRelationInputObjectSchema as NpiProviderOrderByWithRelationInputObjectSchema } from './objects/NpiProviderOrderByWithRelationInput.schema';
+import { NpiProviderWhereInputObjectSchema as NpiProviderWhereInputObjectSchema } from './objects/NpiProviderWhereInput.schema';
+import { NpiProviderWhereUniqueInputObjectSchema as NpiProviderWhereUniqueInputObjectSchema } from './objects/NpiProviderWhereUniqueInput.schema';
+import { NpiProviderCountAggregateInputObjectSchema as NpiProviderCountAggregateInputObjectSchema } from './objects/NpiProviderCountAggregateInput.schema';
+import { NpiProviderMinAggregateInputObjectSchema as NpiProviderMinAggregateInputObjectSchema } from './objects/NpiProviderMinAggregateInput.schema';
+import { NpiProviderMaxAggregateInputObjectSchema as NpiProviderMaxAggregateInputObjectSchema } from './objects/NpiProviderMaxAggregateInput.schema';
+import { NpiProviderAvgAggregateInputObjectSchema as NpiProviderAvgAggregateInputObjectSchema } from './objects/NpiProviderAvgAggregateInput.schema';
+import { NpiProviderSumAggregateInputObjectSchema as NpiProviderSumAggregateInputObjectSchema } from './objects/NpiProviderSumAggregateInput.schema';
+
+export const NpiProviderAggregateSchema: z.ZodType<Prisma.NpiProviderAggregateArgs> = z.object({ orderBy: z.union([NpiProviderOrderByWithRelationInputObjectSchema, NpiProviderOrderByWithRelationInputObjectSchema.array()]).optional(), where: NpiProviderWhereInputObjectSchema.optional(), cursor: NpiProviderWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), _count: z.union([ z.literal(true), NpiProviderCountAggregateInputObjectSchema ]).optional(), _min: NpiProviderMinAggregateInputObjectSchema.optional(), _max: NpiProviderMaxAggregateInputObjectSchema.optional(), _avg: NpiProviderAvgAggregateInputObjectSchema.optional(), _sum: NpiProviderSumAggregateInputObjectSchema.optional() }).strict() as unknown as z.ZodType<Prisma.NpiProviderAggregateArgs>;
+
+export const NpiProviderAggregateZodSchema = z.object({ orderBy: z.union([NpiProviderOrderByWithRelationInputObjectSchema, NpiProviderOrderByWithRelationInputObjectSchema.array()]).optional(), where: NpiProviderWhereInputObjectSchema.optional(), cursor: NpiProviderWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), _count: z.union([ z.literal(true), NpiProviderCountAggregateInputObjectSchema ]).optional(), _min: NpiProviderMinAggregateInputObjectSchema.optional(), _max: NpiProviderMaxAggregateInputObjectSchema.optional(), _avg: NpiProviderAvgAggregateInputObjectSchema.optional(), _sum: NpiProviderSumAggregateInputObjectSchema.optional() }).strict();

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

@@ -0,0 +1,38 @@
+import type { Prisma } from '../../generated/prisma';
+import * as z from 'zod';
+export declare const PatientAggregateSchema: z.ZodType<Prisma.PatientAggregateArgs>;
+export declare const PatientAggregateZodSchema: z.ZodObject<{
+    orderBy: z.ZodOptional<z.ZodUnion<[z.ZodType<Prisma.PatientOrderByWithRelationInput, z.ZodTypeDef, Prisma.PatientOrderByWithRelationInput>, z.ZodArray<z.ZodType<Prisma.PatientOrderByWithRelationInput, z.ZodTypeDef, Prisma.PatientOrderByWithRelationInput>, "many">]>>;
+    where: z.ZodOptional<z.ZodType<Prisma.PatientWhereInput, z.ZodTypeDef, Prisma.PatientWhereInput>>;
+    cursor: z.ZodOptional<z.ZodType<Prisma.PatientWhereUniqueInput, z.ZodTypeDef, Prisma.PatientWhereUniqueInput>>;
+    take: z.ZodOptional<z.ZodNumber>;
+    skip: z.ZodOptional<z.ZodNumber>;
+    _count: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<true>, z.ZodType<Prisma.PatientCountAggregateInputType, z.ZodTypeDef, Prisma.PatientCountAggregateInputType>]>>;
+    _min: z.ZodOptional<z.ZodType<Prisma.PatientMinAggregateInputType, z.ZodTypeDef, Prisma.PatientMinAggregateInputType>>;
+    _max: z.ZodOptional<z.ZodType<Prisma.PatientMaxAggregateInputType, z.ZodTypeDef, Prisma.PatientMaxAggregateInputType>>;
+    _avg: z.ZodOptional<z.ZodType<Prisma.PatientAvgAggregateInputType, z.ZodTypeDef, Prisma.PatientAvgAggregateInputType>>;
+    _sum: z.ZodOptional<z.ZodType<Prisma.PatientSumAggregateInputType, z.ZodTypeDef, Prisma.PatientSumAggregateInputType>>;
+}, "strict", z.ZodTypeAny, {
+    where?: Prisma.PatientWhereInput | undefined;
+    _count?: true | Prisma.PatientCountAggregateInputType | undefined;
+    orderBy?: Prisma.PatientOrderByWithRelationInput | Prisma.PatientOrderByWithRelationInput[] | undefined;
+    cursor?: Prisma.PatientWhereUniqueInput | undefined;
+    take?: number | undefined;
+    skip?: number | undefined;
+    _min?: Prisma.PatientMinAggregateInputType | undefined;
+    _max?: Prisma.PatientMaxAggregateInputType | undefined;
+    _avg?: Prisma.PatientAvgAggregateInputType | undefined;
+    _sum?: Prisma.PatientSumAggregateInputType | undefined;
+}, {
+    where?: Prisma.PatientWhereInput | undefined;
+    _count?: true | Prisma.PatientCountAggregateInputType | undefined;
+    orderBy?: Prisma.PatientOrderByWithRelationInput | Prisma.PatientOrderByWithRelationInput[] | undefined;
+    cursor?: Prisma.PatientWhereUniqueInput | undefined;
+    take?: number | undefined;
+    skip?: number | undefined;
+    _min?: Prisma.PatientMinAggregateInputType | undefined;
+    _max?: Prisma.PatientMaxAggregateInputType | undefined;
+    _avg?: Prisma.PatientAvgAggregateInputType | undefined;
+    _sum?: Prisma.PatientSumAggregateInputType | undefined;
+}>;
+//# sourceMappingURL=aggregatePatient.schema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"aggregatePatient.schema.d.ts","sourceRoot":"","sources":["aggregatePatient.schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAUzB,eAAO,MAAM,sBAAsB,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,oBAAoB,CAAuqB,CAAC;AAElvB,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAinB,CAAC"}

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

@@ -0,0 +1,47 @@
+"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.PatientAggregateZodSchema = exports.PatientAggregateSchema = void 0;
+const z = __importStar(require("zod"));
+const PatientOrderByWithRelationInput_schema_1 = require("./objects/PatientOrderByWithRelationInput.schema");
+const PatientWhereInput_schema_1 = require("./objects/PatientWhereInput.schema");
+const PatientWhereUniqueInput_schema_1 = require("./objects/PatientWhereUniqueInput.schema");
+const PatientCountAggregateInput_schema_1 = require("./objects/PatientCountAggregateInput.schema");
+const PatientMinAggregateInput_schema_1 = require("./objects/PatientMinAggregateInput.schema");
+const PatientMaxAggregateInput_schema_1 = require("./objects/PatientMaxAggregateInput.schema");
+const PatientAvgAggregateInput_schema_1 = require("./objects/PatientAvgAggregateInput.schema");
+const PatientSumAggregateInput_schema_1 = require("./objects/PatientSumAggregateInput.schema");
+exports.PatientAggregateSchema = z.object({ orderBy: z.union([PatientOrderByWithRelationInput_schema_1.PatientOrderByWithRelationInputObjectSchema, PatientOrderByWithRelationInput_schema_1.PatientOrderByWithRelationInputObjectSchema.array()]).optional(), where: PatientWhereInput_schema_1.PatientWhereInputObjectSchema.optional(), cursor: PatientWhereUniqueInput_schema_1.PatientWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), _count: z.union([z.literal(true), PatientCountAggregateInput_schema_1.PatientCountAggregateInputObjectSchema]).optional(), _min: PatientMinAggregateInput_schema_1.PatientMinAggregateInputObjectSchema.optional(), _max: PatientMaxAggregateInput_schema_1.PatientMaxAggregateInputObjectSchema.optional(), _avg: PatientAvgAggregateInput_schema_1.PatientAvgAggregateInputObjectSchema.optional(), _sum: PatientSumAggregateInput_schema_1.PatientSumAggregateInputObjectSchema.optional() }).strict();
+exports.PatientAggregateZodSchema = z.object({ orderBy: z.union([PatientOrderByWithRelationInput_schema_1.PatientOrderByWithRelationInputObjectSchema, PatientOrderByWithRelationInput_schema_1.PatientOrderByWithRelationInputObjectSchema.array()]).optional(), where: PatientWhereInput_schema_1.PatientWhereInputObjectSchema.optional(), cursor: PatientWhereUniqueInput_schema_1.PatientWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), _count: z.union([z.literal(true), PatientCountAggregateInput_schema_1.PatientCountAggregateInputObjectSchema]).optional(), _min: PatientMinAggregateInput_schema_1.PatientMinAggregateInputObjectSchema.optional(), _max: PatientMaxAggregateInput_schema_1.PatientMaxAggregateInputObjectSchema.optional(), _avg: PatientAvgAggregateInput_schema_1.PatientAvgAggregateInputObjectSchema.optional(), _sum: PatientSumAggregateInput_schema_1.PatientSumAggregateInputObjectSchema.optional() }).strict();

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

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

packages/db/shared/schemas/aggregatePatientDocument.schema.d.ts

@@ -0,0 +1,38 @@
+import type { Prisma } from '../../generated/prisma';
+import * as z from 'zod';
+export declare const PatientDocumentAggregateSchema: z.ZodType<Prisma.PatientDocumentAggregateArgs>;
+export declare const PatientDocumentAggregateZodSchema: z.ZodObject<{
+    orderBy: z.ZodOptional<z.ZodUnion<[z.ZodType<Prisma.PatientDocumentOrderByWithRelationInput, z.ZodTypeDef, Prisma.PatientDocumentOrderByWithRelationInput>, z.ZodArray<z.ZodType<Prisma.PatientDocumentOrderByWithRelationInput, z.ZodTypeDef, Prisma.PatientDocumentOrderByWithRelationInput>, "many">]>>;
+    where: z.ZodOptional<z.ZodType<Prisma.PatientDocumentWhereInput, z.ZodTypeDef, Prisma.PatientDocumentWhereInput>>;
+    cursor: z.ZodOptional<z.ZodType<Prisma.PatientDocumentWhereUniqueInput, z.ZodTypeDef, Prisma.PatientDocumentWhereUniqueInput>>;
+    take: z.ZodOptional<z.ZodNumber>;
+    skip: z.ZodOptional<z.ZodNumber>;
+    _count: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<true>, z.ZodType<Prisma.PatientDocumentCountAggregateInputType, z.ZodTypeDef, Prisma.PatientDocumentCountAggregateInputType>]>>;
+    _min: z.ZodOptional<z.ZodType<Prisma.PatientDocumentMinAggregateInputType, z.ZodTypeDef, Prisma.PatientDocumentMinAggregateInputType>>;
+    _max: z.ZodOptional<z.ZodType<Prisma.PatientDocumentMaxAggregateInputType, z.ZodTypeDef, Prisma.PatientDocumentMaxAggregateInputType>>;
+    _avg: z.ZodOptional<z.ZodType<Prisma.PatientDocumentAvgAggregateInputType, z.ZodTypeDef, Prisma.PatientDocumentAvgAggregateInputType>>;
+    _sum: z.ZodOptional<z.ZodType<Prisma.PatientDocumentSumAggregateInputType, z.ZodTypeDef, Prisma.PatientDocumentSumAggregateInputType>>;
+}, "strict", z.ZodTypeAny, {
+    where?: Prisma.PatientDocumentWhereInput | undefined;
+    _count?: true | Prisma.PatientDocumentCountAggregateInputType | undefined;
+    orderBy?: Prisma.PatientDocumentOrderByWithRelationInput | Prisma.PatientDocumentOrderByWithRelationInput[] | undefined;
+    cursor?: Prisma.PatientDocumentWhereUniqueInput | undefined;
+    take?: number | undefined;
+    skip?: number | undefined;
+    _min?: Prisma.PatientDocumentMinAggregateInputType | undefined;
+    _max?: Prisma.PatientDocumentMaxAggregateInputType | undefined;
+    _avg?: Prisma.PatientDocumentAvgAggregateInputType | undefined;
+    _sum?: Prisma.PatientDocumentSumAggregateInputType | undefined;
+}, {
+    where?: Prisma.PatientDocumentWhereInput | undefined;
+    _count?: true | Prisma.PatientDocumentCountAggregateInputType | undefined;
+    orderBy?: Prisma.PatientDocumentOrderByWithRelationInput | Prisma.PatientDocumentOrderByWithRelationInput[] | undefined;
+    cursor?: Prisma.PatientDocumentWhereUniqueInput | undefined;
+    take?: number | undefined;
+    skip?: number | undefined;
+    _min?: Prisma.PatientDocumentMinAggregateInputType | undefined;
+    _max?: Prisma.PatientDocumentMaxAggregateInputType | undefined;
+    _avg?: Prisma.PatientDocumentAvgAggregateInputType | undefined;
+    _sum?: Prisma.PatientDocumentSumAggregateInputType | undefined;
+}>;
+//# sourceMappingURL=aggregatePatientDocument.schema.d.ts.map

packages/db/shared/schemas/aggregatePatientDocument.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aggregatePatientDocument.schema.d.ts","sourceRoot":"","sources":["aggregatePatientDocument.schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAUzB,eAAO,MAAM,8BAA8B,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,4BAA4B,CAAuvB,CAAC;AAEl1B,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAyrB,CAAC"}

packages/db/shared/schemas/aggregatePatientDocument.schema.js

@@ -0,0 +1,47 @@
+"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.PatientDocumentAggregateZodSchema = exports.PatientDocumentAggregateSchema = void 0;
+const z = __importStar(require("zod"));
+const PatientDocumentOrderByWithRelationInput_schema_1 = require("./objects/PatientDocumentOrderByWithRelationInput.schema");
+const PatientDocumentWhereInput_schema_1 = require("./objects/PatientDocumentWhereInput.schema");
+const PatientDocumentWhereUniqueInput_schema_1 = require("./objects/PatientDocumentWhereUniqueInput.schema");
+const PatientDocumentCountAggregateInput_schema_1 = require("./objects/PatientDocumentCountAggregateInput.schema");
+const PatientDocumentMinAggregateInput_schema_1 = require("./objects/PatientDocumentMinAggregateInput.schema");
+const PatientDocumentMaxAggregateInput_schema_1 = require("./objects/PatientDocumentMaxAggregateInput.schema");
+const PatientDocumentAvgAggregateInput_schema_1 = require("./objects/PatientDocumentAvgAggregateInput.schema");
+const PatientDocumentSumAggregateInput_schema_1 = require("./objects/PatientDocumentSumAggregateInput.schema");
+exports.PatientDocumentAggregateSchema = z.object({ orderBy: z.union([PatientDocumentOrderByWithRelationInput_schema_1.PatientDocumentOrderByWithRelationInputObjectSchema, PatientDocumentOrderByWithRelationInput_schema_1.PatientDocumentOrderByWithRelationInputObjectSchema.array()]).optional(), where: PatientDocumentWhereInput_schema_1.PatientDocumentWhereInputObjectSchema.optional(), cursor: PatientDocumentWhereUniqueInput_schema_1.PatientDocumentWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), _count: z.union([z.literal(true), PatientDocumentCountAggregateInput_schema_1.PatientDocumentCountAggregateInputObjectSchema]).optional(), _min: PatientDocumentMinAggregateInput_schema_1.PatientDocumentMinAggregateInputObjectSchema.optional(), _max: PatientDocumentMaxAggregateInput_schema_1.PatientDocumentMaxAggregateInputObjectSchema.optional(), _avg: PatientDocumentAvgAggregateInput_schema_1.PatientDocumentAvgAggregateInputObjectSchema.optional(), _sum: PatientDocumentSumAggregateInput_schema_1.PatientDocumentSumAggregateInputObjectSchema.optional() }).strict();
+exports.PatientDocumentAggregateZodSchema = z.object({ orderBy: z.union([PatientDocumentOrderByWithRelationInput_schema_1.PatientDocumentOrderByWithRelationInputObjectSchema, PatientDocumentOrderByWithRelationInput_schema_1.PatientDocumentOrderByWithRelationInputObjectSchema.array()]).optional(), where: PatientDocumentWhereInput_schema_1.PatientDocumentWhereInputObjectSchema.optional(), cursor: PatientDocumentWhereUniqueInput_schema_1.PatientDocumentWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), _count: z.union([z.literal(true), PatientDocumentCountAggregateInput_schema_1.PatientDocumentCountAggregateInputObjectSchema]).optional(), _min: PatientDocumentMinAggregateInput_schema_1.PatientDocumentMinAggregateInputObjectSchema.optional(), _max: PatientDocumentMaxAggregateInput_schema_1.PatientDocumentMaxAggregateInputObjectSchema.optional(), _avg: PatientDocumentAvgAggregateInput_schema_1.PatientDocumentAvgAggregateInputObjectSchema.optional(), _sum: PatientDocumentSumAggregateInput_schema_1.PatientDocumentSumAggregateInputObjectSchema.optional() }).strict();

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

@@ -0,0 +1,14 @@
+import type { Prisma } from '../../generated/prisma';
+import * as z from 'zod';
+import { PatientDocumentOrderByWithRelationInputObjectSchema as PatientDocumentOrderByWithRelationInputObjectSchema } from './objects/PatientDocumentOrderByWithRelationInput.schema';
+import { PatientDocumentWhereInputObjectSchema as PatientDocumentWhereInputObjectSchema } from './objects/PatientDocumentWhereInput.schema';
+import { PatientDocumentWhereUniqueInputObjectSchema as PatientDocumentWhereUniqueInputObjectSchema } from './objects/PatientDocumentWhereUniqueInput.schema';
+import { PatientDocumentCountAggregateInputObjectSchema as PatientDocumentCountAggregateInputObjectSchema } from './objects/PatientDocumentCountAggregateInput.schema';
+import { PatientDocumentMinAggregateInputObjectSchema as PatientDocumentMinAggregateInputObjectSchema } from './objects/PatientDocumentMinAggregateInput.schema';
+import { PatientDocumentMaxAggregateInputObjectSchema as PatientDocumentMaxAggregateInputObjectSchema } from './objects/PatientDocumentMaxAggregateInput.schema';
+import { PatientDocumentAvgAggregateInputObjectSchema as PatientDocumentAvgAggregateInputObjectSchema } from './objects/PatientDocumentAvgAggregateInput.schema';
+import { PatientDocumentSumAggregateInputObjectSchema as PatientDocumentSumAggregateInputObjectSchema } from './objects/PatientDocumentSumAggregateInput.schema';
+
+export const PatientDocumentAggregateSchema: z.ZodType<Prisma.PatientDocumentAggregateArgs> = z.object({ orderBy: z.union([PatientDocumentOrderByWithRelationInputObjectSchema, PatientDocumentOrderByWithRelationInputObjectSchema.array()]).optional(), where: PatientDocumentWhereInputObjectSchema.optional(), cursor: PatientDocumentWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), _count: z.union([ z.literal(true), PatientDocumentCountAggregateInputObjectSchema ]).optional(), _min: PatientDocumentMinAggregateInputObjectSchema.optional(), _max: PatientDocumentMaxAggregateInputObjectSchema.optional(), _avg: PatientDocumentAvgAggregateInputObjectSchema.optional(), _sum: PatientDocumentSumAggregateInputObjectSchema.optional() }).strict() as unknown as z.ZodType<Prisma.PatientDocumentAggregateArgs>;
+
+export const PatientDocumentAggregateZodSchema = z.object({ orderBy: z.union([PatientDocumentOrderByWithRelationInputObjectSchema, PatientDocumentOrderByWithRelationInputObjectSchema.array()]).optional(), where: PatientDocumentWhereInputObjectSchema.optional(), cursor: PatientDocumentWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), _count: z.union([ z.literal(true), PatientDocumentCountAggregateInputObjectSchema ]).optional(), _min: PatientDocumentMinAggregateInputObjectSchema.optional(), _max: PatientDocumentMaxAggregateInputObjectSchema.optional(), _avg: PatientDocumentAvgAggregateInputObjectSchema.optional(), _sum: PatientDocumentSumAggregateInputObjectSchema.optional() }).strict();

packages/db/shared/schemas/aggregatePayment.schema.d.ts

@@ -0,0 +1,38 @@
+import type { Prisma } from '../../generated/prisma';
+import * as z from 'zod';
+export declare const PaymentAggregateSchema: z.ZodType<Prisma.PaymentAggregateArgs>;
+export declare const PaymentAggregateZodSchema: z.ZodObject<{
+    orderBy: z.ZodOptional<z.ZodUnion<[z.ZodType<Prisma.PaymentOrderByWithRelationInput, z.ZodTypeDef, Prisma.PaymentOrderByWithRelationInput>, z.ZodArray<z.ZodType<Prisma.PaymentOrderByWithRelationInput, z.ZodTypeDef, Prisma.PaymentOrderByWithRelationInput>, "many">]>>;
+    where: z.ZodOptional<z.ZodType<Prisma.PaymentWhereInput, z.ZodTypeDef, Prisma.PaymentWhereInput>>;
+    cursor: z.ZodOptional<z.ZodType<Prisma.PaymentWhereUniqueInput, z.ZodTypeDef, Prisma.PaymentWhereUniqueInput>>;
+    take: z.ZodOptional<z.ZodNumber>;
+    skip: z.ZodOptional<z.ZodNumber>;
+    _count: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<true>, z.ZodType<Prisma.PaymentCountAggregateInputType, z.ZodTypeDef, Prisma.PaymentCountAggregateInputType>]>>;
+    _min: z.ZodOptional<z.ZodType<Prisma.PaymentMinAggregateInputType, z.ZodTypeDef, Prisma.PaymentMinAggregateInputType>>;
+    _max: z.ZodOptional<z.ZodType<Prisma.PaymentMaxAggregateInputType, z.ZodTypeDef, Prisma.PaymentMaxAggregateInputType>>;
+    _avg: z.ZodOptional<z.ZodType<Prisma.PaymentAvgAggregateInputType, z.ZodTypeDef, Prisma.PaymentAvgAggregateInputType>>;
+    _sum: z.ZodOptional<z.ZodType<Prisma.PaymentSumAggregateInputType, z.ZodTypeDef, Prisma.PaymentSumAggregateInputType>>;
+}, "strict", z.ZodTypeAny, {
+    where?: Prisma.PaymentWhereInput | undefined;
+    _count?: true | Prisma.PaymentCountAggregateInputType | undefined;
+    orderBy?: Prisma.PaymentOrderByWithRelationInput | Prisma.PaymentOrderByWithRelationInput[] | undefined;
+    cursor?: Prisma.PaymentWhereUniqueInput | undefined;
+    take?: number | undefined;
+    skip?: number | undefined;
+    _min?: Prisma.PaymentMinAggregateInputType | undefined;
+    _max?: Prisma.PaymentMaxAggregateInputType | undefined;
+    _avg?: Prisma.PaymentAvgAggregateInputType | undefined;
+    _sum?: Prisma.PaymentSumAggregateInputType | undefined;
+}, {
+    where?: Prisma.PaymentWhereInput | undefined;
+    _count?: true | Prisma.PaymentCountAggregateInputType | undefined;
+    orderBy?: Prisma.PaymentOrderByWithRelationInput | Prisma.PaymentOrderByWithRelationInput[] | undefined;
+    cursor?: Prisma.PaymentWhereUniqueInput | undefined;
+    take?: number | undefined;
+    skip?: number | undefined;
+    _min?: Prisma.PaymentMinAggregateInputType | undefined;
+    _max?: Prisma.PaymentMaxAggregateInputType | undefined;
+    _avg?: Prisma.PaymentAvgAggregateInputType | undefined;
+    _sum?: Prisma.PaymentSumAggregateInputType | undefined;
+}>;
+//# sourceMappingURL=aggregatePayment.schema.d.ts.map

packages/db/shared/schemas/aggregatePayment.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aggregatePayment.schema.d.ts","sourceRoot":"","sources":["aggregatePayment.schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAUzB,eAAO,MAAM,sBAAsB,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,oBAAoB,CAAuqB,CAAC;AAElvB,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAinB,CAAC"}

packages/db/shared/schemas/aggregatePayment.schema.js

@@ -0,0 +1,47 @@
+"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.PaymentAggregateZodSchema = exports.PaymentAggregateSchema = void 0;
+const z = __importStar(require("zod"));
+const PaymentOrderByWithRelationInput_schema_1 = require("./objects/PaymentOrderByWithRelationInput.schema");
+const PaymentWhereInput_schema_1 = require("./objects/PaymentWhereInput.schema");
+const PaymentWhereUniqueInput_schema_1 = require("./objects/PaymentWhereUniqueInput.schema");
+const PaymentCountAggregateInput_schema_1 = require("./objects/PaymentCountAggregateInput.schema");
+const PaymentMinAggregateInput_schema_1 = require("./objects/PaymentMinAggregateInput.schema");
+const PaymentMaxAggregateInput_schema_1 = require("./objects/PaymentMaxAggregateInput.schema");
+const PaymentAvgAggregateInput_schema_1 = require("./objects/PaymentAvgAggregateInput.schema");
+const PaymentSumAggregateInput_schema_1 = require("./objects/PaymentSumAggregateInput.schema");
+exports.PaymentAggregateSchema = z.object({ orderBy: z.union([PaymentOrderByWithRelationInput_schema_1.PaymentOrderByWithRelationInputObjectSchema, PaymentOrderByWithRelationInput_schema_1.PaymentOrderByWithRelationInputObjectSchema.array()]).optional(), where: PaymentWhereInput_schema_1.PaymentWhereInputObjectSchema.optional(), cursor: PaymentWhereUniqueInput_schema_1.PaymentWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), _count: z.union([z.literal(true), PaymentCountAggregateInput_schema_1.PaymentCountAggregateInputObjectSchema]).optional(), _min: PaymentMinAggregateInput_schema_1.PaymentMinAggregateInputObjectSchema.optional(), _max: PaymentMaxAggregateInput_schema_1.PaymentMaxAggregateInputObjectSchema.optional(), _avg: PaymentAvgAggregateInput_schema_1.PaymentAvgAggregateInputObjectSchema.optional(), _sum: PaymentSumAggregateInput_schema_1.PaymentSumAggregateInputObjectSchema.optional() }).strict();
+exports.PaymentAggregateZodSchema = z.object({ orderBy: z.union([PaymentOrderByWithRelationInput_schema_1.PaymentOrderByWithRelationInputObjectSchema, PaymentOrderByWithRelationInput_schema_1.PaymentOrderByWithRelationInputObjectSchema.array()]).optional(), where: PaymentWhereInput_schema_1.PaymentWhereInputObjectSchema.optional(), cursor: PaymentWhereUniqueInput_schema_1.PaymentWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), _count: z.union([z.literal(true), PaymentCountAggregateInput_schema_1.PaymentCountAggregateInputObjectSchema]).optional(), _min: PaymentMinAggregateInput_schema_1.PaymentMinAggregateInputObjectSchema.optional(), _max: PaymentMaxAggregateInput_schema_1.PaymentMaxAggregateInputObjectSchema.optional(), _avg: PaymentAvgAggregateInput_schema_1.PaymentAvgAggregateInputObjectSchema.optional(), _sum: PaymentSumAggregateInput_schema_1.PaymentSumAggregateInputObjectSchema.optional() }).strict();

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

@@ -0,0 +1,14 @@
+import type { Prisma } from '../../generated/prisma';
+import * as z from 'zod';
+import { PaymentOrderByWithRelationInputObjectSchema as PaymentOrderByWithRelationInputObjectSchema } from './objects/PaymentOrderByWithRelationInput.schema';
+import { PaymentWhereInputObjectSchema as PaymentWhereInputObjectSchema } from './objects/PaymentWhereInput.schema';
+import { PaymentWhereUniqueInputObjectSchema as PaymentWhereUniqueInputObjectSchema } from './objects/PaymentWhereUniqueInput.schema';
+import { PaymentCountAggregateInputObjectSchema as PaymentCountAggregateInputObjectSchema } from './objects/PaymentCountAggregateInput.schema';
+import { PaymentMinAggregateInputObjectSchema as PaymentMinAggregateInputObjectSchema } from './objects/PaymentMinAggregateInput.schema';
+import { PaymentMaxAggregateInputObjectSchema as PaymentMaxAggregateInputObjectSchema } from './objects/PaymentMaxAggregateInput.schema';
+import { PaymentAvgAggregateInputObjectSchema as PaymentAvgAggregateInputObjectSchema } from './objects/PaymentAvgAggregateInput.schema';
+import { PaymentSumAggregateInputObjectSchema as PaymentSumAggregateInputObjectSchema } from './objects/PaymentSumAggregateInput.schema';
+
+export const PaymentAggregateSchema: z.ZodType<Prisma.PaymentAggregateArgs> = z.object({ orderBy: z.union([PaymentOrderByWithRelationInputObjectSchema, PaymentOrderByWithRelationInputObjectSchema.array()]).optional(), where: PaymentWhereInputObjectSchema.optional(), cursor: PaymentWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), _count: z.union([ z.literal(true), PaymentCountAggregateInputObjectSchema ]).optional(), _min: PaymentMinAggregateInputObjectSchema.optional(), _max: PaymentMaxAggregateInputObjectSchema.optional(), _avg: PaymentAvgAggregateInputObjectSchema.optional(), _sum: PaymentSumAggregateInputObjectSchema.optional() }).strict() as unknown as z.ZodType<Prisma.PaymentAggregateArgs>;
+
+export const PaymentAggregateZodSchema = z.object({ orderBy: z.union([PaymentOrderByWithRelationInputObjectSchema, PaymentOrderByWithRelationInputObjectSchema.array()]).optional(), where: PaymentWhereInputObjectSchema.optional(), cursor: PaymentWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), _count: z.union([ z.literal(true), PaymentCountAggregateInputObjectSchema ]).optional(), _min: PaymentMinAggregateInputObjectSchema.optional(), _max: PaymentMaxAggregateInputObjectSchema.optional(), _avg: PaymentAvgAggregateInputObjectSchema.optional(), _sum: PaymentSumAggregateInputObjectSchema.optional() }).strict();

packages/db/shared/schemas/aggregatePdfFile.schema.d.ts

@@ -0,0 +1,38 @@
+import type { Prisma } from '../../generated/prisma';
+import * as z from 'zod';
+export declare const PdfFileAggregateSchema: z.ZodType<Prisma.PdfFileAggregateArgs>;
+export declare const PdfFileAggregateZodSchema: z.ZodObject<{
+    orderBy: z.ZodOptional<z.ZodUnion<[z.ZodType<Prisma.PdfFileOrderByWithRelationInput, z.ZodTypeDef, Prisma.PdfFileOrderByWithRelationInput>, z.ZodArray<z.ZodType<Prisma.PdfFileOrderByWithRelationInput, z.ZodTypeDef, Prisma.PdfFileOrderByWithRelationInput>, "many">]>>;
+    where: z.ZodOptional<z.ZodType<Prisma.PdfFileWhereInput, z.ZodTypeDef, Prisma.PdfFileWhereInput>>;
+    cursor: z.ZodOptional<z.ZodType<Prisma.PdfFileWhereUniqueInput, z.ZodTypeDef, Prisma.PdfFileWhereUniqueInput>>;
+    take: z.ZodOptional<z.ZodNumber>;
+    skip: z.ZodOptional<z.ZodNumber>;
+    _count: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<true>, z.ZodType<Prisma.PdfFileCountAggregateInputType, z.ZodTypeDef, Prisma.PdfFileCountAggregateInputType>]>>;
+    _min: z.ZodOptional<z.ZodType<Prisma.PdfFileMinAggregateInputType, z.ZodTypeDef, Prisma.PdfFileMinAggregateInputType>>;
+    _max: z.ZodOptional<z.ZodType<Prisma.PdfFileMaxAggregateInputType, z.ZodTypeDef, Prisma.PdfFileMaxAggregateInputType>>;
+    _avg: z.ZodOptional<z.ZodType<Prisma.PdfFileAvgAggregateInputType, z.ZodTypeDef, Prisma.PdfFileAvgAggregateInputType>>;
+    _sum: z.ZodOptional<z.ZodType<Prisma.PdfFileSumAggregateInputType, z.ZodTypeDef, Prisma.PdfFileSumAggregateInputType>>;
+}, "strict", z.ZodTypeAny, {
+    where?: Prisma.PdfFileWhereInput | undefined;
+    _count?: true | Prisma.PdfFileCountAggregateInputType | undefined;
+    orderBy?: Prisma.PdfFileOrderByWithRelationInput | Prisma.PdfFileOrderByWithRelationInput[] | undefined;
+    cursor?: Prisma.PdfFileWhereUniqueInput | undefined;
+    take?: number | undefined;
+    skip?: number | undefined;
+    _min?: Prisma.PdfFileMinAggregateInputType | undefined;
+    _max?: Prisma.PdfFileMaxAggregateInputType | undefined;
+    _avg?: Prisma.PdfFileAvgAggregateInputType | undefined;
+    _sum?: Prisma.PdfFileSumAggregateInputType | undefined;
+}, {
+    where?: Prisma.PdfFileWhereInput | undefined;
+    _count?: true | Prisma.PdfFileCountAggregateInputType | undefined;
+    orderBy?: Prisma.PdfFileOrderByWithRelationInput | Prisma.PdfFileOrderByWithRelationInput[] | undefined;
+    cursor?: Prisma.PdfFileWhereUniqueInput | undefined;
+    take?: number | undefined;
+    skip?: number | undefined;
+    _min?: Prisma.PdfFileMinAggregateInputType | undefined;
+    _max?: Prisma.PdfFileMaxAggregateInputType | undefined;
+    _avg?: Prisma.PdfFileAvgAggregateInputType | undefined;
+    _sum?: Prisma.PdfFileSumAggregateInputType | undefined;
+}>;
+//# sourceMappingURL=aggregatePdfFile.schema.d.ts.map

packages/db/shared/schemas/aggregatePdfFile.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aggregatePdfFile.schema.d.ts","sourceRoot":"","sources":["aggregatePdfFile.schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAUzB,eAAO,MAAM,sBAAsB,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,oBAAoB,CAAuqB,CAAC;AAElvB,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAinB,CAAC"}

packages/db/shared/schemas/aggregatePdfFile.schema.js

@@ -0,0 +1,47 @@
+"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.PdfFileAggregateZodSchema = exports.PdfFileAggregateSchema = void 0;
+const z = __importStar(require("zod"));
+const PdfFileOrderByWithRelationInput_schema_1 = require("./objects/PdfFileOrderByWithRelationInput.schema");
+const PdfFileWhereInput_schema_1 = require("./objects/PdfFileWhereInput.schema");
+const PdfFileWhereUniqueInput_schema_1 = require("./objects/PdfFileWhereUniqueInput.schema");
+const PdfFileCountAggregateInput_schema_1 = require("./objects/PdfFileCountAggregateInput.schema");
+const PdfFileMinAggregateInput_schema_1 = require("./objects/PdfFileMinAggregateInput.schema");
+const PdfFileMaxAggregateInput_schema_1 = require("./objects/PdfFileMaxAggregateInput.schema");
+const PdfFileAvgAggregateInput_schema_1 = require("./objects/PdfFileAvgAggregateInput.schema");
+const PdfFileSumAggregateInput_schema_1 = require("./objects/PdfFileSumAggregateInput.schema");
+exports.PdfFileAggregateSchema = z.object({ orderBy: z.union([PdfFileOrderByWithRelationInput_schema_1.PdfFileOrderByWithRelationInputObjectSchema, PdfFileOrderByWithRelationInput_schema_1.PdfFileOrderByWithRelationInputObjectSchema.array()]).optional(), where: PdfFileWhereInput_schema_1.PdfFileWhereInputObjectSchema.optional(), cursor: PdfFileWhereUniqueInput_schema_1.PdfFileWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), _count: z.union([z.literal(true), PdfFileCountAggregateInput_schema_1.PdfFileCountAggregateInputObjectSchema]).optional(), _min: PdfFileMinAggregateInput_schema_1.PdfFileMinAggregateInputObjectSchema.optional(), _max: PdfFileMaxAggregateInput_schema_1.PdfFileMaxAggregateInputObjectSchema.optional(), _avg: PdfFileAvgAggregateInput_schema_1.PdfFileAvgAggregateInputObjectSchema.optional(), _sum: PdfFileSumAggregateInput_schema_1.PdfFileSumAggregateInputObjectSchema.optional() }).strict();
+exports.PdfFileAggregateZodSchema = z.object({ orderBy: z.union([PdfFileOrderByWithRelationInput_schema_1.PdfFileOrderByWithRelationInputObjectSchema, PdfFileOrderByWithRelationInput_schema_1.PdfFileOrderByWithRelationInputObjectSchema.array()]).optional(), where: PdfFileWhereInput_schema_1.PdfFileWhereInputObjectSchema.optional(), cursor: PdfFileWhereUniqueInput_schema_1.PdfFileWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), _count: z.union([z.literal(true), PdfFileCountAggregateInput_schema_1.PdfFileCountAggregateInputObjectSchema]).optional(), _min: PdfFileMinAggregateInput_schema_1.PdfFileMinAggregateInputObjectSchema.optional(), _max: PdfFileMaxAggregateInput_schema_1.PdfFileMaxAggregateInputObjectSchema.optional(), _avg: PdfFileAvgAggregateInput_schema_1.PdfFileAvgAggregateInputObjectSchema.optional(), _sum: PdfFileSumAggregateInput_schema_1.PdfFileSumAggregateInputObjectSchema.optional() }).strict();

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

@@ -0,0 +1,14 @@
+import type { Prisma } from '../../generated/prisma';
+import * as z from 'zod';
+import { PdfFileOrderByWithRelationInputObjectSchema as PdfFileOrderByWithRelationInputObjectSchema } from './objects/PdfFileOrderByWithRelationInput.schema';
+import { PdfFileWhereInputObjectSchema as PdfFileWhereInputObjectSchema } from './objects/PdfFileWhereInput.schema';
+import { PdfFileWhereUniqueInputObjectSchema as PdfFileWhereUniqueInputObjectSchema } from './objects/PdfFileWhereUniqueInput.schema';
+import { PdfFileCountAggregateInputObjectSchema as PdfFileCountAggregateInputObjectSchema } from './objects/PdfFileCountAggregateInput.schema';
+import { PdfFileMinAggregateInputObjectSchema as PdfFileMinAggregateInputObjectSchema } from './objects/PdfFileMinAggregateInput.schema';
+import { PdfFileMaxAggregateInputObjectSchema as PdfFileMaxAggregateInputObjectSchema } from './objects/PdfFileMaxAggregateInput.schema';
+import { PdfFileAvgAggregateInputObjectSchema as PdfFileAvgAggregateInputObjectSchema } from './objects/PdfFileAvgAggregateInput.schema';
+import { PdfFileSumAggregateInputObjectSchema as PdfFileSumAggregateInputObjectSchema } from './objects/PdfFileSumAggregateInput.schema';
+
+export const PdfFileAggregateSchema: z.ZodType<Prisma.PdfFileAggregateArgs> = z.object({ orderBy: z.union([PdfFileOrderByWithRelationInputObjectSchema, PdfFileOrderByWithRelationInputObjectSchema.array()]).optional(), where: PdfFileWhereInputObjectSchema.optional(), cursor: PdfFileWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), _count: z.union([ z.literal(true), PdfFileCountAggregateInputObjectSchema ]).optional(), _min: PdfFileMinAggregateInputObjectSchema.optional(), _max: PdfFileMaxAggregateInputObjectSchema.optional(), _avg: PdfFileAvgAggregateInputObjectSchema.optional(), _sum: PdfFileSumAggregateInputObjectSchema.optional() }).strict() as unknown as z.ZodType<Prisma.PdfFileAggregateArgs>;
+
+export const PdfFileAggregateZodSchema = z.object({ orderBy: z.union([PdfFileOrderByWithRelationInputObjectSchema, PdfFileOrderByWithRelationInputObjectSchema.array()]).optional(), where: PdfFileWhereInputObjectSchema.optional(), cursor: PdfFileWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), _count: z.union([ z.literal(true), PdfFileCountAggregateInputObjectSchema ]).optional(), _min: PdfFileMinAggregateInputObjectSchema.optional(), _max: PdfFileMaxAggregateInputObjectSchema.optional(), _avg: PdfFileAvgAggregateInputObjectSchema.optional(), _sum: PdfFileSumAggregateInputObjectSchema.optional() }).strict();

packages/db/shared/schemas/aggregatePdfGroup.schema.d.ts

@@ -0,0 +1,38 @@
+import type { Prisma } from '../../generated/prisma';
+import * as z from 'zod';
+export declare const PdfGroupAggregateSchema: z.ZodType<Prisma.PdfGroupAggregateArgs>;
+export declare const PdfGroupAggregateZodSchema: z.ZodObject<{
+    orderBy: z.ZodOptional<z.ZodUnion<[z.ZodType<Prisma.PdfGroupOrderByWithRelationInput, z.ZodTypeDef, Prisma.PdfGroupOrderByWithRelationInput>, z.ZodArray<z.ZodType<Prisma.PdfGroupOrderByWithRelationInput, z.ZodTypeDef, Prisma.PdfGroupOrderByWithRelationInput>, "many">]>>;
+    where: z.ZodOptional<z.ZodType<Prisma.PdfGroupWhereInput, z.ZodTypeDef, Prisma.PdfGroupWhereInput>>;
+    cursor: z.ZodOptional<z.ZodType<Prisma.PdfGroupWhereUniqueInput, z.ZodTypeDef, Prisma.PdfGroupWhereUniqueInput>>;
+    take: z.ZodOptional<z.ZodNumber>;
+    skip: z.ZodOptional<z.ZodNumber>;
+    _count: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<true>, z.ZodType<Prisma.PdfGroupCountAggregateInputType, z.ZodTypeDef, Prisma.PdfGroupCountAggregateInputType>]>>;
+    _min: z.ZodOptional<z.ZodType<Prisma.PdfGroupMinAggregateInputType, z.ZodTypeDef, Prisma.PdfGroupMinAggregateInputType>>;
+    _max: z.ZodOptional<z.ZodType<Prisma.PdfGroupMaxAggregateInputType, z.ZodTypeDef, Prisma.PdfGroupMaxAggregateInputType>>;
+    _avg: z.ZodOptional<z.ZodType<Prisma.PdfGroupAvgAggregateInputType, z.ZodTypeDef, Prisma.PdfGroupAvgAggregateInputType>>;
+    _sum: z.ZodOptional<z.ZodType<Prisma.PdfGroupSumAggregateInputType, z.ZodTypeDef, Prisma.PdfGroupSumAggregateInputType>>;
+}, "strict", z.ZodTypeAny, {
+    where?: Prisma.PdfGroupWhereInput | undefined;
+    _count?: true | Prisma.PdfGroupCountAggregateInputType | undefined;
+    orderBy?: Prisma.PdfGroupOrderByWithRelationInput | Prisma.PdfGroupOrderByWithRelationInput[] | undefined;
+    cursor?: Prisma.PdfGroupWhereUniqueInput | undefined;
+    take?: number | undefined;
+    skip?: number | undefined;
+    _min?: Prisma.PdfGroupMinAggregateInputType | undefined;
+    _max?: Prisma.PdfGroupMaxAggregateInputType | undefined;
+    _avg?: Prisma.PdfGroupAvgAggregateInputType | undefined;
+    _sum?: Prisma.PdfGroupSumAggregateInputType | undefined;
+}, {
+    where?: Prisma.PdfGroupWhereInput | undefined;
+    _count?: true | Prisma.PdfGroupCountAggregateInputType | undefined;
+    orderBy?: Prisma.PdfGroupOrderByWithRelationInput | Prisma.PdfGroupOrderByWithRelationInput[] | undefined;
+    cursor?: Prisma.PdfGroupWhereUniqueInput | undefined;
+    take?: number | undefined;
+    skip?: number | undefined;
+    _min?: Prisma.PdfGroupMinAggregateInputType | undefined;
+    _max?: Prisma.PdfGroupMaxAggregateInputType | undefined;
+    _avg?: Prisma.PdfGroupAvgAggregateInputType | undefined;
+    _sum?: Prisma.PdfGroupSumAggregateInputType | undefined;
+}>;
+//# sourceMappingURL=aggregatePdfGroup.schema.d.ts.map

packages/db/shared/schemas/aggregatePdfGroup.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aggregatePdfGroup.schema.d.ts","sourceRoot":"","sources":["aggregatePdfGroup.schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAUzB,eAAO,MAAM,uBAAuB,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,qBAAqB,CAAirB,CAAC;AAE9vB,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAA0nB,CAAC"}

packages/db/shared/schemas/aggregatePdfGroup.schema.js

@@ -0,0 +1,47 @@
+"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.PdfGroupAggregateZodSchema = exports.PdfGroupAggregateSchema = void 0;
+const z = __importStar(require("zod"));
+const PdfGroupOrderByWithRelationInput_schema_1 = require("./objects/PdfGroupOrderByWithRelationInput.schema");
+const PdfGroupWhereInput_schema_1 = require("./objects/PdfGroupWhereInput.schema");
+const PdfGroupWhereUniqueInput_schema_1 = require("./objects/PdfGroupWhereUniqueInput.schema");
+const PdfGroupCountAggregateInput_schema_1 = require("./objects/PdfGroupCountAggregateInput.schema");
+const PdfGroupMinAggregateInput_schema_1 = require("./objects/PdfGroupMinAggregateInput.schema");
+const PdfGroupMaxAggregateInput_schema_1 = require("./objects/PdfGroupMaxAggregateInput.schema");
+const PdfGroupAvgAggregateInput_schema_1 = require("./objects/PdfGroupAvgAggregateInput.schema");
+const PdfGroupSumAggregateInput_schema_1 = require("./objects/PdfGroupSumAggregateInput.schema");
+exports.PdfGroupAggregateSchema = z.object({ orderBy: z.union([PdfGroupOrderByWithRelationInput_schema_1.PdfGroupOrderByWithRelationInputObjectSchema, PdfGroupOrderByWithRelationInput_schema_1.PdfGroupOrderByWithRelationInputObjectSchema.array()]).optional(), where: PdfGroupWhereInput_schema_1.PdfGroupWhereInputObjectSchema.optional(), cursor: PdfGroupWhereUniqueInput_schema_1.PdfGroupWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), _count: z.union([z.literal(true), PdfGroupCountAggregateInput_schema_1.PdfGroupCountAggregateInputObjectSchema]).optional(), _min: PdfGroupMinAggregateInput_schema_1.PdfGroupMinAggregateInputObjectSchema.optional(), _max: PdfGroupMaxAggregateInput_schema_1.PdfGroupMaxAggregateInputObjectSchema.optional(), _avg: PdfGroupAvgAggregateInput_schema_1.PdfGroupAvgAggregateInputObjectSchema.optional(), _sum: PdfGroupSumAggregateInput_schema_1.PdfGroupSumAggregateInputObjectSchema.optional() }).strict();
+exports.PdfGroupAggregateZodSchema = z.object({ orderBy: z.union([PdfGroupOrderByWithRelationInput_schema_1.PdfGroupOrderByWithRelationInputObjectSchema, PdfGroupOrderByWithRelationInput_schema_1.PdfGroupOrderByWithRelationInputObjectSchema.array()]).optional(), where: PdfGroupWhereInput_schema_1.PdfGroupWhereInputObjectSchema.optional(), cursor: PdfGroupWhereUniqueInput_schema_1.PdfGroupWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), _count: z.union([z.literal(true), PdfGroupCountAggregateInput_schema_1.PdfGroupCountAggregateInputObjectSchema]).optional(), _min: PdfGroupMinAggregateInput_schema_1.PdfGroupMinAggregateInputObjectSchema.optional(), _max: PdfGroupMaxAggregateInput_schema_1.PdfGroupMaxAggregateInputObjectSchema.optional(), _avg: PdfGroupAvgAggregateInput_schema_1.PdfGroupAvgAggregateInputObjectSchema.optional(), _sum: PdfGroupSumAggregateInput_schema_1.PdfGroupSumAggregateInputObjectSchema.optional() }).strict();

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

@@ -0,0 +1,14 @@
+import type { Prisma } from '../../generated/prisma';
+import * as z from 'zod';
+import { PdfGroupOrderByWithRelationInputObjectSchema as PdfGroupOrderByWithRelationInputObjectSchema } from './objects/PdfGroupOrderByWithRelationInput.schema';
+import { PdfGroupWhereInputObjectSchema as PdfGroupWhereInputObjectSchema } from './objects/PdfGroupWhereInput.schema';
+import { PdfGroupWhereUniqueInputObjectSchema as PdfGroupWhereUniqueInputObjectSchema } from './objects/PdfGroupWhereUniqueInput.schema';
+import { PdfGroupCountAggregateInputObjectSchema as PdfGroupCountAggregateInputObjectSchema } from './objects/PdfGroupCountAggregateInput.schema';
+import { PdfGroupMinAggregateInputObjectSchema as PdfGroupMinAggregateInputObjectSchema } from './objects/PdfGroupMinAggregateInput.schema';
+import { PdfGroupMaxAggregateInputObjectSchema as PdfGroupMaxAggregateInputObjectSchema } from './objects/PdfGroupMaxAggregateInput.schema';
+import { PdfGroupAvgAggregateInputObjectSchema as PdfGroupAvgAggregateInputObjectSchema } from './objects/PdfGroupAvgAggregateInput.schema';
+import { PdfGroupSumAggregateInputObjectSchema as PdfGroupSumAggregateInputObjectSchema } from './objects/PdfGroupSumAggregateInput.schema';
+
+export const PdfGroupAggregateSchema: z.ZodType<Prisma.PdfGroupAggregateArgs> = z.object({ orderBy: z.union([PdfGroupOrderByWithRelationInputObjectSchema, PdfGroupOrderByWithRelationInputObjectSchema.array()]).optional(), where: PdfGroupWhereInputObjectSchema.optional(), cursor: PdfGroupWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), _count: z.union([ z.literal(true), PdfGroupCountAggregateInputObjectSchema ]).optional(), _min: PdfGroupMinAggregateInputObjectSchema.optional(), _max: PdfGroupMaxAggregateInputObjectSchema.optional(), _avg: PdfGroupAvgAggregateInputObjectSchema.optional(), _sum: PdfGroupSumAggregateInputObjectSchema.optional() }).strict() as unknown as z.ZodType<Prisma.PdfGroupAggregateArgs>;
+
+export const PdfGroupAggregateZodSchema = z.object({ orderBy: z.union([PdfGroupOrderByWithRelationInputObjectSchema, PdfGroupOrderByWithRelationInputObjectSchema.array()]).optional(), where: PdfGroupWhereInputObjectSchema.optional(), cursor: PdfGroupWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), _count: z.union([ z.literal(true), PdfGroupCountAggregateInputObjectSchema ]).optional(), _min: PdfGroupMinAggregateInputObjectSchema.optional(), _max: PdfGroupMaxAggregateInputObjectSchema.optional(), _avg: PdfGroupAvgAggregateInputObjectSchema.optional(), _sum: PdfGroupSumAggregateInputObjectSchema.optional() }).strict();

packages/db/shared/schemas/aggregateServiceLine.schema.d.ts

@@ -0,0 +1,38 @@
+import type { Prisma } from '../../generated/prisma';
+import * as z from 'zod';
+export declare const ServiceLineAggregateSchema: z.ZodType<Prisma.ServiceLineAggregateArgs>;
+export declare const ServiceLineAggregateZodSchema: z.ZodObject<{
+    orderBy: z.ZodOptional<z.ZodUnion<[z.ZodType<Prisma.ServiceLineOrderByWithRelationInput, z.ZodTypeDef, Prisma.ServiceLineOrderByWithRelationInput>, z.ZodArray<z.ZodType<Prisma.ServiceLineOrderByWithRelationInput, z.ZodTypeDef, Prisma.ServiceLineOrderByWithRelationInput>, "many">]>>;
+    where: z.ZodOptional<z.ZodType<Prisma.ServiceLineWhereInput, z.ZodTypeDef, Prisma.ServiceLineWhereInput>>;
+    cursor: z.ZodOptional<z.ZodType<Prisma.ServiceLineWhereUniqueInput, z.ZodTypeDef, Prisma.ServiceLineWhereUniqueInput>>;
+    take: z.ZodOptional<z.ZodNumber>;
+    skip: z.ZodOptional<z.ZodNumber>;
+    _count: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<true>, z.ZodType<Prisma.ServiceLineCountAggregateInputType, z.ZodTypeDef, Prisma.ServiceLineCountAggregateInputType>]>>;
+    _min: z.ZodOptional<z.ZodType<Prisma.ServiceLineMinAggregateInputType, z.ZodTypeDef, Prisma.ServiceLineMinAggregateInputType>>;
+    _max: z.ZodOptional<z.ZodType<Prisma.ServiceLineMaxAggregateInputType, z.ZodTypeDef, Prisma.ServiceLineMaxAggregateInputType>>;
+    _avg: z.ZodOptional<z.ZodType<Prisma.ServiceLineAvgAggregateInputType, z.ZodTypeDef, Prisma.ServiceLineAvgAggregateInputType>>;
+    _sum: z.ZodOptional<z.ZodType<Prisma.ServiceLineSumAggregateInputType, z.ZodTypeDef, Prisma.ServiceLineSumAggregateInputType>>;
+}, "strict", z.ZodTypeAny, {
+    where?: Prisma.ServiceLineWhereInput | undefined;
+    _count?: true | Prisma.ServiceLineCountAggregateInputType | undefined;
+    orderBy?: Prisma.ServiceLineOrderByWithRelationInput | Prisma.ServiceLineOrderByWithRelationInput[] | undefined;
+    cursor?: Prisma.ServiceLineWhereUniqueInput | undefined;
+    take?: number | undefined;
+    skip?: number | undefined;
+    _min?: Prisma.ServiceLineMinAggregateInputType | undefined;
+    _max?: Prisma.ServiceLineMaxAggregateInputType | undefined;
+    _avg?: Prisma.ServiceLineAvgAggregateInputType | undefined;
+    _sum?: Prisma.ServiceLineSumAggregateInputType | undefined;
+}, {
+    where?: Prisma.ServiceLineWhereInput | undefined;
+    _count?: true | Prisma.ServiceLineCountAggregateInputType | undefined;
+    orderBy?: Prisma.ServiceLineOrderByWithRelationInput | Prisma.ServiceLineOrderByWithRelationInput[] | undefined;
+    cursor?: Prisma.ServiceLineWhereUniqueInput | undefined;
+    take?: number | undefined;
+    skip?: number | undefined;
+    _min?: Prisma.ServiceLineMinAggregateInputType | undefined;
+    _max?: Prisma.ServiceLineMaxAggregateInputType | undefined;
+    _avg?: Prisma.ServiceLineAvgAggregateInputType | undefined;
+    _sum?: Prisma.ServiceLineSumAggregateInputType | undefined;
+}>;
+//# sourceMappingURL=aggregateServiceLine.schema.d.ts.map

packages/db/shared/schemas/aggregateServiceLine.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aggregateServiceLine.schema.d.ts","sourceRoot":"","sources":["aggregateServiceLine.schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAUzB,eAAO,MAAM,0BAA0B,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,wBAAwB,CAA+sB,CAAC;AAElyB,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAqpB,CAAC"}

packages/db/shared/schemas/aggregateServiceLine.schema.js

@@ -0,0 +1,47 @@
+"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.ServiceLineAggregateZodSchema = exports.ServiceLineAggregateSchema = void 0;
+const z = __importStar(require("zod"));
+const ServiceLineOrderByWithRelationInput_schema_1 = require("./objects/ServiceLineOrderByWithRelationInput.schema");
+const ServiceLineWhereInput_schema_1 = require("./objects/ServiceLineWhereInput.schema");
+const ServiceLineWhereUniqueInput_schema_1 = require("./objects/ServiceLineWhereUniqueInput.schema");
+const ServiceLineCountAggregateInput_schema_1 = require("./objects/ServiceLineCountAggregateInput.schema");
+const ServiceLineMinAggregateInput_schema_1 = require("./objects/ServiceLineMinAggregateInput.schema");
+const ServiceLineMaxAggregateInput_schema_1 = require("./objects/ServiceLineMaxAggregateInput.schema");
+const ServiceLineAvgAggregateInput_schema_1 = require("./objects/ServiceLineAvgAggregateInput.schema");
+const ServiceLineSumAggregateInput_schema_1 = require("./objects/ServiceLineSumAggregateInput.schema");
+exports.ServiceLineAggregateSchema = z.object({ orderBy: z.union([ServiceLineOrderByWithRelationInput_schema_1.ServiceLineOrderByWithRelationInputObjectSchema, ServiceLineOrderByWithRelationInput_schema_1.ServiceLineOrderByWithRelationInputObjectSchema.array()]).optional(), where: ServiceLineWhereInput_schema_1.ServiceLineWhereInputObjectSchema.optional(), cursor: ServiceLineWhereUniqueInput_schema_1.ServiceLineWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), _count: z.union([z.literal(true), ServiceLineCountAggregateInput_schema_1.ServiceLineCountAggregateInputObjectSchema]).optional(), _min: ServiceLineMinAggregateInput_schema_1.ServiceLineMinAggregateInputObjectSchema.optional(), _max: ServiceLineMaxAggregateInput_schema_1.ServiceLineMaxAggregateInputObjectSchema.optional(), _avg: ServiceLineAvgAggregateInput_schema_1.ServiceLineAvgAggregateInputObjectSchema.optional(), _sum: ServiceLineSumAggregateInput_schema_1.ServiceLineSumAggregateInputObjectSchema.optional() }).strict();
+exports.ServiceLineAggregateZodSchema = z.object({ orderBy: z.union([ServiceLineOrderByWithRelationInput_schema_1.ServiceLineOrderByWithRelationInputObjectSchema, ServiceLineOrderByWithRelationInput_schema_1.ServiceLineOrderByWithRelationInputObjectSchema.array()]).optional(), where: ServiceLineWhereInput_schema_1.ServiceLineWhereInputObjectSchema.optional(), cursor: ServiceLineWhereUniqueInput_schema_1.ServiceLineWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), _count: z.union([z.literal(true), ServiceLineCountAggregateInput_schema_1.ServiceLineCountAggregateInputObjectSchema]).optional(), _min: ServiceLineMinAggregateInput_schema_1.ServiceLineMinAggregateInputObjectSchema.optional(), _max: ServiceLineMaxAggregateInput_schema_1.ServiceLineMaxAggregateInputObjectSchema.optional(), _avg: ServiceLineAvgAggregateInput_schema_1.ServiceLineAvgAggregateInputObjectSchema.optional(), _sum: ServiceLineSumAggregateInput_schema_1.ServiceLineSumAggregateInputObjectSchema.optional() }).strict();

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

@@ -0,0 +1,14 @@
+import type { Prisma } from '../../generated/prisma';
+import * as z from 'zod';
+import { ServiceLineOrderByWithRelationInputObjectSchema as ServiceLineOrderByWithRelationInputObjectSchema } from './objects/ServiceLineOrderByWithRelationInput.schema';
+import { ServiceLineWhereInputObjectSchema as ServiceLineWhereInputObjectSchema } from './objects/ServiceLineWhereInput.schema';
+import { ServiceLineWhereUniqueInputObjectSchema as ServiceLineWhereUniqueInputObjectSchema } from './objects/ServiceLineWhereUniqueInput.schema';
+import { ServiceLineCountAggregateInputObjectSchema as ServiceLineCountAggregateInputObjectSchema } from './objects/ServiceLineCountAggregateInput.schema';
+import { ServiceLineMinAggregateInputObjectSchema as ServiceLineMinAggregateInputObjectSchema } from './objects/ServiceLineMinAggregateInput.schema';
+import { ServiceLineMaxAggregateInputObjectSchema as ServiceLineMaxAggregateInputObjectSchema } from './objects/ServiceLineMaxAggregateInput.schema';
+import { ServiceLineAvgAggregateInputObjectSchema as ServiceLineAvgAggregateInputObjectSchema } from './objects/ServiceLineAvgAggregateInput.schema';
+import { ServiceLineSumAggregateInputObjectSchema as ServiceLineSumAggregateInputObjectSchema } from './objects/ServiceLineSumAggregateInput.schema';
+
+export const ServiceLineAggregateSchema: z.ZodType<Prisma.ServiceLineAggregateArgs> = z.object({ orderBy: z.union([ServiceLineOrderByWithRelationInputObjectSchema, ServiceLineOrderByWithRelationInputObjectSchema.array()]).optional(), where: ServiceLineWhereInputObjectSchema.optional(), cursor: ServiceLineWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), _count: z.union([ z.literal(true), ServiceLineCountAggregateInputObjectSchema ]).optional(), _min: ServiceLineMinAggregateInputObjectSchema.optional(), _max: ServiceLineMaxAggregateInputObjectSchema.optional(), _avg: ServiceLineAvgAggregateInputObjectSchema.optional(), _sum: ServiceLineSumAggregateInputObjectSchema.optional() }).strict() as unknown as z.ZodType<Prisma.ServiceLineAggregateArgs>;
+
+export const ServiceLineAggregateZodSchema = z.object({ orderBy: z.union([ServiceLineOrderByWithRelationInputObjectSchema, ServiceLineOrderByWithRelationInputObjectSchema.array()]).optional(), where: ServiceLineWhereInputObjectSchema.optional(), cursor: ServiceLineWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), _count: z.union([ z.literal(true), ServiceLineCountAggregateInputObjectSchema ]).optional(), _min: ServiceLineMinAggregateInputObjectSchema.optional(), _max: ServiceLineMaxAggregateInputObjectSchema.optional(), _avg: ServiceLineAvgAggregateInputObjectSchema.optional(), _sum: ServiceLineSumAggregateInputObjectSchema.optional() }).strict();

packages/db/shared/schemas/aggregateServiceLineTransaction.schema.d.ts

@@ -0,0 +1,38 @@
+import type { Prisma } from '../../generated/prisma';
+import * as z from 'zod';
+export declare const ServiceLineTransactionAggregateSchema: z.ZodType<Prisma.ServiceLineTransactionAggregateArgs>;
+export declare const ServiceLineTransactionAggregateZodSchema: z.ZodObject<{
+    orderBy: z.ZodOptional<z.ZodUnion<[z.ZodType<Prisma.ServiceLineTransactionOrderByWithRelationInput, z.ZodTypeDef, Prisma.ServiceLineTransactionOrderByWithRelationInput>, z.ZodArray<z.ZodType<Prisma.ServiceLineTransactionOrderByWithRelationInput, z.ZodTypeDef, Prisma.ServiceLineTransactionOrderByWithRelationInput>, "many">]>>;
+    where: z.ZodOptional<z.ZodType<Prisma.ServiceLineTransactionWhereInput, z.ZodTypeDef, Prisma.ServiceLineTransactionWhereInput>>;
+    cursor: z.ZodOptional<z.ZodType<Prisma.ServiceLineTransactionWhereUniqueInput, z.ZodTypeDef, Prisma.ServiceLineTransactionWhereUniqueInput>>;
+    take: z.ZodOptional<z.ZodNumber>;
+    skip: z.ZodOptional<z.ZodNumber>;
+    _count: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<true>, z.ZodType<Prisma.ServiceLineTransactionCountAggregateInputType, z.ZodTypeDef, Prisma.ServiceLineTransactionCountAggregateInputType>]>>;
+    _min: z.ZodOptional<z.ZodType<Prisma.ServiceLineTransactionMinAggregateInputType, z.ZodTypeDef, Prisma.ServiceLineTransactionMinAggregateInputType>>;
+    _max: z.ZodOptional<z.ZodType<Prisma.ServiceLineTransactionMaxAggregateInputType, z.ZodTypeDef, Prisma.ServiceLineTransactionMaxAggregateInputType>>;
+    _avg: z.ZodOptional<z.ZodType<Prisma.ServiceLineTransactionAvgAggregateInputType, z.ZodTypeDef, Prisma.ServiceLineTransactionAvgAggregateInputType>>;
+    _sum: z.ZodOptional<z.ZodType<Prisma.ServiceLineTransactionSumAggregateInputType, z.ZodTypeDef, Prisma.ServiceLineTransactionSumAggregateInputType>>;
+}, "strict", z.ZodTypeAny, {
+    where?: Prisma.ServiceLineTransactionWhereInput | undefined;
+    _count?: true | Prisma.ServiceLineTransactionCountAggregateInputType | undefined;
+    orderBy?: Prisma.ServiceLineTransactionOrderByWithRelationInput | Prisma.ServiceLineTransactionOrderByWithRelationInput[] | undefined;
+    cursor?: Prisma.ServiceLineTransactionWhereUniqueInput | undefined;
+    take?: number | undefined;
+    skip?: number | undefined;
+    _min?: Prisma.ServiceLineTransactionMinAggregateInputType | undefined;
+    _max?: Prisma.ServiceLineTransactionMaxAggregateInputType | undefined;
+    _avg?: Prisma.ServiceLineTransactionAvgAggregateInputType | undefined;
+    _sum?: Prisma.ServiceLineTransactionSumAggregateInputType | undefined;
+}, {
+    where?: Prisma.ServiceLineTransactionWhereInput | undefined;
+    _count?: true | Prisma.ServiceLineTransactionCountAggregateInputType | undefined;
+    orderBy?: Prisma.ServiceLineTransactionOrderByWithRelationInput | Prisma.ServiceLineTransactionOrderByWithRelationInput[] | undefined;
+    cursor?: Prisma.ServiceLineTransactionWhereUniqueInput | undefined;
+    take?: number | undefined;
+    skip?: number | undefined;
+    _min?: Prisma.ServiceLineTransactionMinAggregateInputType | undefined;
+    _max?: Prisma.ServiceLineTransactionMaxAggregateInputType | undefined;
+    _avg?: Prisma.ServiceLineTransactionAvgAggregateInputType | undefined;
+    _sum?: Prisma.ServiceLineTransactionSumAggregateInputType | undefined;
+}>;
+//# sourceMappingURL=aggregateServiceLineTransaction.schema.d.ts.map

packages/db/shared/schemas/aggregateServiceLineTransaction.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aggregateServiceLineTransaction.schema.d.ts","sourceRoot":"","sources":["aggregateServiceLineTransaction.schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAUzB,eAAO,MAAM,qCAAqC,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,mCAAmC,CAA6zB,CAAC;AAEt6B,eAAO,MAAM,wCAAwC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAwvB,CAAC"}

packages/db/shared/schemas/aggregateServiceLineTransaction.schema.js

@@ -0,0 +1,47 @@
+"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.ServiceLineTransactionAggregateZodSchema = exports.ServiceLineTransactionAggregateSchema = void 0;
+const z = __importStar(require("zod"));
+const ServiceLineTransactionOrderByWithRelationInput_schema_1 = require("./objects/ServiceLineTransactionOrderByWithRelationInput.schema");
+const ServiceLineTransactionWhereInput_schema_1 = require("./objects/ServiceLineTransactionWhereInput.schema");
+const ServiceLineTransactionWhereUniqueInput_schema_1 = require("./objects/ServiceLineTransactionWhereUniqueInput.schema");
+const ServiceLineTransactionCountAggregateInput_schema_1 = require("./objects/ServiceLineTransactionCountAggregateInput.schema");
+const ServiceLineTransactionMinAggregateInput_schema_1 = require("./objects/ServiceLineTransactionMinAggregateInput.schema");
+const ServiceLineTransactionMaxAggregateInput_schema_1 = require("./objects/ServiceLineTransactionMaxAggregateInput.schema");
+const ServiceLineTransactionAvgAggregateInput_schema_1 = require("./objects/ServiceLineTransactionAvgAggregateInput.schema");
+const ServiceLineTransactionSumAggregateInput_schema_1 = require("./objects/ServiceLineTransactionSumAggregateInput.schema");
+exports.ServiceLineTransactionAggregateSchema = z.object({ orderBy: z.union([ServiceLineTransactionOrderByWithRelationInput_schema_1.ServiceLineTransactionOrderByWithRelationInputObjectSchema, ServiceLineTransactionOrderByWithRelationInput_schema_1.ServiceLineTransactionOrderByWithRelationInputObjectSchema.array()]).optional(), where: ServiceLineTransactionWhereInput_schema_1.ServiceLineTransactionWhereInputObjectSchema.optional(), cursor: ServiceLineTransactionWhereUniqueInput_schema_1.ServiceLineTransactionWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), _count: z.union([z.literal(true), ServiceLineTransactionCountAggregateInput_schema_1.ServiceLineTransactionCountAggregateInputObjectSchema]).optional(), _min: ServiceLineTransactionMinAggregateInput_schema_1.ServiceLineTransactionMinAggregateInputObjectSchema.optional(), _max: ServiceLineTransactionMaxAggregateInput_schema_1.ServiceLineTransactionMaxAggregateInputObjectSchema.optional(), _avg: ServiceLineTransactionAvgAggregateInput_schema_1.ServiceLineTransactionAvgAggregateInputObjectSchema.optional(), _sum: ServiceLineTransactionSumAggregateInput_schema_1.ServiceLineTransactionSumAggregateInputObjectSchema.optional() }).strict();
+exports.ServiceLineTransactionAggregateZodSchema = z.object({ orderBy: z.union([ServiceLineTransactionOrderByWithRelationInput_schema_1.ServiceLineTransactionOrderByWithRelationInputObjectSchema, ServiceLineTransactionOrderByWithRelationInput_schema_1.ServiceLineTransactionOrderByWithRelationInputObjectSchema.array()]).optional(), where: ServiceLineTransactionWhereInput_schema_1.ServiceLineTransactionWhereInputObjectSchema.optional(), cursor: ServiceLineTransactionWhereUniqueInput_schema_1.ServiceLineTransactionWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), _count: z.union([z.literal(true), ServiceLineTransactionCountAggregateInput_schema_1.ServiceLineTransactionCountAggregateInputObjectSchema]).optional(), _min: ServiceLineTransactionMinAggregateInput_schema_1.ServiceLineTransactionMinAggregateInputObjectSchema.optional(), _max: ServiceLineTransactionMaxAggregateInput_schema_1.ServiceLineTransactionMaxAggregateInputObjectSchema.optional(), _avg: ServiceLineTransactionAvgAggregateInput_schema_1.ServiceLineTransactionAvgAggregateInputObjectSchema.optional(), _sum: ServiceLineTransactionSumAggregateInput_schema_1.ServiceLineTransactionSumAggregateInputObjectSchema.optional() }).strict();

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

@@ -0,0 +1,14 @@
+import type { Prisma } from '../../generated/prisma';
+import * as z from 'zod';
+import { ServiceLineTransactionOrderByWithRelationInputObjectSchema as ServiceLineTransactionOrderByWithRelationInputObjectSchema } from './objects/ServiceLineTransactionOrderByWithRelationInput.schema';
+import { ServiceLineTransactionWhereInputObjectSchema as ServiceLineTransactionWhereInputObjectSchema } from './objects/ServiceLineTransactionWhereInput.schema';
+import { ServiceLineTransactionWhereUniqueInputObjectSchema as ServiceLineTransactionWhereUniqueInputObjectSchema } from './objects/ServiceLineTransactionWhereUniqueInput.schema';
+import { ServiceLineTransactionCountAggregateInputObjectSchema as ServiceLineTransactionCountAggregateInputObjectSchema } from './objects/ServiceLineTransactionCountAggregateInput.schema';
+import { ServiceLineTransactionMinAggregateInputObjectSchema as ServiceLineTransactionMinAggregateInputObjectSchema } from './objects/ServiceLineTransactionMinAggregateInput.schema';
+import { ServiceLineTransactionMaxAggregateInputObjectSchema as ServiceLineTransactionMaxAggregateInputObjectSchema } from './objects/ServiceLineTransactionMaxAggregateInput.schema';
+import { ServiceLineTransactionAvgAggregateInputObjectSchema as ServiceLineTransactionAvgAggregateInputObjectSchema } from './objects/ServiceLineTransactionAvgAggregateInput.schema';
+import { ServiceLineTransactionSumAggregateInputObjectSchema as ServiceLineTransactionSumAggregateInputObjectSchema } from './objects/ServiceLineTransactionSumAggregateInput.schema';
+
+export const ServiceLineTransactionAggregateSchema: z.ZodType<Prisma.ServiceLineTransactionAggregateArgs> = z.object({ orderBy: z.union([ServiceLineTransactionOrderByWithRelationInputObjectSchema, ServiceLineTransactionOrderByWithRelationInputObjectSchema.array()]).optional(), where: ServiceLineTransactionWhereInputObjectSchema.optional(), cursor: ServiceLineTransactionWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), _count: z.union([ z.literal(true), ServiceLineTransactionCountAggregateInputObjectSchema ]).optional(), _min: ServiceLineTransactionMinAggregateInputObjectSchema.optional(), _max: ServiceLineTransactionMaxAggregateInputObjectSchema.optional(), _avg: ServiceLineTransactionAvgAggregateInputObjectSchema.optional(), _sum: ServiceLineTransactionSumAggregateInputObjectSchema.optional() }).strict() as unknown as z.ZodType<Prisma.ServiceLineTransactionAggregateArgs>;
+
+export const ServiceLineTransactionAggregateZodSchema = z.object({ orderBy: z.union([ServiceLineTransactionOrderByWithRelationInputObjectSchema, ServiceLineTransactionOrderByWithRelationInputObjectSchema.array()]).optional(), where: ServiceLineTransactionWhereInputObjectSchema.optional(), cursor: ServiceLineTransactionWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), _count: z.union([ z.literal(true), ServiceLineTransactionCountAggregateInputObjectSchema ]).optional(), _min: ServiceLineTransactionMinAggregateInputObjectSchema.optional(), _max: ServiceLineTransactionMaxAggregateInputObjectSchema.optional(), _avg: ServiceLineTransactionAvgAggregateInputObjectSchema.optional(), _sum: ServiceLineTransactionSumAggregateInputObjectSchema.optional() }).strict();

packages/db/shared/schemas/aggregateStaff.schema.d.ts

@@ -0,0 +1,38 @@
+import type { Prisma } from '../../generated/prisma';
+import * as z from 'zod';
+export declare const StaffAggregateSchema: z.ZodType<Prisma.StaffAggregateArgs>;
+export declare const StaffAggregateZodSchema: z.ZodObject<{
+    orderBy: z.ZodOptional<z.ZodUnion<[z.ZodType<Prisma.StaffOrderByWithRelationInput, z.ZodTypeDef, Prisma.StaffOrderByWithRelationInput>, z.ZodArray<z.ZodType<Prisma.StaffOrderByWithRelationInput, z.ZodTypeDef, Prisma.StaffOrderByWithRelationInput>, "many">]>>;
+    where: z.ZodOptional<z.ZodType<Prisma.StaffWhereInput, z.ZodTypeDef, Prisma.StaffWhereInput>>;
+    cursor: z.ZodOptional<z.ZodType<Prisma.StaffWhereUniqueInput, z.ZodTypeDef, Prisma.StaffWhereUniqueInput>>;
+    take: z.ZodOptional<z.ZodNumber>;
+    skip: z.ZodOptional<z.ZodNumber>;
+    _count: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<true>, z.ZodType<Prisma.StaffCountAggregateInputType, z.ZodTypeDef, Prisma.StaffCountAggregateInputType>]>>;
+    _min: z.ZodOptional<z.ZodType<Prisma.StaffMinAggregateInputType, z.ZodTypeDef, Prisma.StaffMinAggregateInputType>>;
+    _max: z.ZodOptional<z.ZodType<Prisma.StaffMaxAggregateInputType, z.ZodTypeDef, Prisma.StaffMaxAggregateInputType>>;
+    _avg: z.ZodOptional<z.ZodType<Prisma.StaffAvgAggregateInputType, z.ZodTypeDef, Prisma.StaffAvgAggregateInputType>>;
+    _sum: z.ZodOptional<z.ZodType<Prisma.StaffSumAggregateInputType, z.ZodTypeDef, Prisma.StaffSumAggregateInputType>>;
+}, "strict", z.ZodTypeAny, {
+    where?: Prisma.StaffWhereInput | undefined;
+    _count?: true | Prisma.StaffCountAggregateInputType | undefined;
+    orderBy?: Prisma.StaffOrderByWithRelationInput | Prisma.StaffOrderByWithRelationInput[] | undefined;
+    cursor?: Prisma.StaffWhereUniqueInput | undefined;
+    take?: number | undefined;
+    skip?: number | undefined;
+    _min?: Prisma.StaffMinAggregateInputType | undefined;
+    _max?: Prisma.StaffMaxAggregateInputType | undefined;
+    _avg?: Prisma.StaffAvgAggregateInputType | undefined;
+    _sum?: Prisma.StaffSumAggregateInputType | undefined;
+}, {
+    where?: Prisma.StaffWhereInput | undefined;
+    _count?: true | Prisma.StaffCountAggregateInputType | undefined;
+    orderBy?: Prisma.StaffOrderByWithRelationInput | Prisma.StaffOrderByWithRelationInput[] | undefined;
+    cursor?: Prisma.StaffWhereUniqueInput | undefined;
+    take?: number | undefined;
+    skip?: number | undefined;
+    _min?: Prisma.StaffMinAggregateInputType | undefined;
+    _max?: Prisma.StaffMaxAggregateInputType | undefined;
+    _avg?: Prisma.StaffAvgAggregateInputType | undefined;
+    _sum?: Prisma.StaffSumAggregateInputType | undefined;
+}>;
+//# sourceMappingURL=aggregateStaff.schema.d.ts.map

packages/db/shared/schemas/aggregateStaff.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aggregateStaff.schema.d.ts","sourceRoot":"","sources":["aggregateStaff.schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAUzB,eAAO,MAAM,oBAAoB,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,kBAAkB,CAAmpB,CAAC;AAE1tB,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAA+lB,CAAC"}

packages/db/shared/schemas/aggregateStaff.schema.js

@@ -0,0 +1,47 @@
+"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.StaffAggregateZodSchema = exports.StaffAggregateSchema = void 0;
+const z = __importStar(require("zod"));
+const StaffOrderByWithRelationInput_schema_1 = require("./objects/StaffOrderByWithRelationInput.schema");
+const StaffWhereInput_schema_1 = require("./objects/StaffWhereInput.schema");
+const StaffWhereUniqueInput_schema_1 = require("./objects/StaffWhereUniqueInput.schema");
+const StaffCountAggregateInput_schema_1 = require("./objects/StaffCountAggregateInput.schema");
+const StaffMinAggregateInput_schema_1 = require("./objects/StaffMinAggregateInput.schema");
+const StaffMaxAggregateInput_schema_1 = require("./objects/StaffMaxAggregateInput.schema");
+const StaffAvgAggregateInput_schema_1 = require("./objects/StaffAvgAggregateInput.schema");
+const StaffSumAggregateInput_schema_1 = require("./objects/StaffSumAggregateInput.schema");
+exports.StaffAggregateSchema = z.object({ orderBy: z.union([StaffOrderByWithRelationInput_schema_1.StaffOrderByWithRelationInputObjectSchema, StaffOrderByWithRelationInput_schema_1.StaffOrderByWithRelationInputObjectSchema.array()]).optional(), where: StaffWhereInput_schema_1.StaffWhereInputObjectSchema.optional(), cursor: StaffWhereUniqueInput_schema_1.StaffWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), _count: z.union([z.literal(true), StaffCountAggregateInput_schema_1.StaffCountAggregateInputObjectSchema]).optional(), _min: StaffMinAggregateInput_schema_1.StaffMinAggregateInputObjectSchema.optional(), _max: StaffMaxAggregateInput_schema_1.StaffMaxAggregateInputObjectSchema.optional(), _avg: StaffAvgAggregateInput_schema_1.StaffAvgAggregateInputObjectSchema.optional(), _sum: StaffSumAggregateInput_schema_1.StaffSumAggregateInputObjectSchema.optional() }).strict();
+exports.StaffAggregateZodSchema = z.object({ orderBy: z.union([StaffOrderByWithRelationInput_schema_1.StaffOrderByWithRelationInputObjectSchema, StaffOrderByWithRelationInput_schema_1.StaffOrderByWithRelationInputObjectSchema.array()]).optional(), where: StaffWhereInput_schema_1.StaffWhereInputObjectSchema.optional(), cursor: StaffWhereUniqueInput_schema_1.StaffWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), _count: z.union([z.literal(true), StaffCountAggregateInput_schema_1.StaffCountAggregateInputObjectSchema]).optional(), _min: StaffMinAggregateInput_schema_1.StaffMinAggregateInputObjectSchema.optional(), _max: StaffMaxAggregateInput_schema_1.StaffMaxAggregateInputObjectSchema.optional(), _avg: StaffAvgAggregateInput_schema_1.StaffAvgAggregateInputObjectSchema.optional(), _sum: StaffSumAggregateInput_schema_1.StaffSumAggregateInputObjectSchema.optional() }).strict();

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

@@ -0,0 +1,14 @@
+import type { Prisma } from '../../generated/prisma';
+import * as z from 'zod';
+import { StaffOrderByWithRelationInputObjectSchema as StaffOrderByWithRelationInputObjectSchema } from './objects/StaffOrderByWithRelationInput.schema';
+import { StaffWhereInputObjectSchema as StaffWhereInputObjectSchema } from './objects/StaffWhereInput.schema';
+import { StaffWhereUniqueInputObjectSchema as StaffWhereUniqueInputObjectSchema } from './objects/StaffWhereUniqueInput.schema';
+import { StaffCountAggregateInputObjectSchema as StaffCountAggregateInputObjectSchema } from './objects/StaffCountAggregateInput.schema';
+import { StaffMinAggregateInputObjectSchema as StaffMinAggregateInputObjectSchema } from './objects/StaffMinAggregateInput.schema';
+import { StaffMaxAggregateInputObjectSchema as StaffMaxAggregateInputObjectSchema } from './objects/StaffMaxAggregateInput.schema';
+import { StaffAvgAggregateInputObjectSchema as StaffAvgAggregateInputObjectSchema } from './objects/StaffAvgAggregateInput.schema';
+import { StaffSumAggregateInputObjectSchema as StaffSumAggregateInputObjectSchema } from './objects/StaffSumAggregateInput.schema';
+
+export const StaffAggregateSchema: z.ZodType<Prisma.StaffAggregateArgs> = z.object({ orderBy: z.union([StaffOrderByWithRelationInputObjectSchema, StaffOrderByWithRelationInputObjectSchema.array()]).optional(), where: StaffWhereInputObjectSchema.optional(), cursor: StaffWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), _count: z.union([ z.literal(true), StaffCountAggregateInputObjectSchema ]).optional(), _min: StaffMinAggregateInputObjectSchema.optional(), _max: StaffMaxAggregateInputObjectSchema.optional(), _avg: StaffAvgAggregateInputObjectSchema.optional(), _sum: StaffSumAggregateInputObjectSchema.optional() }).strict() as unknown as z.ZodType<Prisma.StaffAggregateArgs>;
+
+export const StaffAggregateZodSchema = z.object({ orderBy: z.union([StaffOrderByWithRelationInputObjectSchema, StaffOrderByWithRelationInputObjectSchema.array()]).optional(), where: StaffWhereInputObjectSchema.optional(), cursor: StaffWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), _count: z.union([ z.literal(true), StaffCountAggregateInputObjectSchema ]).optional(), _min: StaffMinAggregateInputObjectSchema.optional(), _max: StaffMaxAggregateInputObjectSchema.optional(), _avg: StaffAvgAggregateInputObjectSchema.optional(), _sum: StaffSumAggregateInputObjectSchema.optional() }).strict();

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

@@ -0,0 +1,38 @@
+import type { Prisma } from '../../generated/prisma';
+import * as z from 'zod';
+export declare const UserAggregateSchema: z.ZodType<Prisma.UserAggregateArgs>;
+export declare const UserAggregateZodSchema: z.ZodObject<{
+    orderBy: z.ZodOptional<z.ZodUnion<[z.ZodType<Prisma.UserOrderByWithRelationInput, z.ZodTypeDef, Prisma.UserOrderByWithRelationInput>, z.ZodArray<z.ZodType<Prisma.UserOrderByWithRelationInput, z.ZodTypeDef, Prisma.UserOrderByWithRelationInput>, "many">]>>;
+    where: z.ZodOptional<z.ZodType<Prisma.UserWhereInput, z.ZodTypeDef, Prisma.UserWhereInput>>;
+    cursor: z.ZodOptional<z.ZodType<Prisma.UserWhereUniqueInput, z.ZodTypeDef, Prisma.UserWhereUniqueInput>>;
+    take: z.ZodOptional<z.ZodNumber>;
+    skip: z.ZodOptional<z.ZodNumber>;
+    _count: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<true>, z.ZodType<Prisma.UserCountAggregateInputType, z.ZodTypeDef, Prisma.UserCountAggregateInputType>]>>;
+    _min: z.ZodOptional<z.ZodType<Prisma.UserMinAggregateInputType, z.ZodTypeDef, Prisma.UserMinAggregateInputType>>;
+    _max: z.ZodOptional<z.ZodType<Prisma.UserMaxAggregateInputType, z.ZodTypeDef, Prisma.UserMaxAggregateInputType>>;
+    _avg: z.ZodOptional<z.ZodType<Prisma.UserAvgAggregateInputType, z.ZodTypeDef, Prisma.UserAvgAggregateInputType>>;
+    _sum: z.ZodOptional<z.ZodType<Prisma.UserSumAggregateInputType, z.ZodTypeDef, Prisma.UserSumAggregateInputType>>;
+}, "strict", z.ZodTypeAny, {
+    where?: Prisma.UserWhereInput | undefined;
+    _count?: true | Prisma.UserCountAggregateInputType | undefined;
+    orderBy?: Prisma.UserOrderByWithRelationInput | Prisma.UserOrderByWithRelationInput[] | undefined;
+    cursor?: Prisma.UserWhereUniqueInput | undefined;
+    take?: number | undefined;
+    skip?: number | undefined;
+    _min?: Prisma.UserMinAggregateInputType | undefined;
+    _max?: Prisma.UserMaxAggregateInputType | undefined;
+    _avg?: Prisma.UserAvgAggregateInputType | undefined;
+    _sum?: Prisma.UserSumAggregateInputType | undefined;
+}, {
+    where?: Prisma.UserWhereInput | undefined;
+    _count?: true | Prisma.UserCountAggregateInputType | undefined;
+    orderBy?: Prisma.UserOrderByWithRelationInput | Prisma.UserOrderByWithRelationInput[] | undefined;
+    cursor?: Prisma.UserWhereUniqueInput | undefined;
+    take?: number | undefined;
+    skip?: number | undefined;
+    _min?: Prisma.UserMinAggregateInputType | undefined;
+    _max?: Prisma.UserMaxAggregateInputType | undefined;
+    _avg?: Prisma.UserAvgAggregateInputType | undefined;
+    _sum?: Prisma.UserSumAggregateInputType | undefined;
+}>;
+//# sourceMappingURL=aggregateUser.schema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"aggregateUser.schema.d.ts","sourceRoot":"","sources":["aggregateUser.schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAUzB,eAAO,MAAM,mBAAmB,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,iBAAiB,CAAyoB,CAAC;AAE9sB,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAslB,CAAC"}

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

@@ -0,0 +1,47 @@
+"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.UserAggregateZodSchema = exports.UserAggregateSchema = void 0;
+const z = __importStar(require("zod"));
+const UserOrderByWithRelationInput_schema_1 = require("./objects/UserOrderByWithRelationInput.schema");
+const UserWhereInput_schema_1 = require("./objects/UserWhereInput.schema");
+const UserWhereUniqueInput_schema_1 = require("./objects/UserWhereUniqueInput.schema");
+const UserCountAggregateInput_schema_1 = require("./objects/UserCountAggregateInput.schema");
+const UserMinAggregateInput_schema_1 = require("./objects/UserMinAggregateInput.schema");
+const UserMaxAggregateInput_schema_1 = require("./objects/UserMaxAggregateInput.schema");
+const UserAvgAggregateInput_schema_1 = require("./objects/UserAvgAggregateInput.schema");
+const UserSumAggregateInput_schema_1 = require("./objects/UserSumAggregateInput.schema");
+exports.UserAggregateSchema = z.object({ orderBy: z.union([UserOrderByWithRelationInput_schema_1.UserOrderByWithRelationInputObjectSchema, UserOrderByWithRelationInput_schema_1.UserOrderByWithRelationInputObjectSchema.array()]).optional(), where: UserWhereInput_schema_1.UserWhereInputObjectSchema.optional(), cursor: UserWhereUniqueInput_schema_1.UserWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), _count: z.union([z.literal(true), UserCountAggregateInput_schema_1.UserCountAggregateInputObjectSchema]).optional(), _min: UserMinAggregateInput_schema_1.UserMinAggregateInputObjectSchema.optional(), _max: UserMaxAggregateInput_schema_1.UserMaxAggregateInputObjectSchema.optional(), _avg: UserAvgAggregateInput_schema_1.UserAvgAggregateInputObjectSchema.optional(), _sum: UserSumAggregateInput_schema_1.UserSumAggregateInputObjectSchema.optional() }).strict();
+exports.UserAggregateZodSchema = z.object({ orderBy: z.union([UserOrderByWithRelationInput_schema_1.UserOrderByWithRelationInputObjectSchema, UserOrderByWithRelationInput_schema_1.UserOrderByWithRelationInputObjectSchema.array()]).optional(), where: UserWhereInput_schema_1.UserWhereInputObjectSchema.optional(), cursor: UserWhereUniqueInput_schema_1.UserWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), _count: z.union([z.literal(true), UserCountAggregateInput_schema_1.UserCountAggregateInputObjectSchema]).optional(), _min: UserMinAggregateInput_schema_1.UserMinAggregateInputObjectSchema.optional(), _max: UserMaxAggregateInput_schema_1.UserMaxAggregateInputObjectSchema.optional(), _avg: UserAvgAggregateInput_schema_1.UserAvgAggregateInputObjectSchema.optional(), _sum: UserSumAggregateInput_schema_1.UserSumAggregateInputObjectSchema.optional() }).strict();

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

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

packages/db/shared/schemas/countAppointment.schema.d.ts

@@ -0,0 +1,26 @@
+import type { Prisma } from '../../generated/prisma';
+import * as z from 'zod';
+export declare const AppointmentCountSchema: z.ZodType<Prisma.AppointmentCountArgs>;
+export declare const AppointmentCountZodSchema: z.ZodObject<{
+    orderBy: z.ZodOptional<z.ZodUnion<[z.ZodType<Prisma.AppointmentOrderByWithRelationInput, z.ZodTypeDef, Prisma.AppointmentOrderByWithRelationInput>, z.ZodArray<z.ZodType<Prisma.AppointmentOrderByWithRelationInput, z.ZodTypeDef, Prisma.AppointmentOrderByWithRelationInput>, "many">]>>;
+    where: z.ZodOptional<z.ZodType<Prisma.AppointmentWhereInput, z.ZodTypeDef, Prisma.AppointmentWhereInput>>;
+    cursor: z.ZodOptional<z.ZodType<Prisma.AppointmentWhereUniqueInput, z.ZodTypeDef, Prisma.AppointmentWhereUniqueInput>>;
+    take: z.ZodOptional<z.ZodNumber>;
+    skip: z.ZodOptional<z.ZodNumber>;
+    select: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<true>, z.ZodType<Prisma.AppointmentCountAggregateInputType, z.ZodTypeDef, Prisma.AppointmentCountAggregateInputType>]>>;
+}, "strict", z.ZodTypeAny, {
+    where?: Prisma.AppointmentWhereInput | undefined;
+    select?: true | Prisma.AppointmentCountAggregateInputType | undefined;
+    orderBy?: Prisma.AppointmentOrderByWithRelationInput | Prisma.AppointmentOrderByWithRelationInput[] | undefined;
+    cursor?: Prisma.AppointmentWhereUniqueInput | undefined;
+    take?: number | undefined;
+    skip?: number | undefined;
+}, {
+    where?: Prisma.AppointmentWhereInput | undefined;
+    select?: true | Prisma.AppointmentCountAggregateInputType | undefined;
+    orderBy?: Prisma.AppointmentOrderByWithRelationInput | Prisma.AppointmentOrderByWithRelationInput[] | undefined;
+    cursor?: Prisma.AppointmentWhereUniqueInput | undefined;
+    take?: number | undefined;
+    skip?: number | undefined;
+}>;
+//# sourceMappingURL=countAppointment.schema.d.ts.map

packages/db/shared/schemas/countAppointment.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"countAppointment.schema.d.ts","sourceRoot":"","sources":["countAppointment.schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAMzB,eAAO,MAAM,sBAAsB,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,oBAAoB,CAA+d,CAAC;AAE1iB,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;EAAya,CAAC"}

packages/db/shared/schemas/countAppointment.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.AppointmentCountZodSchema = exports.AppointmentCountSchema = void 0;
+const z = __importStar(require("zod"));
+const AppointmentOrderByWithRelationInput_schema_1 = require("./objects/AppointmentOrderByWithRelationInput.schema");
+const AppointmentWhereInput_schema_1 = require("./objects/AppointmentWhereInput.schema");
+const AppointmentWhereUniqueInput_schema_1 = require("./objects/AppointmentWhereUniqueInput.schema");
+const AppointmentCountAggregateInput_schema_1 = require("./objects/AppointmentCountAggregateInput.schema");
+exports.AppointmentCountSchema = z.object({ orderBy: z.union([AppointmentOrderByWithRelationInput_schema_1.AppointmentOrderByWithRelationInputObjectSchema, AppointmentOrderByWithRelationInput_schema_1.AppointmentOrderByWithRelationInputObjectSchema.array()]).optional(), where: AppointmentWhereInput_schema_1.AppointmentWhereInputObjectSchema.optional(), cursor: AppointmentWhereUniqueInput_schema_1.AppointmentWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), select: z.union([z.literal(true), AppointmentCountAggregateInput_schema_1.AppointmentCountAggregateInputObjectSchema]).optional() }).strict();
+exports.AppointmentCountZodSchema = z.object({ orderBy: z.union([AppointmentOrderByWithRelationInput_schema_1.AppointmentOrderByWithRelationInputObjectSchema, AppointmentOrderByWithRelationInput_schema_1.AppointmentOrderByWithRelationInputObjectSchema.array()]).optional(), where: AppointmentWhereInput_schema_1.AppointmentWhereInputObjectSchema.optional(), cursor: AppointmentWhereUniqueInput_schema_1.AppointmentWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), select: z.union([z.literal(true), AppointmentCountAggregateInput_schema_1.AppointmentCountAggregateInputObjectSchema]).optional() }).strict();