Enable zod-prisma-types createInputTypes

package.json

@@ -24,5 +24,8 @@
   "lint-staged": {
     "{desktop,server,jobrunner,utility}/*.{js,jsx,ts,tsx}": "eslint --fix",
     "*": "prettier --ignore-unknown --write"
+  },
+  "resolutions": {
+    "zod": "<=3.21.1"
   }
 }

utility/prisma/schema.prisma

@@ -11,7 +11,7 @@ generator zod {
   output           = "./types"
   useMultipleFiles = true
   writeBarrelFiles = true
-  createInputTypes = false
+  createInputTypes = true
   addIncludeType   = false
   addSelectType    = false
 }

utility/prisma/types/index.ts

@@ -1,2 +1,3 @@
-export * from './modelSchema';
-export * from './inputTypeSchemas';
+export * from "./modelSchema";
+export * from "./inputTypeSchemas";
+export * from "./outputTypeSchemas";

utility/prisma/types/inputTypeSchemas/AssetAvgOrderByAggregateInputSchema.ts

@@ -0,0 +1,14 @@
+import type { Prisma } from "../../client";
+import { z } from "zod";
+import { SortOrderSchema } from "./SortOrderSchema";
+
+export const AssetAvgOrderByAggregateInputSchema: z.ZodType<Prisma.AssetAvgOrderByAggregateInput> =
+  z
+    .object({
+      id: z.lazy(() => SortOrderSchema).optional(),
+      rundownId: z.lazy(() => SortOrderSchema).optional(),
+      mediaId: z.lazy(() => SortOrderSchema).optional(),
+    })
+    .strict();
+
+export default AssetAvgOrderByAggregateInputSchema;

utility/prisma/types/inputTypeSchemas/AssetCountOrderByAggregateInputSchema.ts

@@ -0,0 +1,16 @@
+import type { Prisma } from "../../client";
+import { z } from "zod";
+import { SortOrderSchema } from "./SortOrderSchema";
+
+export const AssetCountOrderByAggregateInputSchema: z.ZodType<Prisma.AssetCountOrderByAggregateInput> =
+  z
+    .object({
+      id: z.lazy(() => SortOrderSchema).optional(),
+      name: z.lazy(() => SortOrderSchema).optional(),
+      type: z.lazy(() => SortOrderSchema).optional(),
+      rundownId: z.lazy(() => SortOrderSchema).optional(),
+      mediaId: z.lazy(() => SortOrderSchema).optional(),
+    })
+    .strict();
+
+export default AssetCountOrderByAggregateInputSchema;

utility/prisma/types/inputTypeSchemas/AssetCreateInputSchema.ts

@@ -0,0 +1,20 @@
+import type { Prisma } from "../../client";
+import { z } from "zod";
+import { AssetTypeSchema } from "./AssetTypeSchema";
+import { MediaCreateNestedOneWithoutAssetInputSchema } from "./MediaCreateNestedOneWithoutAssetInputSchema";
+import { RundownCreateNestedOneWithoutAssetsInputSchema } from "./RundownCreateNestedOneWithoutAssetsInputSchema";
+import { LoadAssetJobCreateNestedManyWithoutAssetInputSchema } from "./LoadAssetJobCreateNestedManyWithoutAssetInputSchema";
+
+export const AssetCreateInputSchema: z.ZodType<Prisma.AssetCreateInput> = z
+  .object({
+    name: z.string(),
+    type: z.lazy(() => AssetTypeSchema),
+    media: z.lazy(() => MediaCreateNestedOneWithoutAssetInputSchema),
+    rundown: z.lazy(() => RundownCreateNestedOneWithoutAssetsInputSchema),
+    loadJobs: z
+      .lazy(() => LoadAssetJobCreateNestedManyWithoutAssetInputSchema)
+      .optional(),
+  })
+  .strict();
+
+export default AssetCreateInputSchema;

utility/prisma/types/inputTypeSchemas/AssetCreateManyInputSchema.ts

@@ -0,0 +1,16 @@
+import type { Prisma } from "../../client";
+import { z } from "zod";
+import { AssetTypeSchema } from "./AssetTypeSchema";
+
+export const AssetCreateManyInputSchema: z.ZodType<Prisma.AssetCreateManyInput> =
+  z
+    .object({
+      id: z.number().int().optional(),
+      name: z.string(),
+      type: z.lazy(() => AssetTypeSchema),
+      rundownId: z.number().int(),
+      mediaId: z.number().int(),
+    })
+    .strict();
+
+export default AssetCreateManyInputSchema;

utility/prisma/types/inputTypeSchemas/AssetCreateManyRundownInputEnvelopeSchema.ts

@@ -0,0 +1,16 @@
+import type { Prisma } from "../../client";
+import { z } from "zod";
+import { AssetCreateManyRundownInputSchema } from "./AssetCreateManyRundownInputSchema";
+
+export const AssetCreateManyRundownInputEnvelopeSchema: z.ZodType<Prisma.AssetCreateManyRundownInputEnvelope> =
+  z
+    .object({
+      data: z.union([
+        z.lazy(() => AssetCreateManyRundownInputSchema),
+        z.lazy(() => AssetCreateManyRundownInputSchema).array(),
+      ]),
+      skipDuplicates: z.boolean().optional(),
+    })
+    .strict();
+
+export default AssetCreateManyRundownInputEnvelopeSchema;

utility/prisma/types/inputTypeSchemas/AssetCreateManyRundownInputSchema.ts

@@ -0,0 +1,15 @@
+import type { Prisma } from "../../client";
+import { z } from "zod";
+import { AssetTypeSchema } from "./AssetTypeSchema";
+
+export const AssetCreateManyRundownInputSchema: z.ZodType<Prisma.AssetCreateManyRundownInput> =
+  z
+    .object({
+      id: z.number().int().optional(),
+      name: z.string(),
+      type: z.lazy(() => AssetTypeSchema),
+      mediaId: z.number().int(),
+    })
+    .strict();
+
+export default AssetCreateManyRundownInputSchema;

utility/prisma/types/inputTypeSchemas/AssetCreateNestedManyWithoutRundownInputSchema.ts

@@ -0,0 +1,38 @@
+import type { Prisma } from "../../client";
+import { z } from "zod";
+import { AssetCreateWithoutRundownInputSchema } from "./AssetCreateWithoutRundownInputSchema";
+import { AssetUncheckedCreateWithoutRundownInputSchema } from "./AssetUncheckedCreateWithoutRundownInputSchema";
+import { AssetCreateOrConnectWithoutRundownInputSchema } from "./AssetCreateOrConnectWithoutRundownInputSchema";
+import { AssetCreateManyRundownInputEnvelopeSchema } from "./AssetCreateManyRundownInputEnvelopeSchema";
+import { AssetWhereUniqueInputSchema } from "./AssetWhereUniqueInputSchema";
+
+export const AssetCreateNestedManyWithoutRundownInputSchema: z.ZodType<Prisma.AssetCreateNestedManyWithoutRundownInput> =
+  z
+    .object({
+      create: z
+        .union([
+          z.lazy(() => AssetCreateWithoutRundownInputSchema),
+          z.lazy(() => AssetCreateWithoutRundownInputSchema).array(),
+          z.lazy(() => AssetUncheckedCreateWithoutRundownInputSchema),
+          z.lazy(() => AssetUncheckedCreateWithoutRundownInputSchema).array(),
+        ])
+        .optional(),
+      connectOrCreate: z
+        .union([
+          z.lazy(() => AssetCreateOrConnectWithoutRundownInputSchema),
+          z.lazy(() => AssetCreateOrConnectWithoutRundownInputSchema).array(),
+        ])
+        .optional(),
+      createMany: z
+        .lazy(() => AssetCreateManyRundownInputEnvelopeSchema)
+        .optional(),
+      connect: z
+        .union([
+          z.lazy(() => AssetWhereUniqueInputSchema),
+          z.lazy(() => AssetWhereUniqueInputSchema).array(),
+        ])
+        .optional(),
+    })
+    .strict();
+
+export default AssetCreateNestedManyWithoutRundownInputSchema;

utility/prisma/types/inputTypeSchemas/AssetCreateNestedOneWithoutLoadJobsInputSchema.ts

@@ -0,0 +1,24 @@
+import type { Prisma } from "../../client";
+import { z } from "zod";
+import { AssetCreateWithoutLoadJobsInputSchema } from "./AssetCreateWithoutLoadJobsInputSchema";
+import { AssetUncheckedCreateWithoutLoadJobsInputSchema } from "./AssetUncheckedCreateWithoutLoadJobsInputSchema";
+import { AssetCreateOrConnectWithoutLoadJobsInputSchema } from "./AssetCreateOrConnectWithoutLoadJobsInputSchema";
+import { AssetWhereUniqueInputSchema } from "./AssetWhereUniqueInputSchema";
+
+export const AssetCreateNestedOneWithoutLoadJobsInputSchema: z.ZodType<Prisma.AssetCreateNestedOneWithoutLoadJobsInput> =
+  z
+    .object({
+      create: z
+        .union([
+          z.lazy(() => AssetCreateWithoutLoadJobsInputSchema),
+          z.lazy(() => AssetUncheckedCreateWithoutLoadJobsInputSchema),
+        ])
+        .optional(),
+      connectOrCreate: z
+        .lazy(() => AssetCreateOrConnectWithoutLoadJobsInputSchema)
+        .optional(),
+      connect: z.lazy(() => AssetWhereUniqueInputSchema).optional(),
+    })
+    .strict();
+
+export default AssetCreateNestedOneWithoutLoadJobsInputSchema;

utility/prisma/types/inputTypeSchemas/AssetCreateNestedOneWithoutMediaInputSchema.ts

@@ -0,0 +1,24 @@
+import type { Prisma } from "../../client";
+import { z } from "zod";
+import { AssetCreateWithoutMediaInputSchema } from "./AssetCreateWithoutMediaInputSchema";
+import { AssetUncheckedCreateWithoutMediaInputSchema } from "./AssetUncheckedCreateWithoutMediaInputSchema";
+import { AssetCreateOrConnectWithoutMediaInputSchema } from "./AssetCreateOrConnectWithoutMediaInputSchema";
+import { AssetWhereUniqueInputSchema } from "./AssetWhereUniqueInputSchema";
+
+export const AssetCreateNestedOneWithoutMediaInputSchema: z.ZodType<Prisma.AssetCreateNestedOneWithoutMediaInput> =
+  z
+    .object({
+      create: z
+        .union([
+          z.lazy(() => AssetCreateWithoutMediaInputSchema),
+          z.lazy(() => AssetUncheckedCreateWithoutMediaInputSchema),
+        ])
+        .optional(),
+      connectOrCreate: z
+        .lazy(() => AssetCreateOrConnectWithoutMediaInputSchema)
+        .optional(),
+      connect: z.lazy(() => AssetWhereUniqueInputSchema).optional(),
+    })
+    .strict();
+
+export default AssetCreateNestedOneWithoutMediaInputSchema;

utility/prisma/types/inputTypeSchemas/AssetCreateOrConnectWithoutLoadJobsInputSchema.ts

@@ -0,0 +1,18 @@
+import type { Prisma } from "../../client";
+import { z } from "zod";
+import { AssetWhereUniqueInputSchema } from "./AssetWhereUniqueInputSchema";
+import { AssetCreateWithoutLoadJobsInputSchema } from "./AssetCreateWithoutLoadJobsInputSchema";
+import { AssetUncheckedCreateWithoutLoadJobsInputSchema } from "./AssetUncheckedCreateWithoutLoadJobsInputSchema";
+
+export const AssetCreateOrConnectWithoutLoadJobsInputSchema: z.ZodType<Prisma.AssetCreateOrConnectWithoutLoadJobsInput> =
+  z
+    .object({
+      where: z.lazy(() => AssetWhereUniqueInputSchema),
+      create: z.union([
+        z.lazy(() => AssetCreateWithoutLoadJobsInputSchema),
+        z.lazy(() => AssetUncheckedCreateWithoutLoadJobsInputSchema),
+      ]),
+    })
+    .strict();
+
+export default AssetCreateOrConnectWithoutLoadJobsInputSchema;

utility/prisma/types/inputTypeSchemas/AssetCreateOrConnectWithoutMediaInputSchema.ts

@@ -0,0 +1,18 @@
+import type { Prisma } from "../../client";
+import { z } from "zod";
+import { AssetWhereUniqueInputSchema } from "./AssetWhereUniqueInputSchema";
+import { AssetCreateWithoutMediaInputSchema } from "./AssetCreateWithoutMediaInputSchema";
+import { AssetUncheckedCreateWithoutMediaInputSchema } from "./AssetUncheckedCreateWithoutMediaInputSchema";
+
+export const AssetCreateOrConnectWithoutMediaInputSchema: z.ZodType<Prisma.AssetCreateOrConnectWithoutMediaInput> =
+  z
+    .object({
+      where: z.lazy(() => AssetWhereUniqueInputSchema),
+      create: z.union([
+        z.lazy(() => AssetCreateWithoutMediaInputSchema),
+        z.lazy(() => AssetUncheckedCreateWithoutMediaInputSchema),
+      ]),
+    })
+    .strict();
+
+export default AssetCreateOrConnectWithoutMediaInputSchema;

utility/prisma/types/inputTypeSchemas/AssetCreateOrConnectWithoutRundownInputSchema.ts

@@ -0,0 +1,18 @@
+import type { Prisma } from "../../client";
+import { z } from "zod";
+import { AssetWhereUniqueInputSchema } from "./AssetWhereUniqueInputSchema";
+import { AssetCreateWithoutRundownInputSchema } from "./AssetCreateWithoutRundownInputSchema";
+import { AssetUncheckedCreateWithoutRundownInputSchema } from "./AssetUncheckedCreateWithoutRundownInputSchema";
+
+export const AssetCreateOrConnectWithoutRundownInputSchema: z.ZodType<Prisma.AssetCreateOrConnectWithoutRundownInput> =
+  z
+    .object({
+      where: z.lazy(() => AssetWhereUniqueInputSchema),
+      create: z.union([
+        z.lazy(() => AssetCreateWithoutRundownInputSchema),
+        z.lazy(() => AssetUncheckedCreateWithoutRundownInputSchema),
+      ]),
+    })
+    .strict();
+
+export default AssetCreateOrConnectWithoutRundownInputSchema;

utility/prisma/types/inputTypeSchemas/AssetCreateWithoutLoadJobsInputSchema.ts

@@ -0,0 +1,17 @@
+import type { Prisma } from "../../client";
+import { z } from "zod";
+import { AssetTypeSchema } from "./AssetTypeSchema";
+import { MediaCreateNestedOneWithoutAssetInputSchema } from "./MediaCreateNestedOneWithoutAssetInputSchema";
+import { RundownCreateNestedOneWithoutAssetsInputSchema } from "./RundownCreateNestedOneWithoutAssetsInputSchema";
+
+export const AssetCreateWithoutLoadJobsInputSchema: z.ZodType<Prisma.AssetCreateWithoutLoadJobsInput> =
+  z
+    .object({
+      name: z.string(),
+      type: z.lazy(() => AssetTypeSchema),
+      media: z.lazy(() => MediaCreateNestedOneWithoutAssetInputSchema),
+      rundown: z.lazy(() => RundownCreateNestedOneWithoutAssetsInputSchema),
+    })
+    .strict();
+
+export default AssetCreateWithoutLoadJobsInputSchema;

utility/prisma/types/inputTypeSchemas/AssetCreateWithoutMediaInputSchema.ts

@@ -0,0 +1,19 @@
+import type { Prisma } from "../../client";
+import { z } from "zod";
+import { AssetTypeSchema } from "./AssetTypeSchema";
+import { RundownCreateNestedOneWithoutAssetsInputSchema } from "./RundownCreateNestedOneWithoutAssetsInputSchema";
+import { LoadAssetJobCreateNestedManyWithoutAssetInputSchema } from "./LoadAssetJobCreateNestedManyWithoutAssetInputSchema";
+
+export const AssetCreateWithoutMediaInputSchema: z.ZodType<Prisma.AssetCreateWithoutMediaInput> =
+  z
+    .object({
+      name: z.string(),
+      type: z.lazy(() => AssetTypeSchema),
+      rundown: z.lazy(() => RundownCreateNestedOneWithoutAssetsInputSchema),
+      loadJobs: z
+        .lazy(() => LoadAssetJobCreateNestedManyWithoutAssetInputSchema)
+        .optional(),
+    })
+    .strict();
+
+export default AssetCreateWithoutMediaInputSchema;

utility/prisma/types/inputTypeSchemas/AssetCreateWithoutRundownInputSchema.ts

@@ -0,0 +1,19 @@
+import type { Prisma } from "../../client";
+import { z } from "zod";
+import { AssetTypeSchema } from "./AssetTypeSchema";
+import { MediaCreateNestedOneWithoutAssetInputSchema } from "./MediaCreateNestedOneWithoutAssetInputSchema";
+import { LoadAssetJobCreateNestedManyWithoutAssetInputSchema } from "./LoadAssetJobCreateNestedManyWithoutAssetInputSchema";
+
+export const AssetCreateWithoutRundownInputSchema: z.ZodType<Prisma.AssetCreateWithoutRundownInput> =
+  z
+    .object({
+      name: z.string(),
+      type: z.lazy(() => AssetTypeSchema),
+      media: z.lazy(() => MediaCreateNestedOneWithoutAssetInputSchema),
+      loadJobs: z
+        .lazy(() => LoadAssetJobCreateNestedManyWithoutAssetInputSchema)
+        .optional(),
+    })
+    .strict();
+
+export default AssetCreateWithoutRundownInputSchema;

utility/prisma/types/inputTypeSchemas/AssetIncludeSchema.ts

@@ -0,0 +1,21 @@
+import { z } from "zod";
+import type { Prisma } from "../../client";
+import { MediaArgsSchema } from "../outputTypeSchemas/MediaArgsSchema";
+import { RundownArgsSchema } from "../outputTypeSchemas/RundownArgsSchema";
+import { LoadAssetJobFindManyArgsSchema } from "../outputTypeSchemas/LoadAssetJobFindManyArgsSchema";
+import { AssetCountOutputTypeArgsSchema } from "../outputTypeSchemas/AssetCountOutputTypeArgsSchema";
+
+export const AssetIncludeSchema: z.ZodType<Prisma.AssetInclude> = z
+  .object({
+    media: z.union([z.boolean(), z.lazy(() => MediaArgsSchema)]).optional(),
+    rundown: z.union([z.boolean(), z.lazy(() => RundownArgsSchema)]).optional(),
+    loadJobs: z
+      .union([z.boolean(), z.lazy(() => LoadAssetJobFindManyArgsSchema)])
+      .optional(),
+    _count: z
+      .union([z.boolean(), z.lazy(() => AssetCountOutputTypeArgsSchema)])
+      .optional(),
+  })
+  .strict();
+
+export default AssetIncludeSchema;

utility/prisma/types/inputTypeSchemas/AssetListRelationFilterSchema.ts

@@ -0,0 +1,14 @@
+import type { Prisma } from "../../client";
+import { z } from "zod";
+import { AssetWhereInputSchema } from "./AssetWhereInputSchema";
+
+export const AssetListRelationFilterSchema: z.ZodType<Prisma.AssetListRelationFilter> =
+  z
+    .object({
+      every: z.lazy(() => AssetWhereInputSchema).optional(),
+      some: z.lazy(() => AssetWhereInputSchema).optional(),
+      none: z.lazy(() => AssetWhereInputSchema).optional(),
+    })
+    .strict();
+
+export default AssetListRelationFilterSchema;

utility/prisma/types/inputTypeSchemas/AssetMaxOrderByAggregateInputSchema.ts

@@ -0,0 +1,16 @@
+import type { Prisma } from "../../client";
+import { z } from "zod";
+import { SortOrderSchema } from "./SortOrderSchema";
+
+export const AssetMaxOrderByAggregateInputSchema: z.ZodType<Prisma.AssetMaxOrderByAggregateInput> =
+  z
+    .object({
+      id: z.lazy(() => SortOrderSchema).optional(),
+      name: z.lazy(() => SortOrderSchema).optional(),
+      type: z.lazy(() => SortOrderSchema).optional(),
+      rundownId: z.lazy(() => SortOrderSchema).optional(),
+      mediaId: z.lazy(() => SortOrderSchema).optional(),
+    })
+    .strict();
+
+export default AssetMaxOrderByAggregateInputSchema;