@rawan-temo/prisma-zod-generator 3.3.1-config-coercion.0

package/tests/multi-provider/schemas/postgresql/generated/schemas/deleteOnePostgreSQLUser.schema.ts

@@ -0,0 +1,9 @@
+import type { Prisma } from '@prisma/client';
+import * as z from 'zod';
+import { PostgreSQLUserSelectObjectSchema as PostgreSQLUserSelectObjectSchema } from './objects/PostgreSQLUserSelect.schema';
+import { PostgreSQLUserIncludeObjectSchema as PostgreSQLUserIncludeObjectSchema } from './objects/PostgreSQLUserInclude.schema';
+import { PostgreSQLUserWhereUniqueInputObjectSchema as PostgreSQLUserWhereUniqueInputObjectSchema } from './objects/PostgreSQLUserWhereUniqueInput.schema';
+
+export const PostgreSQLUserDeleteOneSchema: z.ZodType<Prisma.PostgreSQLUserDeleteArgs> = z.object({ select: PostgreSQLUserSelectObjectSchema.optional(), include: PostgreSQLUserIncludeObjectSchema.optional(), where: PostgreSQLUserWhereUniqueInputObjectSchema }).strict() as unknown as z.ZodType<Prisma.PostgreSQLUserDeleteArgs>;
+
+export const PostgreSQLUserDeleteOneZodSchema = z.object({ select: PostgreSQLUserSelectObjectSchema.optional(), include: PostgreSQLUserIncludeObjectSchema.optional(), where: PostgreSQLUserWhereUniqueInputObjectSchema }).strict();

package/tests/multi-provider/schemas/postgresql/generated/schemas/enums/JsonNullValueFilter.schema.ts

@@ -0,0 +1,5 @@
+import * as z from 'zod';
+
+export const JsonNullValueFilterSchema = z.enum(['DbNull', 'JsonNull', 'AnyNull'])
+
+export type JsonNullValueFilter = z.infer<typeof JsonNullValueFilterSchema>;

package/tests/multi-provider/schemas/postgresql/generated/schemas/enums/NullableJsonNullValueInput.schema.ts

@@ -0,0 +1,5 @@
+import * as z from 'zod';
+
+export const NullableJsonNullValueInputSchema = z.enum(['DbNull', 'JsonNull'])
+
+export type NullableJsonNullValueInput = z.infer<typeof NullableJsonNullValueInputSchema>;

package/tests/multi-provider/schemas/postgresql/generated/schemas/enums/NullsOrder.schema.ts

@@ -0,0 +1,5 @@
+import * as z from 'zod';
+
+export const NullsOrderSchema = z.enum(['first', 'last'])
+
+export type NullsOrder = z.infer<typeof NullsOrderSchema>;

package/tests/multi-provider/schemas/postgresql/generated/schemas/enums/PostgreSQLPostScalarFieldEnum.schema.ts

@@ -0,0 +1,5 @@
+import * as z from 'zod';
+
+export const PostgreSQLPostScalarFieldEnumSchema = z.enum(['id', 'title', 'content', 'published', 'createdAt', 'updatedAt', 'likes', 'data', 'bytes', 'authorId'])
+
+export type PostgreSQLPostScalarFieldEnum = z.infer<typeof PostgreSQLPostScalarFieldEnumSchema>;

package/tests/multi-provider/schemas/postgresql/generated/schemas/enums/PostgreSQLProfileScalarFieldEnum.schema.ts

@@ -0,0 +1,5 @@
+import * as z from 'zod';
+
+export const PostgreSQLProfileScalarFieldEnumSchema = z.enum(['id', 'bio', 'userId'])
+
+export type PostgreSQLProfileScalarFieldEnum = z.infer<typeof PostgreSQLProfileScalarFieldEnumSchema>;

package/tests/multi-provider/schemas/postgresql/generated/schemas/enums/PostgreSQLUserRole.schema.ts

@@ -0,0 +1,5 @@
+import * as z from 'zod';
+
+export const PostgreSQLUserRoleSchema = z.enum(['ADMIN', 'USER'])
+
+export type PostgreSQLUserRole = z.infer<typeof PostgreSQLUserRoleSchema>;

package/tests/multi-provider/schemas/postgresql/generated/schemas/enums/PostgreSQLUserScalarFieldEnum.schema.ts

@@ -0,0 +1,5 @@
+import * as z from 'zod';
+
+export const PostgreSQLUserScalarFieldEnumSchema = z.enum(['id', 'email', 'name', 'role', 'scores', 'tags'])
+
+export type PostgreSQLUserScalarFieldEnum = z.infer<typeof PostgreSQLUserScalarFieldEnumSchema>;

package/tests/multi-provider/schemas/postgresql/generated/schemas/enums/QueryMode.schema.ts

@@ -0,0 +1,5 @@
+import * as z from 'zod';
+
+export const QueryModeSchema = z.enum(['default', 'insensitive'])
+
+export type QueryMode = z.infer<typeof QueryModeSchema>;

package/tests/multi-provider/schemas/postgresql/generated/schemas/enums/SortOrder.schema.ts

@@ -0,0 +1,5 @@
+import * as z from 'zod';
+
+export const SortOrderSchema = z.enum(['asc', 'desc'])
+
+export type SortOrder = z.infer<typeof SortOrderSchema>;

package/tests/multi-provider/schemas/postgresql/generated/schemas/enums/TransactionIsolationLevel.schema.ts

@@ -0,0 +1,5 @@
+import * as z from 'zod';
+
+export const TransactionIsolationLevelSchema = z.enum(['ReadUncommitted', 'ReadCommitted', 'RepeatableRead', 'Serializable'])
+
+export type TransactionIsolationLevel = z.infer<typeof TransactionIsolationLevelSchema>;

package/tests/multi-provider/schemas/postgresql/generated/schemas/findFirstOrThrowPostgreSQLPost.schema.ts

@@ -0,0 +1,43 @@
+import type { Prisma } from '@prisma/client';
+import * as z from 'zod';
+import { PostgreSQLPostIncludeObjectSchema as PostgreSQLPostIncludeObjectSchema } from './objects/PostgreSQLPostInclude.schema';
+import { PostgreSQLPostOrderByWithRelationInputObjectSchema as PostgreSQLPostOrderByWithRelationInputObjectSchema } from './objects/PostgreSQLPostOrderByWithRelationInput.schema';
+import { PostgreSQLPostWhereInputObjectSchema as PostgreSQLPostWhereInputObjectSchema } from './objects/PostgreSQLPostWhereInput.schema';
+import { PostgreSQLPostWhereUniqueInputObjectSchema as PostgreSQLPostWhereUniqueInputObjectSchema } from './objects/PostgreSQLPostWhereUniqueInput.schema';
+import { PostgreSQLPostScalarFieldEnumSchema } from './enums/PostgreSQLPostScalarFieldEnum.schema';
+import { PostgreSQLUserArgsObjectSchema as PostgreSQLUserArgsObjectSchema } from './objects/PostgreSQLUserArgs.schema';
+
+// Select schema needs to be in file to prevent circular imports
+//------------------------------------------------------
+
+export const PostgreSQLPostFindFirstOrThrowSelectSchema: z.ZodType<Prisma.PostgreSQLPostSelect> = z.object({
+    id: z.boolean().optional(),
+    title: z.boolean().optional(),
+    content: z.boolean().optional(),
+    published: z.boolean().optional(),
+    createdAt: z.boolean().optional(),
+    updatedAt: z.boolean().optional(),
+    likes: z.boolean().optional(),
+    data: z.boolean().optional(),
+    bytes: z.boolean().optional(),
+    author: z.union([z.boolean(), z.lazy(() => PostgreSQLUserArgsObjectSchema)]).optional(),
+    authorId: z.boolean().optional()
+  }).strict() as unknown as z.ZodType<Prisma.PostgreSQLPostSelect>;
+
+export const PostgreSQLPostFindFirstOrThrowSelectZodSchema = z.object({
+    id: z.boolean().optional(),
+    title: z.boolean().optional(),
+    content: z.boolean().optional(),
+    published: z.boolean().optional(),
+    createdAt: z.boolean().optional(),
+    updatedAt: z.boolean().optional(),
+    likes: z.boolean().optional(),
+    data: z.boolean().optional(),
+    bytes: z.boolean().optional(),
+    author: z.union([z.boolean(), z.lazy(() => PostgreSQLUserArgsObjectSchema)]).optional(),
+    authorId: z.boolean().optional()
+  }).strict();
+
+export const PostgreSQLPostFindFirstOrThrowSchema: z.ZodType<Prisma.PostgreSQLPostFindFirstOrThrowArgs> = z.object({ select: PostgreSQLPostFindFirstOrThrowSelectSchema.optional(), include: z.lazy(() => PostgreSQLPostIncludeObjectSchema.optional()), orderBy: z.union([PostgreSQLPostOrderByWithRelationInputObjectSchema, PostgreSQLPostOrderByWithRelationInputObjectSchema.array()]).optional(), where: PostgreSQLPostWhereInputObjectSchema.optional(), cursor: PostgreSQLPostWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), distinct: z.union([PostgreSQLPostScalarFieldEnumSchema, PostgreSQLPostScalarFieldEnumSchema.array()]).optional() }).strict() as unknown as z.ZodType<Prisma.PostgreSQLPostFindFirstOrThrowArgs>;
+
+export const PostgreSQLPostFindFirstOrThrowZodSchema = z.object({ select: PostgreSQLPostFindFirstOrThrowSelectSchema.optional(), include: z.lazy(() => PostgreSQLPostIncludeObjectSchema.optional()), orderBy: z.union([PostgreSQLPostOrderByWithRelationInputObjectSchema, PostgreSQLPostOrderByWithRelationInputObjectSchema.array()]).optional(), where: PostgreSQLPostWhereInputObjectSchema.optional(), cursor: PostgreSQLPostWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), distinct: z.union([PostgreSQLPostScalarFieldEnumSchema, PostgreSQLPostScalarFieldEnumSchema.array()]).optional() }).strict();

package/tests/multi-provider/schemas/postgresql/generated/schemas/findFirstOrThrowPostgreSQLProfile.schema.ts

@@ -0,0 +1,29 @@
+import type { Prisma } from '@prisma/client';
+import * as z from 'zod';
+import { PostgreSQLProfileIncludeObjectSchema as PostgreSQLProfileIncludeObjectSchema } from './objects/PostgreSQLProfileInclude.schema';
+import { PostgreSQLProfileOrderByWithRelationInputObjectSchema as PostgreSQLProfileOrderByWithRelationInputObjectSchema } from './objects/PostgreSQLProfileOrderByWithRelationInput.schema';
+import { PostgreSQLProfileWhereInputObjectSchema as PostgreSQLProfileWhereInputObjectSchema } from './objects/PostgreSQLProfileWhereInput.schema';
+import { PostgreSQLProfileWhereUniqueInputObjectSchema as PostgreSQLProfileWhereUniqueInputObjectSchema } from './objects/PostgreSQLProfileWhereUniqueInput.schema';
+import { PostgreSQLProfileScalarFieldEnumSchema } from './enums/PostgreSQLProfileScalarFieldEnum.schema';
+import { PostgreSQLUserArgsObjectSchema as PostgreSQLUserArgsObjectSchema } from './objects/PostgreSQLUserArgs.schema';
+
+// Select schema needs to be in file to prevent circular imports
+//------------------------------------------------------
+
+export const PostgreSQLProfileFindFirstOrThrowSelectSchema: z.ZodType<Prisma.PostgreSQLProfileSelect> = z.object({
+    id: z.boolean().optional(),
+    bio: z.boolean().optional(),
+    user: z.union([z.boolean(), z.lazy(() => PostgreSQLUserArgsObjectSchema)]).optional(),
+    userId: z.boolean().optional()
+  }).strict() as unknown as z.ZodType<Prisma.PostgreSQLProfileSelect>;
+
+export const PostgreSQLProfileFindFirstOrThrowSelectZodSchema = z.object({
+    id: z.boolean().optional(),
+    bio: z.boolean().optional(),
+    user: z.union([z.boolean(), z.lazy(() => PostgreSQLUserArgsObjectSchema)]).optional(),
+    userId: z.boolean().optional()
+  }).strict();
+
+export const PostgreSQLProfileFindFirstOrThrowSchema: z.ZodType<Prisma.PostgreSQLProfileFindFirstOrThrowArgs> = z.object({ select: PostgreSQLProfileFindFirstOrThrowSelectSchema.optional(), include: z.lazy(() => PostgreSQLProfileIncludeObjectSchema.optional()), orderBy: z.union([PostgreSQLProfileOrderByWithRelationInputObjectSchema, PostgreSQLProfileOrderByWithRelationInputObjectSchema.array()]).optional(), where: PostgreSQLProfileWhereInputObjectSchema.optional(), cursor: PostgreSQLProfileWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), distinct: z.union([PostgreSQLProfileScalarFieldEnumSchema, PostgreSQLProfileScalarFieldEnumSchema.array()]).optional() }).strict() as unknown as z.ZodType<Prisma.PostgreSQLProfileFindFirstOrThrowArgs>;
+
+export const PostgreSQLProfileFindFirstOrThrowZodSchema = z.object({ select: PostgreSQLProfileFindFirstOrThrowSelectSchema.optional(), include: z.lazy(() => PostgreSQLProfileIncludeObjectSchema.optional()), orderBy: z.union([PostgreSQLProfileOrderByWithRelationInputObjectSchema, PostgreSQLProfileOrderByWithRelationInputObjectSchema.array()]).optional(), where: PostgreSQLProfileWhereInputObjectSchema.optional(), cursor: PostgreSQLProfileWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), distinct: z.union([PostgreSQLProfileScalarFieldEnumSchema, PostgreSQLProfileScalarFieldEnumSchema.array()]).optional() }).strict();

package/tests/multi-provider/schemas/postgresql/generated/schemas/findFirstOrThrowPostgreSQLUser.schema.ts

@@ -0,0 +1,41 @@
+import type { Prisma } from '@prisma/client';
+import * as z from 'zod';
+import { PostgreSQLUserIncludeObjectSchema as PostgreSQLUserIncludeObjectSchema } from './objects/PostgreSQLUserInclude.schema';
+import { PostgreSQLUserOrderByWithRelationInputObjectSchema as PostgreSQLUserOrderByWithRelationInputObjectSchema } from './objects/PostgreSQLUserOrderByWithRelationInput.schema';
+import { PostgreSQLUserWhereInputObjectSchema as PostgreSQLUserWhereInputObjectSchema } from './objects/PostgreSQLUserWhereInput.schema';
+import { PostgreSQLUserWhereUniqueInputObjectSchema as PostgreSQLUserWhereUniqueInputObjectSchema } from './objects/PostgreSQLUserWhereUniqueInput.schema';
+import { PostgreSQLUserScalarFieldEnumSchema } from './enums/PostgreSQLUserScalarFieldEnum.schema';
+import { PostgreSQLProfileArgsObjectSchema as PostgreSQLProfileArgsObjectSchema } from './objects/PostgreSQLProfileArgs.schema';
+import { PostgreSQLPostFindManySchema } from './findManyPostgreSQLPost.schema';
+import { PostgreSQLUserCountOutputTypeArgsObjectSchema as PostgreSQLUserCountOutputTypeArgsObjectSchema } from './objects/PostgreSQLUserCountOutputTypeArgs.schema';
+
+// Select schema needs to be in file to prevent circular imports
+//------------------------------------------------------
+
+export const PostgreSQLUserFindFirstOrThrowSelectSchema: z.ZodType<Prisma.PostgreSQLUserSelect> = z.object({
+    id: z.boolean().optional(),
+    email: z.boolean().optional(),
+    name: z.boolean().optional(),
+    role: z.boolean().optional(),
+    scores: z.boolean().optional(),
+    tags: z.boolean().optional(),
+    profile: z.union([z.boolean(), z.lazy(() => PostgreSQLProfileArgsObjectSchema)]).optional(),
+    posts: z.union([z.boolean(), z.lazy(() => PostgreSQLPostFindManySchema)]).optional(),
+    _count: z.union([z.boolean(), z.lazy(() => PostgreSQLUserCountOutputTypeArgsObjectSchema)]).optional()
+  }).strict() as unknown as z.ZodType<Prisma.PostgreSQLUserSelect>;
+
+export const PostgreSQLUserFindFirstOrThrowSelectZodSchema = z.object({
+    id: z.boolean().optional(),
+    email: z.boolean().optional(),
+    name: z.boolean().optional(),
+    role: z.boolean().optional(),
+    scores: z.boolean().optional(),
+    tags: z.boolean().optional(),
+    profile: z.union([z.boolean(), z.lazy(() => PostgreSQLProfileArgsObjectSchema)]).optional(),
+    posts: z.union([z.boolean(), z.lazy(() => PostgreSQLPostFindManySchema)]).optional(),
+    _count: z.union([z.boolean(), z.lazy(() => PostgreSQLUserCountOutputTypeArgsObjectSchema)]).optional()
+  }).strict();
+
+export const PostgreSQLUserFindFirstOrThrowSchema: z.ZodType<Prisma.PostgreSQLUserFindFirstOrThrowArgs> = z.object({ select: PostgreSQLUserFindFirstOrThrowSelectSchema.optional(), include: z.lazy(() => PostgreSQLUserIncludeObjectSchema.optional()), orderBy: z.union([PostgreSQLUserOrderByWithRelationInputObjectSchema, PostgreSQLUserOrderByWithRelationInputObjectSchema.array()]).optional(), where: PostgreSQLUserWhereInputObjectSchema.optional(), cursor: PostgreSQLUserWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), distinct: z.union([PostgreSQLUserScalarFieldEnumSchema, PostgreSQLUserScalarFieldEnumSchema.array()]).optional() }).strict() as unknown as z.ZodType<Prisma.PostgreSQLUserFindFirstOrThrowArgs>;
+
+export const PostgreSQLUserFindFirstOrThrowZodSchema = z.object({ select: PostgreSQLUserFindFirstOrThrowSelectSchema.optional(), include: z.lazy(() => PostgreSQLUserIncludeObjectSchema.optional()), orderBy: z.union([PostgreSQLUserOrderByWithRelationInputObjectSchema, PostgreSQLUserOrderByWithRelationInputObjectSchema.array()]).optional(), where: PostgreSQLUserWhereInputObjectSchema.optional(), cursor: PostgreSQLUserWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), distinct: z.union([PostgreSQLUserScalarFieldEnumSchema, PostgreSQLUserScalarFieldEnumSchema.array()]).optional() }).strict();

package/tests/multi-provider/schemas/postgresql/generated/schemas/findFirstPostgreSQLPost.schema.ts

@@ -0,0 +1,43 @@
+import type { Prisma } from '@prisma/client';
+import * as z from 'zod';
+import { PostgreSQLPostIncludeObjectSchema as PostgreSQLPostIncludeObjectSchema } from './objects/PostgreSQLPostInclude.schema';
+import { PostgreSQLPostOrderByWithRelationInputObjectSchema as PostgreSQLPostOrderByWithRelationInputObjectSchema } from './objects/PostgreSQLPostOrderByWithRelationInput.schema';
+import { PostgreSQLPostWhereInputObjectSchema as PostgreSQLPostWhereInputObjectSchema } from './objects/PostgreSQLPostWhereInput.schema';
+import { PostgreSQLPostWhereUniqueInputObjectSchema as PostgreSQLPostWhereUniqueInputObjectSchema } from './objects/PostgreSQLPostWhereUniqueInput.schema';
+import { PostgreSQLPostScalarFieldEnumSchema } from './enums/PostgreSQLPostScalarFieldEnum.schema';
+import { PostgreSQLUserArgsObjectSchema as PostgreSQLUserArgsObjectSchema } from './objects/PostgreSQLUserArgs.schema';
+
+// Select schema needs to be in file to prevent circular imports
+//------------------------------------------------------
+
+export const PostgreSQLPostFindFirstSelectSchema: z.ZodType<Prisma.PostgreSQLPostSelect> = z.object({
+    id: z.boolean().optional(),
+    title: z.boolean().optional(),
+    content: z.boolean().optional(),
+    published: z.boolean().optional(),
+    createdAt: z.boolean().optional(),
+    updatedAt: z.boolean().optional(),
+    likes: z.boolean().optional(),
+    data: z.boolean().optional(),
+    bytes: z.boolean().optional(),
+    author: z.union([z.boolean(), z.lazy(() => PostgreSQLUserArgsObjectSchema)]).optional(),
+    authorId: z.boolean().optional()
+  }).strict() as unknown as z.ZodType<Prisma.PostgreSQLPostSelect>;
+
+export const PostgreSQLPostFindFirstSelectZodSchema = z.object({
+    id: z.boolean().optional(),
+    title: z.boolean().optional(),
+    content: z.boolean().optional(),
+    published: z.boolean().optional(),
+    createdAt: z.boolean().optional(),
+    updatedAt: z.boolean().optional(),
+    likes: z.boolean().optional(),
+    data: z.boolean().optional(),
+    bytes: z.boolean().optional(),
+    author: z.union([z.boolean(), z.lazy(() => PostgreSQLUserArgsObjectSchema)]).optional(),
+    authorId: z.boolean().optional()
+  }).strict();
+
+export const PostgreSQLPostFindFirstSchema: z.ZodType<Prisma.PostgreSQLPostFindFirstArgs> = z.object({ select: PostgreSQLPostFindFirstSelectSchema.optional(), include: z.lazy(() => PostgreSQLPostIncludeObjectSchema.optional()), orderBy: z.union([PostgreSQLPostOrderByWithRelationInputObjectSchema, PostgreSQLPostOrderByWithRelationInputObjectSchema.array()]).optional(), where: PostgreSQLPostWhereInputObjectSchema.optional(), cursor: PostgreSQLPostWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), distinct: z.union([PostgreSQLPostScalarFieldEnumSchema, PostgreSQLPostScalarFieldEnumSchema.array()]).optional() }).strict() as unknown as z.ZodType<Prisma.PostgreSQLPostFindFirstArgs>;
+
+export const PostgreSQLPostFindFirstZodSchema = z.object({ select: PostgreSQLPostFindFirstSelectSchema.optional(), include: z.lazy(() => PostgreSQLPostIncludeObjectSchema.optional()), orderBy: z.union([PostgreSQLPostOrderByWithRelationInputObjectSchema, PostgreSQLPostOrderByWithRelationInputObjectSchema.array()]).optional(), where: PostgreSQLPostWhereInputObjectSchema.optional(), cursor: PostgreSQLPostWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), distinct: z.union([PostgreSQLPostScalarFieldEnumSchema, PostgreSQLPostScalarFieldEnumSchema.array()]).optional() }).strict();

package/tests/multi-provider/schemas/postgresql/generated/schemas/findFirstPostgreSQLProfile.schema.ts

@@ -0,0 +1,29 @@
+import type { Prisma } from '@prisma/client';
+import * as z from 'zod';
+import { PostgreSQLProfileIncludeObjectSchema as PostgreSQLProfileIncludeObjectSchema } from './objects/PostgreSQLProfileInclude.schema';
+import { PostgreSQLProfileOrderByWithRelationInputObjectSchema as PostgreSQLProfileOrderByWithRelationInputObjectSchema } from './objects/PostgreSQLProfileOrderByWithRelationInput.schema';
+import { PostgreSQLProfileWhereInputObjectSchema as PostgreSQLProfileWhereInputObjectSchema } from './objects/PostgreSQLProfileWhereInput.schema';
+import { PostgreSQLProfileWhereUniqueInputObjectSchema as PostgreSQLProfileWhereUniqueInputObjectSchema } from './objects/PostgreSQLProfileWhereUniqueInput.schema';
+import { PostgreSQLProfileScalarFieldEnumSchema } from './enums/PostgreSQLProfileScalarFieldEnum.schema';
+import { PostgreSQLUserArgsObjectSchema as PostgreSQLUserArgsObjectSchema } from './objects/PostgreSQLUserArgs.schema';
+
+// Select schema needs to be in file to prevent circular imports
+//------------------------------------------------------
+
+export const PostgreSQLProfileFindFirstSelectSchema: z.ZodType<Prisma.PostgreSQLProfileSelect> = z.object({
+    id: z.boolean().optional(),
+    bio: z.boolean().optional(),
+    user: z.union([z.boolean(), z.lazy(() => PostgreSQLUserArgsObjectSchema)]).optional(),
+    userId: z.boolean().optional()
+  }).strict() as unknown as z.ZodType<Prisma.PostgreSQLProfileSelect>;
+
+export const PostgreSQLProfileFindFirstSelectZodSchema = z.object({
+    id: z.boolean().optional(),
+    bio: z.boolean().optional(),
+    user: z.union([z.boolean(), z.lazy(() => PostgreSQLUserArgsObjectSchema)]).optional(),
+    userId: z.boolean().optional()
+  }).strict();
+
+export const PostgreSQLProfileFindFirstSchema: z.ZodType<Prisma.PostgreSQLProfileFindFirstArgs> = z.object({ select: PostgreSQLProfileFindFirstSelectSchema.optional(), include: z.lazy(() => PostgreSQLProfileIncludeObjectSchema.optional()), orderBy: z.union([PostgreSQLProfileOrderByWithRelationInputObjectSchema, PostgreSQLProfileOrderByWithRelationInputObjectSchema.array()]).optional(), where: PostgreSQLProfileWhereInputObjectSchema.optional(), cursor: PostgreSQLProfileWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), distinct: z.union([PostgreSQLProfileScalarFieldEnumSchema, PostgreSQLProfileScalarFieldEnumSchema.array()]).optional() }).strict() as unknown as z.ZodType<Prisma.PostgreSQLProfileFindFirstArgs>;
+
+export const PostgreSQLProfileFindFirstZodSchema = z.object({ select: PostgreSQLProfileFindFirstSelectSchema.optional(), include: z.lazy(() => PostgreSQLProfileIncludeObjectSchema.optional()), orderBy: z.union([PostgreSQLProfileOrderByWithRelationInputObjectSchema, PostgreSQLProfileOrderByWithRelationInputObjectSchema.array()]).optional(), where: PostgreSQLProfileWhereInputObjectSchema.optional(), cursor: PostgreSQLProfileWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), distinct: z.union([PostgreSQLProfileScalarFieldEnumSchema, PostgreSQLProfileScalarFieldEnumSchema.array()]).optional() }).strict();

package/tests/multi-provider/schemas/postgresql/generated/schemas/findFirstPostgreSQLUser.schema.ts

@@ -0,0 +1,41 @@
+import type { Prisma } from '@prisma/client';
+import * as z from 'zod';
+import { PostgreSQLUserIncludeObjectSchema as PostgreSQLUserIncludeObjectSchema } from './objects/PostgreSQLUserInclude.schema';
+import { PostgreSQLUserOrderByWithRelationInputObjectSchema as PostgreSQLUserOrderByWithRelationInputObjectSchema } from './objects/PostgreSQLUserOrderByWithRelationInput.schema';
+import { PostgreSQLUserWhereInputObjectSchema as PostgreSQLUserWhereInputObjectSchema } from './objects/PostgreSQLUserWhereInput.schema';
+import { PostgreSQLUserWhereUniqueInputObjectSchema as PostgreSQLUserWhereUniqueInputObjectSchema } from './objects/PostgreSQLUserWhereUniqueInput.schema';
+import { PostgreSQLUserScalarFieldEnumSchema } from './enums/PostgreSQLUserScalarFieldEnum.schema';
+import { PostgreSQLProfileArgsObjectSchema as PostgreSQLProfileArgsObjectSchema } from './objects/PostgreSQLProfileArgs.schema';
+import { PostgreSQLPostFindManySchema } from './findManyPostgreSQLPost.schema';
+import { PostgreSQLUserCountOutputTypeArgsObjectSchema as PostgreSQLUserCountOutputTypeArgsObjectSchema } from './objects/PostgreSQLUserCountOutputTypeArgs.schema';
+
+// Select schema needs to be in file to prevent circular imports
+//------------------------------------------------------
+
+export const PostgreSQLUserFindFirstSelectSchema: z.ZodType<Prisma.PostgreSQLUserSelect> = z.object({
+    id: z.boolean().optional(),
+    email: z.boolean().optional(),
+    name: z.boolean().optional(),
+    role: z.boolean().optional(),
+    scores: z.boolean().optional(),
+    tags: z.boolean().optional(),
+    profile: z.union([z.boolean(), z.lazy(() => PostgreSQLProfileArgsObjectSchema)]).optional(),
+    posts: z.union([z.boolean(), z.lazy(() => PostgreSQLPostFindManySchema)]).optional(),
+    _count: z.union([z.boolean(), z.lazy(() => PostgreSQLUserCountOutputTypeArgsObjectSchema)]).optional()
+  }).strict() as unknown as z.ZodType<Prisma.PostgreSQLUserSelect>;
+
+export const PostgreSQLUserFindFirstSelectZodSchema = z.object({
+    id: z.boolean().optional(),
+    email: z.boolean().optional(),
+    name: z.boolean().optional(),
+    role: z.boolean().optional(),
+    scores: z.boolean().optional(),
+    tags: z.boolean().optional(),
+    profile: z.union([z.boolean(), z.lazy(() => PostgreSQLProfileArgsObjectSchema)]).optional(),
+    posts: z.union([z.boolean(), z.lazy(() => PostgreSQLPostFindManySchema)]).optional(),
+    _count: z.union([z.boolean(), z.lazy(() => PostgreSQLUserCountOutputTypeArgsObjectSchema)]).optional()
+  }).strict();
+
+export const PostgreSQLUserFindFirstSchema: z.ZodType<Prisma.PostgreSQLUserFindFirstArgs> = z.object({ select: PostgreSQLUserFindFirstSelectSchema.optional(), include: z.lazy(() => PostgreSQLUserIncludeObjectSchema.optional()), orderBy: z.union([PostgreSQLUserOrderByWithRelationInputObjectSchema, PostgreSQLUserOrderByWithRelationInputObjectSchema.array()]).optional(), where: PostgreSQLUserWhereInputObjectSchema.optional(), cursor: PostgreSQLUserWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), distinct: z.union([PostgreSQLUserScalarFieldEnumSchema, PostgreSQLUserScalarFieldEnumSchema.array()]).optional() }).strict() as unknown as z.ZodType<Prisma.PostgreSQLUserFindFirstArgs>;
+
+export const PostgreSQLUserFindFirstZodSchema = z.object({ select: PostgreSQLUserFindFirstSelectSchema.optional(), include: z.lazy(() => PostgreSQLUserIncludeObjectSchema.optional()), orderBy: z.union([PostgreSQLUserOrderByWithRelationInputObjectSchema, PostgreSQLUserOrderByWithRelationInputObjectSchema.array()]).optional(), where: PostgreSQLUserWhereInputObjectSchema.optional(), cursor: PostgreSQLUserWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), distinct: z.union([PostgreSQLUserScalarFieldEnumSchema, PostgreSQLUserScalarFieldEnumSchema.array()]).optional() }).strict();

package/tests/multi-provider/schemas/postgresql/generated/schemas/findManyPostgreSQLPost.schema.ts

@@ -0,0 +1,43 @@
+import type { Prisma } from '@prisma/client';
+import * as z from 'zod';
+import { PostgreSQLPostIncludeObjectSchema as PostgreSQLPostIncludeObjectSchema } from './objects/PostgreSQLPostInclude.schema';
+import { PostgreSQLPostOrderByWithRelationInputObjectSchema as PostgreSQLPostOrderByWithRelationInputObjectSchema } from './objects/PostgreSQLPostOrderByWithRelationInput.schema';
+import { PostgreSQLPostWhereInputObjectSchema as PostgreSQLPostWhereInputObjectSchema } from './objects/PostgreSQLPostWhereInput.schema';
+import { PostgreSQLPostWhereUniqueInputObjectSchema as PostgreSQLPostWhereUniqueInputObjectSchema } from './objects/PostgreSQLPostWhereUniqueInput.schema';
+import { PostgreSQLPostScalarFieldEnumSchema } from './enums/PostgreSQLPostScalarFieldEnum.schema';
+import { PostgreSQLUserArgsObjectSchema as PostgreSQLUserArgsObjectSchema } from './objects/PostgreSQLUserArgs.schema';
+
+// Select schema needs to be in file to prevent circular imports
+//------------------------------------------------------
+
+export const PostgreSQLPostFindManySelectSchema: z.ZodType<Prisma.PostgreSQLPostSelect> = z.object({
+    id: z.boolean().optional(),
+    title: z.boolean().optional(),
+    content: z.boolean().optional(),
+    published: z.boolean().optional(),
+    createdAt: z.boolean().optional(),
+    updatedAt: z.boolean().optional(),
+    likes: z.boolean().optional(),
+    data: z.boolean().optional(),
+    bytes: z.boolean().optional(),
+    author: z.union([z.boolean(), z.lazy(() => PostgreSQLUserArgsObjectSchema)]).optional(),
+    authorId: z.boolean().optional()
+  }).strict() as unknown as z.ZodType<Prisma.PostgreSQLPostSelect>;
+
+export const PostgreSQLPostFindManySelectZodSchema = z.object({
+    id: z.boolean().optional(),
+    title: z.boolean().optional(),
+    content: z.boolean().optional(),
+    published: z.boolean().optional(),
+    createdAt: z.boolean().optional(),
+    updatedAt: z.boolean().optional(),
+    likes: z.boolean().optional(),
+    data: z.boolean().optional(),
+    bytes: z.boolean().optional(),
+    author: z.union([z.boolean(), z.lazy(() => PostgreSQLUserArgsObjectSchema)]).optional(),
+    authorId: z.boolean().optional()
+  }).strict();
+
+export const PostgreSQLPostFindManySchema: z.ZodType<Prisma.PostgreSQLPostFindManyArgs> = z.object({ select: PostgreSQLPostFindManySelectSchema.optional(), include: z.lazy(() => PostgreSQLPostIncludeObjectSchema.optional()), orderBy: z.union([PostgreSQLPostOrderByWithRelationInputObjectSchema, PostgreSQLPostOrderByWithRelationInputObjectSchema.array()]).optional(), where: PostgreSQLPostWhereInputObjectSchema.optional(), cursor: PostgreSQLPostWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), distinct: z.union([PostgreSQLPostScalarFieldEnumSchema, PostgreSQLPostScalarFieldEnumSchema.array()]).optional() }).strict() as unknown as z.ZodType<Prisma.PostgreSQLPostFindManyArgs>;
+
+export const PostgreSQLPostFindManyZodSchema = z.object({ select: PostgreSQLPostFindManySelectSchema.optional(), include: z.lazy(() => PostgreSQLPostIncludeObjectSchema.optional()), orderBy: z.union([PostgreSQLPostOrderByWithRelationInputObjectSchema, PostgreSQLPostOrderByWithRelationInputObjectSchema.array()]).optional(), where: PostgreSQLPostWhereInputObjectSchema.optional(), cursor: PostgreSQLPostWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), distinct: z.union([PostgreSQLPostScalarFieldEnumSchema, PostgreSQLPostScalarFieldEnumSchema.array()]).optional() }).strict();

package/tests/multi-provider/schemas/postgresql/generated/schemas/findManyPostgreSQLProfile.schema.ts

@@ -0,0 +1,29 @@
+import type { Prisma } from '@prisma/client';
+import * as z from 'zod';
+import { PostgreSQLProfileIncludeObjectSchema as PostgreSQLProfileIncludeObjectSchema } from './objects/PostgreSQLProfileInclude.schema';
+import { PostgreSQLProfileOrderByWithRelationInputObjectSchema as PostgreSQLProfileOrderByWithRelationInputObjectSchema } from './objects/PostgreSQLProfileOrderByWithRelationInput.schema';
+import { PostgreSQLProfileWhereInputObjectSchema as PostgreSQLProfileWhereInputObjectSchema } from './objects/PostgreSQLProfileWhereInput.schema';
+import { PostgreSQLProfileWhereUniqueInputObjectSchema as PostgreSQLProfileWhereUniqueInputObjectSchema } from './objects/PostgreSQLProfileWhereUniqueInput.schema';
+import { PostgreSQLProfileScalarFieldEnumSchema } from './enums/PostgreSQLProfileScalarFieldEnum.schema';
+import { PostgreSQLUserArgsObjectSchema as PostgreSQLUserArgsObjectSchema } from './objects/PostgreSQLUserArgs.schema';
+
+// Select schema needs to be in file to prevent circular imports
+//------------------------------------------------------
+
+export const PostgreSQLProfileFindManySelectSchema: z.ZodType<Prisma.PostgreSQLProfileSelect> = z.object({
+    id: z.boolean().optional(),
+    bio: z.boolean().optional(),
+    user: z.union([z.boolean(), z.lazy(() => PostgreSQLUserArgsObjectSchema)]).optional(),
+    userId: z.boolean().optional()
+  }).strict() as unknown as z.ZodType<Prisma.PostgreSQLProfileSelect>;
+
+export const PostgreSQLProfileFindManySelectZodSchema = z.object({
+    id: z.boolean().optional(),
+    bio: z.boolean().optional(),
+    user: z.union([z.boolean(), z.lazy(() => PostgreSQLUserArgsObjectSchema)]).optional(),
+    userId: z.boolean().optional()
+  }).strict();
+
+export const PostgreSQLProfileFindManySchema: z.ZodType<Prisma.PostgreSQLProfileFindManyArgs> = z.object({ select: PostgreSQLProfileFindManySelectSchema.optional(), include: z.lazy(() => PostgreSQLProfileIncludeObjectSchema.optional()), orderBy: z.union([PostgreSQLProfileOrderByWithRelationInputObjectSchema, PostgreSQLProfileOrderByWithRelationInputObjectSchema.array()]).optional(), where: PostgreSQLProfileWhereInputObjectSchema.optional(), cursor: PostgreSQLProfileWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), distinct: z.union([PostgreSQLProfileScalarFieldEnumSchema, PostgreSQLProfileScalarFieldEnumSchema.array()]).optional() }).strict() as unknown as z.ZodType<Prisma.PostgreSQLProfileFindManyArgs>;
+
+export const PostgreSQLProfileFindManyZodSchema = z.object({ select: PostgreSQLProfileFindManySelectSchema.optional(), include: z.lazy(() => PostgreSQLProfileIncludeObjectSchema.optional()), orderBy: z.union([PostgreSQLProfileOrderByWithRelationInputObjectSchema, PostgreSQLProfileOrderByWithRelationInputObjectSchema.array()]).optional(), where: PostgreSQLProfileWhereInputObjectSchema.optional(), cursor: PostgreSQLProfileWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), distinct: z.union([PostgreSQLProfileScalarFieldEnumSchema, PostgreSQLProfileScalarFieldEnumSchema.array()]).optional() }).strict();

package/tests/multi-provider/schemas/postgresql/generated/schemas/findManyPostgreSQLUser.schema.ts

@@ -0,0 +1,41 @@
+import type { Prisma } from '@prisma/client';
+import * as z from 'zod';
+import { PostgreSQLUserIncludeObjectSchema as PostgreSQLUserIncludeObjectSchema } from './objects/PostgreSQLUserInclude.schema';
+import { PostgreSQLUserOrderByWithRelationInputObjectSchema as PostgreSQLUserOrderByWithRelationInputObjectSchema } from './objects/PostgreSQLUserOrderByWithRelationInput.schema';
+import { PostgreSQLUserWhereInputObjectSchema as PostgreSQLUserWhereInputObjectSchema } from './objects/PostgreSQLUserWhereInput.schema';
+import { PostgreSQLUserWhereUniqueInputObjectSchema as PostgreSQLUserWhereUniqueInputObjectSchema } from './objects/PostgreSQLUserWhereUniqueInput.schema';
+import { PostgreSQLUserScalarFieldEnumSchema } from './enums/PostgreSQLUserScalarFieldEnum.schema';
+import { PostgreSQLProfileArgsObjectSchema as PostgreSQLProfileArgsObjectSchema } from './objects/PostgreSQLProfileArgs.schema';
+import { PostgreSQLPostFindManySchema } from './findManyPostgreSQLPost.schema';
+import { PostgreSQLUserCountOutputTypeArgsObjectSchema as PostgreSQLUserCountOutputTypeArgsObjectSchema } from './objects/PostgreSQLUserCountOutputTypeArgs.schema';
+
+// Select schema needs to be in file to prevent circular imports
+//------------------------------------------------------
+
+export const PostgreSQLUserFindManySelectSchema: z.ZodType<Prisma.PostgreSQLUserSelect> = z.object({
+    id: z.boolean().optional(),
+    email: z.boolean().optional(),
+    name: z.boolean().optional(),
+    role: z.boolean().optional(),
+    scores: z.boolean().optional(),
+    tags: z.boolean().optional(),
+    profile: z.union([z.boolean(), z.lazy(() => PostgreSQLProfileArgsObjectSchema)]).optional(),
+    posts: z.union([z.boolean(), z.lazy(() => PostgreSQLPostFindManySchema)]).optional(),
+    _count: z.union([z.boolean(), z.lazy(() => PostgreSQLUserCountOutputTypeArgsObjectSchema)]).optional()
+  }).strict() as unknown as z.ZodType<Prisma.PostgreSQLUserSelect>;
+
+export const PostgreSQLUserFindManySelectZodSchema = z.object({
+    id: z.boolean().optional(),
+    email: z.boolean().optional(),
+    name: z.boolean().optional(),
+    role: z.boolean().optional(),
+    scores: z.boolean().optional(),
+    tags: z.boolean().optional(),
+    profile: z.union([z.boolean(), z.lazy(() => PostgreSQLProfileArgsObjectSchema)]).optional(),
+    posts: z.union([z.boolean(), z.lazy(() => PostgreSQLPostFindManySchema)]).optional(),
+    _count: z.union([z.boolean(), z.lazy(() => PostgreSQLUserCountOutputTypeArgsObjectSchema)]).optional()
+  }).strict();
+
+export const PostgreSQLUserFindManySchema: z.ZodType<Prisma.PostgreSQLUserFindManyArgs> = z.object({ select: PostgreSQLUserFindManySelectSchema.optional(), include: z.lazy(() => PostgreSQLUserIncludeObjectSchema.optional()), orderBy: z.union([PostgreSQLUserOrderByWithRelationInputObjectSchema, PostgreSQLUserOrderByWithRelationInputObjectSchema.array()]).optional(), where: PostgreSQLUserWhereInputObjectSchema.optional(), cursor: PostgreSQLUserWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), distinct: z.union([PostgreSQLUserScalarFieldEnumSchema, PostgreSQLUserScalarFieldEnumSchema.array()]).optional() }).strict() as unknown as z.ZodType<Prisma.PostgreSQLUserFindManyArgs>;
+
+export const PostgreSQLUserFindManyZodSchema = z.object({ select: PostgreSQLUserFindManySelectSchema.optional(), include: z.lazy(() => PostgreSQLUserIncludeObjectSchema.optional()), orderBy: z.union([PostgreSQLUserOrderByWithRelationInputObjectSchema, PostgreSQLUserOrderByWithRelationInputObjectSchema.array()]).optional(), where: PostgreSQLUserWhereInputObjectSchema.optional(), cursor: PostgreSQLUserWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), distinct: z.union([PostgreSQLUserScalarFieldEnumSchema, PostgreSQLUserScalarFieldEnumSchema.array()]).optional() }).strict();

package/tests/multi-provider/schemas/postgresql/generated/schemas/findUniqueOrThrowPostgreSQLPost.schema.ts

@@ -0,0 +1,9 @@
+import type { Prisma } from '@prisma/client';
+import * as z from 'zod';
+import { PostgreSQLPostSelectObjectSchema as PostgreSQLPostSelectObjectSchema } from './objects/PostgreSQLPostSelect.schema';
+import { PostgreSQLPostIncludeObjectSchema as PostgreSQLPostIncludeObjectSchema } from './objects/PostgreSQLPostInclude.schema';
+import { PostgreSQLPostWhereUniqueInputObjectSchema as PostgreSQLPostWhereUniqueInputObjectSchema } from './objects/PostgreSQLPostWhereUniqueInput.schema';
+
+export const PostgreSQLPostFindUniqueOrThrowSchema: z.ZodType<Prisma.PostgreSQLPostFindUniqueOrThrowArgs> = z.object({ select: PostgreSQLPostSelectObjectSchema.optional(), include: PostgreSQLPostIncludeObjectSchema.optional(), where: PostgreSQLPostWhereUniqueInputObjectSchema }).strict() as unknown as z.ZodType<Prisma.PostgreSQLPostFindUniqueOrThrowArgs>;
+
+export const PostgreSQLPostFindUniqueOrThrowZodSchema = z.object({ select: PostgreSQLPostSelectObjectSchema.optional(), include: PostgreSQLPostIncludeObjectSchema.optional(), where: PostgreSQLPostWhereUniqueInputObjectSchema }).strict();

package/tests/multi-provider/schemas/postgresql/generated/schemas/findUniqueOrThrowPostgreSQLProfile.schema.ts

@@ -0,0 +1,9 @@
+import type { Prisma } from '@prisma/client';
+import * as z from 'zod';
+import { PostgreSQLProfileSelectObjectSchema as PostgreSQLProfileSelectObjectSchema } from './objects/PostgreSQLProfileSelect.schema';
+import { PostgreSQLProfileIncludeObjectSchema as PostgreSQLProfileIncludeObjectSchema } from './objects/PostgreSQLProfileInclude.schema';
+import { PostgreSQLProfileWhereUniqueInputObjectSchema as PostgreSQLProfileWhereUniqueInputObjectSchema } from './objects/PostgreSQLProfileWhereUniqueInput.schema';
+
+export const PostgreSQLProfileFindUniqueOrThrowSchema: z.ZodType<Prisma.PostgreSQLProfileFindUniqueOrThrowArgs> = z.object({ select: PostgreSQLProfileSelectObjectSchema.optional(), include: PostgreSQLProfileIncludeObjectSchema.optional(), where: PostgreSQLProfileWhereUniqueInputObjectSchema }).strict() as unknown as z.ZodType<Prisma.PostgreSQLProfileFindUniqueOrThrowArgs>;
+
+export const PostgreSQLProfileFindUniqueOrThrowZodSchema = z.object({ select: PostgreSQLProfileSelectObjectSchema.optional(), include: PostgreSQLProfileIncludeObjectSchema.optional(), where: PostgreSQLProfileWhereUniqueInputObjectSchema }).strict();

package/tests/multi-provider/schemas/postgresql/generated/schemas/findUniqueOrThrowPostgreSQLUser.schema.ts

@@ -0,0 +1,9 @@
+import type { Prisma } from '@prisma/client';
+import * as z from 'zod';
+import { PostgreSQLUserSelectObjectSchema as PostgreSQLUserSelectObjectSchema } from './objects/PostgreSQLUserSelect.schema';
+import { PostgreSQLUserIncludeObjectSchema as PostgreSQLUserIncludeObjectSchema } from './objects/PostgreSQLUserInclude.schema';
+import { PostgreSQLUserWhereUniqueInputObjectSchema as PostgreSQLUserWhereUniqueInputObjectSchema } from './objects/PostgreSQLUserWhereUniqueInput.schema';
+
+export const PostgreSQLUserFindUniqueOrThrowSchema: z.ZodType<Prisma.PostgreSQLUserFindUniqueOrThrowArgs> = z.object({ select: PostgreSQLUserSelectObjectSchema.optional(), include: PostgreSQLUserIncludeObjectSchema.optional(), where: PostgreSQLUserWhereUniqueInputObjectSchema }).strict() as unknown as z.ZodType<Prisma.PostgreSQLUserFindUniqueOrThrowArgs>;
+
+export const PostgreSQLUserFindUniqueOrThrowZodSchema = z.object({ select: PostgreSQLUserSelectObjectSchema.optional(), include: PostgreSQLUserIncludeObjectSchema.optional(), where: PostgreSQLUserWhereUniqueInputObjectSchema }).strict();

package/tests/multi-provider/schemas/postgresql/generated/schemas/findUniquePostgreSQLPost.schema.ts

@@ -0,0 +1,9 @@
+import type { Prisma } from '@prisma/client';
+import * as z from 'zod';
+import { PostgreSQLPostSelectObjectSchema as PostgreSQLPostSelectObjectSchema } from './objects/PostgreSQLPostSelect.schema';
+import { PostgreSQLPostIncludeObjectSchema as PostgreSQLPostIncludeObjectSchema } from './objects/PostgreSQLPostInclude.schema';
+import { PostgreSQLPostWhereUniqueInputObjectSchema as PostgreSQLPostWhereUniqueInputObjectSchema } from './objects/PostgreSQLPostWhereUniqueInput.schema';
+
+export const PostgreSQLPostFindUniqueSchema: z.ZodType<Prisma.PostgreSQLPostFindUniqueArgs> = z.object({ select: PostgreSQLPostSelectObjectSchema.optional(), include: PostgreSQLPostIncludeObjectSchema.optional(), where: PostgreSQLPostWhereUniqueInputObjectSchema }).strict() as unknown as z.ZodType<Prisma.PostgreSQLPostFindUniqueArgs>;
+
+export const PostgreSQLPostFindUniqueZodSchema = z.object({ select: PostgreSQLPostSelectObjectSchema.optional(), include: PostgreSQLPostIncludeObjectSchema.optional(), where: PostgreSQLPostWhereUniqueInputObjectSchema }).strict();

package/tests/multi-provider/schemas/postgresql/generated/schemas/findUniquePostgreSQLProfile.schema.ts

@@ -0,0 +1,9 @@
+import type { Prisma } from '@prisma/client';
+import * as z from 'zod';
+import { PostgreSQLProfileSelectObjectSchema as PostgreSQLProfileSelectObjectSchema } from './objects/PostgreSQLProfileSelect.schema';
+import { PostgreSQLProfileIncludeObjectSchema as PostgreSQLProfileIncludeObjectSchema } from './objects/PostgreSQLProfileInclude.schema';
+import { PostgreSQLProfileWhereUniqueInputObjectSchema as PostgreSQLProfileWhereUniqueInputObjectSchema } from './objects/PostgreSQLProfileWhereUniqueInput.schema';
+
+export const PostgreSQLProfileFindUniqueSchema: z.ZodType<Prisma.PostgreSQLProfileFindUniqueArgs> = z.object({ select: PostgreSQLProfileSelectObjectSchema.optional(), include: PostgreSQLProfileIncludeObjectSchema.optional(), where: PostgreSQLProfileWhereUniqueInputObjectSchema }).strict() as unknown as z.ZodType<Prisma.PostgreSQLProfileFindUniqueArgs>;
+
+export const PostgreSQLProfileFindUniqueZodSchema = z.object({ select: PostgreSQLProfileSelectObjectSchema.optional(), include: PostgreSQLProfileIncludeObjectSchema.optional(), where: PostgreSQLProfileWhereUniqueInputObjectSchema }).strict();

package/tests/multi-provider/schemas/postgresql/generated/schemas/findUniquePostgreSQLUser.schema.ts

@@ -0,0 +1,9 @@
+import type { Prisma } from '@prisma/client';
+import * as z from 'zod';
+import { PostgreSQLUserSelectObjectSchema as PostgreSQLUserSelectObjectSchema } from './objects/PostgreSQLUserSelect.schema';
+import { PostgreSQLUserIncludeObjectSchema as PostgreSQLUserIncludeObjectSchema } from './objects/PostgreSQLUserInclude.schema';
+import { PostgreSQLUserWhereUniqueInputObjectSchema as PostgreSQLUserWhereUniqueInputObjectSchema } from './objects/PostgreSQLUserWhereUniqueInput.schema';
+
+export const PostgreSQLUserFindUniqueSchema: z.ZodType<Prisma.PostgreSQLUserFindUniqueArgs> = z.object({ select: PostgreSQLUserSelectObjectSchema.optional(), include: PostgreSQLUserIncludeObjectSchema.optional(), where: PostgreSQLUserWhereUniqueInputObjectSchema }).strict() as unknown as z.ZodType<Prisma.PostgreSQLUserFindUniqueArgs>;
+
+export const PostgreSQLUserFindUniqueZodSchema = z.object({ select: PostgreSQLUserSelectObjectSchema.optional(), include: PostgreSQLUserIncludeObjectSchema.optional(), where: PostgreSQLUserWhereUniqueInputObjectSchema }).strict();

package/tests/multi-provider/schemas/postgresql/generated/schemas/groupByPostgreSQLPost.schema.ts

@@ -0,0 +1,15 @@
+import type { Prisma } from '@prisma/client';
+import * as z from 'zod';
+import { PostgreSQLPostWhereInputObjectSchema as PostgreSQLPostWhereInputObjectSchema } from './objects/PostgreSQLPostWhereInput.schema';
+import { PostgreSQLPostOrderByWithAggregationInputObjectSchema as PostgreSQLPostOrderByWithAggregationInputObjectSchema } from './objects/PostgreSQLPostOrderByWithAggregationInput.schema';
+import { PostgreSQLPostScalarWhereWithAggregatesInputObjectSchema as PostgreSQLPostScalarWhereWithAggregatesInputObjectSchema } from './objects/PostgreSQLPostScalarWhereWithAggregatesInput.schema';
+import { PostgreSQLPostScalarFieldEnumSchema } from './enums/PostgreSQLPostScalarFieldEnum.schema';
+import { PostgreSQLPostCountAggregateInputObjectSchema as PostgreSQLPostCountAggregateInputObjectSchema } from './objects/PostgreSQLPostCountAggregateInput.schema';
+import { PostgreSQLPostMinAggregateInputObjectSchema as PostgreSQLPostMinAggregateInputObjectSchema } from './objects/PostgreSQLPostMinAggregateInput.schema';
+import { PostgreSQLPostMaxAggregateInputObjectSchema as PostgreSQLPostMaxAggregateInputObjectSchema } from './objects/PostgreSQLPostMaxAggregateInput.schema';
+import { PostgreSQLPostAvgAggregateInputObjectSchema as PostgreSQLPostAvgAggregateInputObjectSchema } from './objects/PostgreSQLPostAvgAggregateInput.schema';
+import { PostgreSQLPostSumAggregateInputObjectSchema as PostgreSQLPostSumAggregateInputObjectSchema } from './objects/PostgreSQLPostSumAggregateInput.schema';
+
+export const PostgreSQLPostGroupBySchema: z.ZodType<Prisma.PostgreSQLPostGroupByArgs> = z.object({ where: PostgreSQLPostWhereInputObjectSchema.optional(), orderBy: z.union([PostgreSQLPostOrderByWithAggregationInputObjectSchema, PostgreSQLPostOrderByWithAggregationInputObjectSchema.array()]).optional(), having: PostgreSQLPostScalarWhereWithAggregatesInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), by: z.array(PostgreSQLPostScalarFieldEnumSchema), _count: z.union([ z.literal(true), PostgreSQLPostCountAggregateInputObjectSchema ]).optional(), _min: PostgreSQLPostMinAggregateInputObjectSchema.optional(), _max: PostgreSQLPostMaxAggregateInputObjectSchema.optional(), _avg: PostgreSQLPostAvgAggregateInputObjectSchema.optional(), _sum: PostgreSQLPostSumAggregateInputObjectSchema.optional() }).strict() as unknown as z.ZodType<Prisma.PostgreSQLPostGroupByArgs>;
+
+export const PostgreSQLPostGroupByZodSchema = z.object({ where: PostgreSQLPostWhereInputObjectSchema.optional(), orderBy: z.union([PostgreSQLPostOrderByWithAggregationInputObjectSchema, PostgreSQLPostOrderByWithAggregationInputObjectSchema.array()]).optional(), having: PostgreSQLPostScalarWhereWithAggregatesInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), by: z.array(PostgreSQLPostScalarFieldEnumSchema), _count: z.union([ z.literal(true), PostgreSQLPostCountAggregateInputObjectSchema ]).optional(), _min: PostgreSQLPostMinAggregateInputObjectSchema.optional(), _max: PostgreSQLPostMaxAggregateInputObjectSchema.optional(), _avg: PostgreSQLPostAvgAggregateInputObjectSchema.optional(), _sum: PostgreSQLPostSumAggregateInputObjectSchema.optional() }).strict();

package/tests/multi-provider/schemas/postgresql/generated/schemas/groupByPostgreSQLProfile.schema.ts

@@ -0,0 +1,15 @@
+import type { Prisma } from '@prisma/client';
+import * as z from 'zod';
+import { PostgreSQLProfileWhereInputObjectSchema as PostgreSQLProfileWhereInputObjectSchema } from './objects/PostgreSQLProfileWhereInput.schema';
+import { PostgreSQLProfileOrderByWithAggregationInputObjectSchema as PostgreSQLProfileOrderByWithAggregationInputObjectSchema } from './objects/PostgreSQLProfileOrderByWithAggregationInput.schema';
+import { PostgreSQLProfileScalarWhereWithAggregatesInputObjectSchema as PostgreSQLProfileScalarWhereWithAggregatesInputObjectSchema } from './objects/PostgreSQLProfileScalarWhereWithAggregatesInput.schema';
+import { PostgreSQLProfileScalarFieldEnumSchema } from './enums/PostgreSQLProfileScalarFieldEnum.schema';
+import { PostgreSQLProfileCountAggregateInputObjectSchema as PostgreSQLProfileCountAggregateInputObjectSchema } from './objects/PostgreSQLProfileCountAggregateInput.schema';
+import { PostgreSQLProfileMinAggregateInputObjectSchema as PostgreSQLProfileMinAggregateInputObjectSchema } from './objects/PostgreSQLProfileMinAggregateInput.schema';
+import { PostgreSQLProfileMaxAggregateInputObjectSchema as PostgreSQLProfileMaxAggregateInputObjectSchema } from './objects/PostgreSQLProfileMaxAggregateInput.schema';
+import { PostgreSQLProfileAvgAggregateInputObjectSchema as PostgreSQLProfileAvgAggregateInputObjectSchema } from './objects/PostgreSQLProfileAvgAggregateInput.schema';
+import { PostgreSQLProfileSumAggregateInputObjectSchema as PostgreSQLProfileSumAggregateInputObjectSchema } from './objects/PostgreSQLProfileSumAggregateInput.schema';
+
+export const PostgreSQLProfileGroupBySchema: z.ZodType<Prisma.PostgreSQLProfileGroupByArgs> = z.object({ where: PostgreSQLProfileWhereInputObjectSchema.optional(), orderBy: z.union([PostgreSQLProfileOrderByWithAggregationInputObjectSchema, PostgreSQLProfileOrderByWithAggregationInputObjectSchema.array()]).optional(), having: PostgreSQLProfileScalarWhereWithAggregatesInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), by: z.array(PostgreSQLProfileScalarFieldEnumSchema), _count: z.union([ z.literal(true), PostgreSQLProfileCountAggregateInputObjectSchema ]).optional(), _min: PostgreSQLProfileMinAggregateInputObjectSchema.optional(), _max: PostgreSQLProfileMaxAggregateInputObjectSchema.optional(), _avg: PostgreSQLProfileAvgAggregateInputObjectSchema.optional(), _sum: PostgreSQLProfileSumAggregateInputObjectSchema.optional() }).strict() as unknown as z.ZodType<Prisma.PostgreSQLProfileGroupByArgs>;
+
+export const PostgreSQLProfileGroupByZodSchema = z.object({ where: PostgreSQLProfileWhereInputObjectSchema.optional(), orderBy: z.union([PostgreSQLProfileOrderByWithAggregationInputObjectSchema, PostgreSQLProfileOrderByWithAggregationInputObjectSchema.array()]).optional(), having: PostgreSQLProfileScalarWhereWithAggregatesInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), by: z.array(PostgreSQLProfileScalarFieldEnumSchema), _count: z.union([ z.literal(true), PostgreSQLProfileCountAggregateInputObjectSchema ]).optional(), _min: PostgreSQLProfileMinAggregateInputObjectSchema.optional(), _max: PostgreSQLProfileMaxAggregateInputObjectSchema.optional(), _avg: PostgreSQLProfileAvgAggregateInputObjectSchema.optional(), _sum: PostgreSQLProfileSumAggregateInputObjectSchema.optional() }).strict();

package/tests/multi-provider/schemas/postgresql/generated/schemas/groupByPostgreSQLUser.schema.ts

@@ -0,0 +1,15 @@
+import type { Prisma } from '@prisma/client';
+import * as z from 'zod';
+import { PostgreSQLUserWhereInputObjectSchema as PostgreSQLUserWhereInputObjectSchema } from './objects/PostgreSQLUserWhereInput.schema';
+import { PostgreSQLUserOrderByWithAggregationInputObjectSchema as PostgreSQLUserOrderByWithAggregationInputObjectSchema } from './objects/PostgreSQLUserOrderByWithAggregationInput.schema';
+import { PostgreSQLUserScalarWhereWithAggregatesInputObjectSchema as PostgreSQLUserScalarWhereWithAggregatesInputObjectSchema } from './objects/PostgreSQLUserScalarWhereWithAggregatesInput.schema';
+import { PostgreSQLUserScalarFieldEnumSchema } from './enums/PostgreSQLUserScalarFieldEnum.schema';
+import { PostgreSQLUserCountAggregateInputObjectSchema as PostgreSQLUserCountAggregateInputObjectSchema } from './objects/PostgreSQLUserCountAggregateInput.schema';
+import { PostgreSQLUserMinAggregateInputObjectSchema as PostgreSQLUserMinAggregateInputObjectSchema } from './objects/PostgreSQLUserMinAggregateInput.schema';
+import { PostgreSQLUserMaxAggregateInputObjectSchema as PostgreSQLUserMaxAggregateInputObjectSchema } from './objects/PostgreSQLUserMaxAggregateInput.schema';
+import { PostgreSQLUserAvgAggregateInputObjectSchema as PostgreSQLUserAvgAggregateInputObjectSchema } from './objects/PostgreSQLUserAvgAggregateInput.schema';
+import { PostgreSQLUserSumAggregateInputObjectSchema as PostgreSQLUserSumAggregateInputObjectSchema } from './objects/PostgreSQLUserSumAggregateInput.schema';
+
+export const PostgreSQLUserGroupBySchema: z.ZodType<Prisma.PostgreSQLUserGroupByArgs> = z.object({ where: PostgreSQLUserWhereInputObjectSchema.optional(), orderBy: z.union([PostgreSQLUserOrderByWithAggregationInputObjectSchema, PostgreSQLUserOrderByWithAggregationInputObjectSchema.array()]).optional(), having: PostgreSQLUserScalarWhereWithAggregatesInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), by: z.array(PostgreSQLUserScalarFieldEnumSchema), _count: z.union([ z.literal(true), PostgreSQLUserCountAggregateInputObjectSchema ]).optional(), _min: PostgreSQLUserMinAggregateInputObjectSchema.optional(), _max: PostgreSQLUserMaxAggregateInputObjectSchema.optional(), _avg: PostgreSQLUserAvgAggregateInputObjectSchema.optional(), _sum: PostgreSQLUserSumAggregateInputObjectSchema.optional() }).strict() as unknown as z.ZodType<Prisma.PostgreSQLUserGroupByArgs>;
+
+export const PostgreSQLUserGroupByZodSchema = z.object({ where: PostgreSQLUserWhereInputObjectSchema.optional(), orderBy: z.union([PostgreSQLUserOrderByWithAggregationInputObjectSchema, PostgreSQLUserOrderByWithAggregationInputObjectSchema.array()]).optional(), having: PostgreSQLUserScalarWhereWithAggregatesInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), by: z.array(PostgreSQLUserScalarFieldEnumSchema), _count: z.union([ z.literal(true), PostgreSQLUserCountAggregateInputObjectSchema ]).optional(), _min: PostgreSQLUserMinAggregateInputObjectSchema.optional(), _max: PostgreSQLUserMaxAggregateInputObjectSchema.optional(), _avg: PostgreSQLUserAvgAggregateInputObjectSchema.optional(), _sum: PostgreSQLUserSumAggregateInputObjectSchema.optional() }).strict();