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

package/tests/multi-provider/schemas/sqlserver/generated/schemas/findFirstSQLServerUser.schema.ts

@@ -0,0 +1,32 @@
+import type { Prisma } from '@prisma/client';
+import * as z from 'zod';
+import { SQLServerUserIncludeObjectSchema as SQLServerUserIncludeObjectSchema } from './objects/SQLServerUserInclude.schema';
+import { SQLServerUserOrderByWithRelationInputObjectSchema as SQLServerUserOrderByWithRelationInputObjectSchema } from './objects/SQLServerUserOrderByWithRelationInput.schema';
+import { SQLServerUserWhereInputObjectSchema as SQLServerUserWhereInputObjectSchema } from './objects/SQLServerUserWhereInput.schema';
+import { SQLServerUserWhereUniqueInputObjectSchema as SQLServerUserWhereUniqueInputObjectSchema } from './objects/SQLServerUserWhereUniqueInput.schema';
+import { SQLServerUserScalarFieldEnumSchema } from './enums/SQLServerUserScalarFieldEnum.schema';
+import { SQLServerPostFindManySchema } from './findManySQLServerPost.schema';
+import { SQLServerUserCountOutputTypeArgsObjectSchema as SQLServerUserCountOutputTypeArgsObjectSchema } from './objects/SQLServerUserCountOutputTypeArgs.schema';
+
+// Select schema needs to be in file to prevent circular imports
+//------------------------------------------------------
+
+export const SQLServerUserFindFirstSelectSchema: z.ZodType<Prisma.SQLServerUserSelect> = z.object({
+    id: z.boolean().optional(),
+    email: z.boolean().optional(),
+    name: z.boolean().optional(),
+    posts: z.union([z.boolean(), z.lazy(() => SQLServerPostFindManySchema)]).optional(),
+    _count: z.union([z.boolean(), z.lazy(() => SQLServerUserCountOutputTypeArgsObjectSchema)]).optional()
+  }).strict() as unknown as z.ZodType<Prisma.SQLServerUserSelect>;
+
+export const SQLServerUserFindFirstSelectZodSchema = z.object({
+    id: z.boolean().optional(),
+    email: z.boolean().optional(),
+    name: z.boolean().optional(),
+    posts: z.union([z.boolean(), z.lazy(() => SQLServerPostFindManySchema)]).optional(),
+    _count: z.union([z.boolean(), z.lazy(() => SQLServerUserCountOutputTypeArgsObjectSchema)]).optional()
+  }).strict();
+
+export const SQLServerUserFindFirstSchema: z.ZodType<Prisma.SQLServerUserFindFirstArgs> = z.object({ select: SQLServerUserFindFirstSelectSchema.optional(), include: z.lazy(() => SQLServerUserIncludeObjectSchema.optional()), orderBy: z.union([SQLServerUserOrderByWithRelationInputObjectSchema, SQLServerUserOrderByWithRelationInputObjectSchema.array()]).optional(), where: SQLServerUserWhereInputObjectSchema.optional(), cursor: SQLServerUserWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), distinct: z.union([SQLServerUserScalarFieldEnumSchema, SQLServerUserScalarFieldEnumSchema.array()]).optional() }).strict() as unknown as z.ZodType<Prisma.SQLServerUserFindFirstArgs>;
+
+export const SQLServerUserFindFirstZodSchema = z.object({ select: SQLServerUserFindFirstSelectSchema.optional(), include: z.lazy(() => SQLServerUserIncludeObjectSchema.optional()), orderBy: z.union([SQLServerUserOrderByWithRelationInputObjectSchema, SQLServerUserOrderByWithRelationInputObjectSchema.array()]).optional(), where: SQLServerUserWhereInputObjectSchema.optional(), cursor: SQLServerUserWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), distinct: z.union([SQLServerUserScalarFieldEnumSchema, SQLServerUserScalarFieldEnumSchema.array()]).optional() }).strict();

package/tests/multi-provider/schemas/sqlserver/generated/schemas/findManySQLServerPost.schema.ts

@@ -0,0 +1,35 @@
+import type { Prisma } from '@prisma/client';
+import * as z from 'zod';
+import { SQLServerPostIncludeObjectSchema as SQLServerPostIncludeObjectSchema } from './objects/SQLServerPostInclude.schema';
+import { SQLServerPostOrderByWithRelationInputObjectSchema as SQLServerPostOrderByWithRelationInputObjectSchema } from './objects/SQLServerPostOrderByWithRelationInput.schema';
+import { SQLServerPostWhereInputObjectSchema as SQLServerPostWhereInputObjectSchema } from './objects/SQLServerPostWhereInput.schema';
+import { SQLServerPostWhereUniqueInputObjectSchema as SQLServerPostWhereUniqueInputObjectSchema } from './objects/SQLServerPostWhereUniqueInput.schema';
+import { SQLServerPostScalarFieldEnumSchema } from './enums/SQLServerPostScalarFieldEnum.schema';
+import { SQLServerUserArgsObjectSchema as SQLServerUserArgsObjectSchema } from './objects/SQLServerUserArgs.schema';
+
+// Select schema needs to be in file to prevent circular imports
+//------------------------------------------------------
+
+export const SQLServerPostFindManySelectSchema: z.ZodType<Prisma.SQLServerPostSelect> = z.object({
+    id: z.boolean().optional(),
+    title: z.boolean().optional(),
+    content: z.boolean().optional(),
+    published: z.boolean().optional(),
+    createdAt: z.boolean().optional(),
+    author: z.union([z.boolean(), z.lazy(() => SQLServerUserArgsObjectSchema)]).optional(),
+    authorId: z.boolean().optional()
+  }).strict() as unknown as z.ZodType<Prisma.SQLServerPostSelect>;
+
+export const SQLServerPostFindManySelectZodSchema = z.object({
+    id: z.boolean().optional(),
+    title: z.boolean().optional(),
+    content: z.boolean().optional(),
+    published: z.boolean().optional(),
+    createdAt: z.boolean().optional(),
+    author: z.union([z.boolean(), z.lazy(() => SQLServerUserArgsObjectSchema)]).optional(),
+    authorId: z.boolean().optional()
+  }).strict();
+
+export const SQLServerPostFindManySchema: z.ZodType<Prisma.SQLServerPostFindManyArgs> = z.object({ select: SQLServerPostFindManySelectSchema.optional(), include: z.lazy(() => SQLServerPostIncludeObjectSchema.optional()), orderBy: z.union([SQLServerPostOrderByWithRelationInputObjectSchema, SQLServerPostOrderByWithRelationInputObjectSchema.array()]).optional(), where: SQLServerPostWhereInputObjectSchema.optional(), cursor: SQLServerPostWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), distinct: z.union([SQLServerPostScalarFieldEnumSchema, SQLServerPostScalarFieldEnumSchema.array()]).optional() }).strict() as unknown as z.ZodType<Prisma.SQLServerPostFindManyArgs>;
+
+export const SQLServerPostFindManyZodSchema = z.object({ select: SQLServerPostFindManySelectSchema.optional(), include: z.lazy(() => SQLServerPostIncludeObjectSchema.optional()), orderBy: z.union([SQLServerPostOrderByWithRelationInputObjectSchema, SQLServerPostOrderByWithRelationInputObjectSchema.array()]).optional(), where: SQLServerPostWhereInputObjectSchema.optional(), cursor: SQLServerPostWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), distinct: z.union([SQLServerPostScalarFieldEnumSchema, SQLServerPostScalarFieldEnumSchema.array()]).optional() }).strict();

package/tests/multi-provider/schemas/sqlserver/generated/schemas/findManySQLServerUser.schema.ts

@@ -0,0 +1,32 @@
+import type { Prisma } from '@prisma/client';
+import * as z from 'zod';
+import { SQLServerUserIncludeObjectSchema as SQLServerUserIncludeObjectSchema } from './objects/SQLServerUserInclude.schema';
+import { SQLServerUserOrderByWithRelationInputObjectSchema as SQLServerUserOrderByWithRelationInputObjectSchema } from './objects/SQLServerUserOrderByWithRelationInput.schema';
+import { SQLServerUserWhereInputObjectSchema as SQLServerUserWhereInputObjectSchema } from './objects/SQLServerUserWhereInput.schema';
+import { SQLServerUserWhereUniqueInputObjectSchema as SQLServerUserWhereUniqueInputObjectSchema } from './objects/SQLServerUserWhereUniqueInput.schema';
+import { SQLServerUserScalarFieldEnumSchema } from './enums/SQLServerUserScalarFieldEnum.schema';
+import { SQLServerPostFindManySchema } from './findManySQLServerPost.schema';
+import { SQLServerUserCountOutputTypeArgsObjectSchema as SQLServerUserCountOutputTypeArgsObjectSchema } from './objects/SQLServerUserCountOutputTypeArgs.schema';
+
+// Select schema needs to be in file to prevent circular imports
+//------------------------------------------------------
+
+export const SQLServerUserFindManySelectSchema: z.ZodType<Prisma.SQLServerUserSelect> = z.object({
+    id: z.boolean().optional(),
+    email: z.boolean().optional(),
+    name: z.boolean().optional(),
+    posts: z.union([z.boolean(), z.lazy(() => SQLServerPostFindManySchema)]).optional(),
+    _count: z.union([z.boolean(), z.lazy(() => SQLServerUserCountOutputTypeArgsObjectSchema)]).optional()
+  }).strict() as unknown as z.ZodType<Prisma.SQLServerUserSelect>;
+
+export const SQLServerUserFindManySelectZodSchema = z.object({
+    id: z.boolean().optional(),
+    email: z.boolean().optional(),
+    name: z.boolean().optional(),
+    posts: z.union([z.boolean(), z.lazy(() => SQLServerPostFindManySchema)]).optional(),
+    _count: z.union([z.boolean(), z.lazy(() => SQLServerUserCountOutputTypeArgsObjectSchema)]).optional()
+  }).strict();
+
+export const SQLServerUserFindManySchema: z.ZodType<Prisma.SQLServerUserFindManyArgs> = z.object({ select: SQLServerUserFindManySelectSchema.optional(), include: z.lazy(() => SQLServerUserIncludeObjectSchema.optional()), orderBy: z.union([SQLServerUserOrderByWithRelationInputObjectSchema, SQLServerUserOrderByWithRelationInputObjectSchema.array()]).optional(), where: SQLServerUserWhereInputObjectSchema.optional(), cursor: SQLServerUserWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), distinct: z.union([SQLServerUserScalarFieldEnumSchema, SQLServerUserScalarFieldEnumSchema.array()]).optional() }).strict() as unknown as z.ZodType<Prisma.SQLServerUserFindManyArgs>;
+
+export const SQLServerUserFindManyZodSchema = z.object({ select: SQLServerUserFindManySelectSchema.optional(), include: z.lazy(() => SQLServerUserIncludeObjectSchema.optional()), orderBy: z.union([SQLServerUserOrderByWithRelationInputObjectSchema, SQLServerUserOrderByWithRelationInputObjectSchema.array()]).optional(), where: SQLServerUserWhereInputObjectSchema.optional(), cursor: SQLServerUserWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), distinct: z.union([SQLServerUserScalarFieldEnumSchema, SQLServerUserScalarFieldEnumSchema.array()]).optional() }).strict();

package/tests/multi-provider/schemas/sqlserver/generated/schemas/findUniqueOrThrowSQLServerPost.schema.ts

@@ -0,0 +1,9 @@
+import type { Prisma } from '@prisma/client';
+import * as z from 'zod';
+import { SQLServerPostSelectObjectSchema as SQLServerPostSelectObjectSchema } from './objects/SQLServerPostSelect.schema';
+import { SQLServerPostIncludeObjectSchema as SQLServerPostIncludeObjectSchema } from './objects/SQLServerPostInclude.schema';
+import { SQLServerPostWhereUniqueInputObjectSchema as SQLServerPostWhereUniqueInputObjectSchema } from './objects/SQLServerPostWhereUniqueInput.schema';
+
+export const SQLServerPostFindUniqueOrThrowSchema: z.ZodType<Prisma.SQLServerPostFindUniqueOrThrowArgs> = z.object({ select: SQLServerPostSelectObjectSchema.optional(), include: SQLServerPostIncludeObjectSchema.optional(), where: SQLServerPostWhereUniqueInputObjectSchema }).strict() as unknown as z.ZodType<Prisma.SQLServerPostFindUniqueOrThrowArgs>;
+
+export const SQLServerPostFindUniqueOrThrowZodSchema = z.object({ select: SQLServerPostSelectObjectSchema.optional(), include: SQLServerPostIncludeObjectSchema.optional(), where: SQLServerPostWhereUniqueInputObjectSchema }).strict();

package/tests/multi-provider/schemas/sqlserver/generated/schemas/findUniqueOrThrowSQLServerUser.schema.ts

@@ -0,0 +1,9 @@
+import type { Prisma } from '@prisma/client';
+import * as z from 'zod';
+import { SQLServerUserSelectObjectSchema as SQLServerUserSelectObjectSchema } from './objects/SQLServerUserSelect.schema';
+import { SQLServerUserIncludeObjectSchema as SQLServerUserIncludeObjectSchema } from './objects/SQLServerUserInclude.schema';
+import { SQLServerUserWhereUniqueInputObjectSchema as SQLServerUserWhereUniqueInputObjectSchema } from './objects/SQLServerUserWhereUniqueInput.schema';
+
+export const SQLServerUserFindUniqueOrThrowSchema: z.ZodType<Prisma.SQLServerUserFindUniqueOrThrowArgs> = z.object({ select: SQLServerUserSelectObjectSchema.optional(), include: SQLServerUserIncludeObjectSchema.optional(), where: SQLServerUserWhereUniqueInputObjectSchema }).strict() as unknown as z.ZodType<Prisma.SQLServerUserFindUniqueOrThrowArgs>;
+
+export const SQLServerUserFindUniqueOrThrowZodSchema = z.object({ select: SQLServerUserSelectObjectSchema.optional(), include: SQLServerUserIncludeObjectSchema.optional(), where: SQLServerUserWhereUniqueInputObjectSchema }).strict();

package/tests/multi-provider/schemas/sqlserver/generated/schemas/findUniqueSQLServerPost.schema.ts

@@ -0,0 +1,9 @@
+import type { Prisma } from '@prisma/client';
+import * as z from 'zod';
+import { SQLServerPostSelectObjectSchema as SQLServerPostSelectObjectSchema } from './objects/SQLServerPostSelect.schema';
+import { SQLServerPostIncludeObjectSchema as SQLServerPostIncludeObjectSchema } from './objects/SQLServerPostInclude.schema';
+import { SQLServerPostWhereUniqueInputObjectSchema as SQLServerPostWhereUniqueInputObjectSchema } from './objects/SQLServerPostWhereUniqueInput.schema';
+
+export const SQLServerPostFindUniqueSchema: z.ZodType<Prisma.SQLServerPostFindUniqueArgs> = z.object({ select: SQLServerPostSelectObjectSchema.optional(), include: SQLServerPostIncludeObjectSchema.optional(), where: SQLServerPostWhereUniqueInputObjectSchema }).strict() as unknown as z.ZodType<Prisma.SQLServerPostFindUniqueArgs>;
+
+export const SQLServerPostFindUniqueZodSchema = z.object({ select: SQLServerPostSelectObjectSchema.optional(), include: SQLServerPostIncludeObjectSchema.optional(), where: SQLServerPostWhereUniqueInputObjectSchema }).strict();

package/tests/multi-provider/schemas/sqlserver/generated/schemas/findUniqueSQLServerUser.schema.ts

@@ -0,0 +1,9 @@
+import type { Prisma } from '@prisma/client';
+import * as z from 'zod';
+import { SQLServerUserSelectObjectSchema as SQLServerUserSelectObjectSchema } from './objects/SQLServerUserSelect.schema';
+import { SQLServerUserIncludeObjectSchema as SQLServerUserIncludeObjectSchema } from './objects/SQLServerUserInclude.schema';
+import { SQLServerUserWhereUniqueInputObjectSchema as SQLServerUserWhereUniqueInputObjectSchema } from './objects/SQLServerUserWhereUniqueInput.schema';
+
+export const SQLServerUserFindUniqueSchema: z.ZodType<Prisma.SQLServerUserFindUniqueArgs> = z.object({ select: SQLServerUserSelectObjectSchema.optional(), include: SQLServerUserIncludeObjectSchema.optional(), where: SQLServerUserWhereUniqueInputObjectSchema }).strict() as unknown as z.ZodType<Prisma.SQLServerUserFindUniqueArgs>;
+
+export const SQLServerUserFindUniqueZodSchema = z.object({ select: SQLServerUserSelectObjectSchema.optional(), include: SQLServerUserIncludeObjectSchema.optional(), where: SQLServerUserWhereUniqueInputObjectSchema }).strict();

package/tests/multi-provider/schemas/sqlserver/generated/schemas/groupBySQLServerPost.schema.ts

@@ -0,0 +1,15 @@
+import type { Prisma } from '@prisma/client';
+import * as z from 'zod';
+import { SQLServerPostWhereInputObjectSchema as SQLServerPostWhereInputObjectSchema } from './objects/SQLServerPostWhereInput.schema';
+import { SQLServerPostOrderByWithAggregationInputObjectSchema as SQLServerPostOrderByWithAggregationInputObjectSchema } from './objects/SQLServerPostOrderByWithAggregationInput.schema';
+import { SQLServerPostScalarWhereWithAggregatesInputObjectSchema as SQLServerPostScalarWhereWithAggregatesInputObjectSchema } from './objects/SQLServerPostScalarWhereWithAggregatesInput.schema';
+import { SQLServerPostScalarFieldEnumSchema } from './enums/SQLServerPostScalarFieldEnum.schema';
+import { SQLServerPostCountAggregateInputObjectSchema as SQLServerPostCountAggregateInputObjectSchema } from './objects/SQLServerPostCountAggregateInput.schema';
+import { SQLServerPostMinAggregateInputObjectSchema as SQLServerPostMinAggregateInputObjectSchema } from './objects/SQLServerPostMinAggregateInput.schema';
+import { SQLServerPostMaxAggregateInputObjectSchema as SQLServerPostMaxAggregateInputObjectSchema } from './objects/SQLServerPostMaxAggregateInput.schema';
+import { SQLServerPostAvgAggregateInputObjectSchema as SQLServerPostAvgAggregateInputObjectSchema } from './objects/SQLServerPostAvgAggregateInput.schema';
+import { SQLServerPostSumAggregateInputObjectSchema as SQLServerPostSumAggregateInputObjectSchema } from './objects/SQLServerPostSumAggregateInput.schema';
+
+export const SQLServerPostGroupBySchema: z.ZodType<Prisma.SQLServerPostGroupByArgs> = z.object({ where: SQLServerPostWhereInputObjectSchema.optional(), orderBy: z.union([SQLServerPostOrderByWithAggregationInputObjectSchema, SQLServerPostOrderByWithAggregationInputObjectSchema.array()]).optional(), having: SQLServerPostScalarWhereWithAggregatesInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), by: z.array(SQLServerPostScalarFieldEnumSchema), _count: z.union([ z.literal(true), SQLServerPostCountAggregateInputObjectSchema ]).optional(), _min: SQLServerPostMinAggregateInputObjectSchema.optional(), _max: SQLServerPostMaxAggregateInputObjectSchema.optional(), _avg: SQLServerPostAvgAggregateInputObjectSchema.optional(), _sum: SQLServerPostSumAggregateInputObjectSchema.optional() }).strict() as unknown as z.ZodType<Prisma.SQLServerPostGroupByArgs>;
+
+export const SQLServerPostGroupByZodSchema = z.object({ where: SQLServerPostWhereInputObjectSchema.optional(), orderBy: z.union([SQLServerPostOrderByWithAggregationInputObjectSchema, SQLServerPostOrderByWithAggregationInputObjectSchema.array()]).optional(), having: SQLServerPostScalarWhereWithAggregatesInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), by: z.array(SQLServerPostScalarFieldEnumSchema), _count: z.union([ z.literal(true), SQLServerPostCountAggregateInputObjectSchema ]).optional(), _min: SQLServerPostMinAggregateInputObjectSchema.optional(), _max: SQLServerPostMaxAggregateInputObjectSchema.optional(), _avg: SQLServerPostAvgAggregateInputObjectSchema.optional(), _sum: SQLServerPostSumAggregateInputObjectSchema.optional() }).strict();

package/tests/multi-provider/schemas/sqlserver/generated/schemas/groupBySQLServerUser.schema.ts

@@ -0,0 +1,15 @@
+import type { Prisma } from '@prisma/client';
+import * as z from 'zod';
+import { SQLServerUserWhereInputObjectSchema as SQLServerUserWhereInputObjectSchema } from './objects/SQLServerUserWhereInput.schema';
+import { SQLServerUserOrderByWithAggregationInputObjectSchema as SQLServerUserOrderByWithAggregationInputObjectSchema } from './objects/SQLServerUserOrderByWithAggregationInput.schema';
+import { SQLServerUserScalarWhereWithAggregatesInputObjectSchema as SQLServerUserScalarWhereWithAggregatesInputObjectSchema } from './objects/SQLServerUserScalarWhereWithAggregatesInput.schema';
+import { SQLServerUserScalarFieldEnumSchema } from './enums/SQLServerUserScalarFieldEnum.schema';
+import { SQLServerUserCountAggregateInputObjectSchema as SQLServerUserCountAggregateInputObjectSchema } from './objects/SQLServerUserCountAggregateInput.schema';
+import { SQLServerUserMinAggregateInputObjectSchema as SQLServerUserMinAggregateInputObjectSchema } from './objects/SQLServerUserMinAggregateInput.schema';
+import { SQLServerUserMaxAggregateInputObjectSchema as SQLServerUserMaxAggregateInputObjectSchema } from './objects/SQLServerUserMaxAggregateInput.schema';
+import { SQLServerUserAvgAggregateInputObjectSchema as SQLServerUserAvgAggregateInputObjectSchema } from './objects/SQLServerUserAvgAggregateInput.schema';
+import { SQLServerUserSumAggregateInputObjectSchema as SQLServerUserSumAggregateInputObjectSchema } from './objects/SQLServerUserSumAggregateInput.schema';
+
+export const SQLServerUserGroupBySchema: z.ZodType<Prisma.SQLServerUserGroupByArgs> = z.object({ where: SQLServerUserWhereInputObjectSchema.optional(), orderBy: z.union([SQLServerUserOrderByWithAggregationInputObjectSchema, SQLServerUserOrderByWithAggregationInputObjectSchema.array()]).optional(), having: SQLServerUserScalarWhereWithAggregatesInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), by: z.array(SQLServerUserScalarFieldEnumSchema), _count: z.union([ z.literal(true), SQLServerUserCountAggregateInputObjectSchema ]).optional(), _min: SQLServerUserMinAggregateInputObjectSchema.optional(), _max: SQLServerUserMaxAggregateInputObjectSchema.optional(), _avg: SQLServerUserAvgAggregateInputObjectSchema.optional(), _sum: SQLServerUserSumAggregateInputObjectSchema.optional() }).strict() as unknown as z.ZodType<Prisma.SQLServerUserGroupByArgs>;
+
+export const SQLServerUserGroupByZodSchema = z.object({ where: SQLServerUserWhereInputObjectSchema.optional(), orderBy: z.union([SQLServerUserOrderByWithAggregationInputObjectSchema, SQLServerUserOrderByWithAggregationInputObjectSchema.array()]).optional(), having: SQLServerUserScalarWhereWithAggregatesInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), by: z.array(SQLServerUserScalarFieldEnumSchema), _count: z.union([ z.literal(true), SQLServerUserCountAggregateInputObjectSchema ]).optional(), _min: SQLServerUserMinAggregateInputObjectSchema.optional(), _max: SQLServerUserMaxAggregateInputObjectSchema.optional(), _avg: SQLServerUserAvgAggregateInputObjectSchema.optional(), _sum: SQLServerUserSumAggregateInputObjectSchema.optional() }).strict();

package/tests/multi-provider/schemas/sqlserver/generated/schemas/index.ts

@@ -0,0 +1,73 @@
+export * from './enums/TransactionIsolationLevel.schema'
+export * from './enums/SQLServerUserScalarFieldEnum.schema'
+export * from './enums/SQLServerPostScalarFieldEnum.schema'
+export * from './enums/SortOrder.schema'
+export * from './enums/NullsOrder.schema'
+export * from './findUniqueSQLServerUser.schema'
+export * from './findUniqueOrThrowSQLServerUser.schema'
+export * from './findFirstSQLServerUser.schema'
+export * from './findFirstOrThrowSQLServerUser.schema'
+export * from './findManySQLServerUser.schema'
+export * from './countSQLServerUser.schema'
+export * from './createOneSQLServerUser.schema'
+export * from './createManySQLServerUser.schema'
+export * from './deleteOneSQLServerUser.schema'
+export * from './deleteManySQLServerUser.schema'
+export * from './updateOneSQLServerUser.schema'
+export * from './updateManySQLServerUser.schema'
+export * from './upsertOneSQLServerUser.schema'
+export * from './aggregateSQLServerUser.schema'
+export * from './groupBySQLServerUser.schema'
+export * from './findUniqueSQLServerPost.schema'
+export * from './findUniqueOrThrowSQLServerPost.schema'
+export * from './findFirstSQLServerPost.schema'
+export * from './findFirstOrThrowSQLServerPost.schema'
+export * from './findManySQLServerPost.schema'
+export * from './countSQLServerPost.schema'
+export * from './createOneSQLServerPost.schema'
+export * from './createManySQLServerPost.schema'
+export * from './deleteOneSQLServerPost.schema'
+export * from './deleteManySQLServerPost.schema'
+export * from './updateOneSQLServerPost.schema'
+export * from './updateManySQLServerPost.schema'
+export * from './upsertOneSQLServerPost.schema'
+export * from './aggregateSQLServerPost.schema'
+export * from './groupBySQLServerPost.schema'
+export * from './results/SQLServerUserFindUniqueResult.schema'
+export * from './results/SQLServerUserFindFirstResult.schema'
+export * from './results/SQLServerUserFindManyResult.schema'
+export * from './results/SQLServerUserCreateResult.schema'
+export * from './results/SQLServerUserCreateManyResult.schema'
+export * from './results/SQLServerUserUpdateResult.schema'
+export * from './results/SQLServerUserUpdateManyResult.schema'
+export * from './results/SQLServerUserUpsertResult.schema'
+export * from './results/SQLServerUserDeleteResult.schema'
+export * from './results/SQLServerUserDeleteManyResult.schema'
+export * from './results/SQLServerUserAggregateResult.schema'
+export * from './results/SQLServerUserGroupByResult.schema'
+export * from './results/SQLServerUserCountResult.schema'
+export * from './results/SQLServerPostFindUniqueResult.schema'
+export * from './results/SQLServerPostFindFirstResult.schema'
+export * from './results/SQLServerPostFindManyResult.schema'
+export * from './results/SQLServerPostCreateResult.schema'
+export * from './results/SQLServerPostCreateManyResult.schema'
+export * from './results/SQLServerPostUpdateResult.schema'
+export * from './results/SQLServerPostUpdateManyResult.schema'
+export * from './results/SQLServerPostUpsertResult.schema'
+export * from './results/SQLServerPostDeleteResult.schema'
+export * from './results/SQLServerPostDeleteManyResult.schema'
+export * from './results/SQLServerPostAggregateResult.schema'
+export * from './results/SQLServerPostGroupByResult.schema'
+export * from './results/SQLServerPostCountResult.schema'
+export * from './results/index'
+export * from './objects/index'
+export * from './variants/pure/SQLServerUser.pure'
+export * from './variants/pure/SQLServerPost.pure'
+export * from './variants/pure/index'
+export * from './variants/input/SQLServerUser.input'
+export * from './variants/input/SQLServerPost.input'
+export * from './variants/input/index'
+export * from './variants/result/SQLServerUser.result'
+export * from './variants/result/SQLServerPost.result'
+export * from './variants/result/index'
+export * from './variants/index'

package/tests/multi-provider/schemas/sqlserver/generated/schemas/objects/BoolFieldUpdateOperationsInput.schema.ts

@@ -0,0 +1,9 @@
+import * as z from 'zod';
+import type { Prisma } from '@prisma/client';
+
+
+const makeSchema = () => z.object({
+  set: z.boolean().optional()
+}).strict();
+export const BoolFieldUpdateOperationsInputObjectSchema: z.ZodType<Prisma.BoolFieldUpdateOperationsInput> = makeSchema() as unknown as z.ZodType<Prisma.BoolFieldUpdateOperationsInput>;
+export const BoolFieldUpdateOperationsInputObjectZodSchema = makeSchema();

package/tests/multi-provider/schemas/sqlserver/generated/schemas/objects/BoolFilter.schema.ts

@@ -0,0 +1,10 @@
+import * as z from 'zod';
+import type { Prisma } from '@prisma/client';
+import { NestedBoolFilterObjectSchema as NestedBoolFilterObjectSchema } from './NestedBoolFilter.schema'
+
+const makeSchema = () => z.object({
+  equals: z.boolean().optional(),
+  not: z.union([z.boolean(), z.lazy(() => NestedBoolFilterObjectSchema)]).optional()
+}).strict();
+export const BoolFilterObjectSchema: z.ZodType<Prisma.BoolFilter> = makeSchema() as unknown as z.ZodType<Prisma.BoolFilter>;
+export const BoolFilterObjectZodSchema = makeSchema();

package/tests/multi-provider/schemas/sqlserver/generated/schemas/objects/BoolWithAggregatesFilter.schema.ts

@@ -0,0 +1,15 @@
+import * as z from 'zod';
+import type { Prisma } from '@prisma/client';
+import { NestedBoolWithAggregatesFilterObjectSchema as NestedBoolWithAggregatesFilterObjectSchema } from './NestedBoolWithAggregatesFilter.schema';
+import { NestedIntFilterObjectSchema as NestedIntFilterObjectSchema } from './NestedIntFilter.schema';
+import { NestedBoolFilterObjectSchema as NestedBoolFilterObjectSchema } from './NestedBoolFilter.schema'
+
+const makeSchema = () => z.object({
+  equals: z.boolean().optional(),
+  not: z.union([z.boolean(), z.lazy(() => NestedBoolWithAggregatesFilterObjectSchema)]).optional(),
+  _count: z.lazy(() => NestedIntFilterObjectSchema).optional(),
+  _min: z.lazy(() => NestedBoolFilterObjectSchema).optional(),
+  _max: z.lazy(() => NestedBoolFilterObjectSchema).optional()
+}).strict();
+export const BoolWithAggregatesFilterObjectSchema: z.ZodType<Prisma.BoolWithAggregatesFilter> = makeSchema() as unknown as z.ZodType<Prisma.BoolWithAggregatesFilter>;
+export const BoolWithAggregatesFilterObjectZodSchema = makeSchema();

package/tests/multi-provider/schemas/sqlserver/generated/schemas/objects/DateTimeFieldUpdateOperationsInput.schema.ts

@@ -0,0 +1,9 @@
+import * as z from 'zod';
+import type { Prisma } from '@prisma/client';
+
+
+const makeSchema = () => z.object({
+  set: z.coerce.date().optional()
+}).strict();
+export const DateTimeFieldUpdateOperationsInputObjectSchema: z.ZodType<Prisma.DateTimeFieldUpdateOperationsInput> = makeSchema() as unknown as z.ZodType<Prisma.DateTimeFieldUpdateOperationsInput>;
+export const DateTimeFieldUpdateOperationsInputObjectZodSchema = makeSchema();

package/tests/multi-provider/schemas/sqlserver/generated/schemas/objects/DateTimeFilter.schema.ts

@@ -0,0 +1,16 @@
+import * as z from 'zod';
+import type { Prisma } from '@prisma/client';
+import { NestedDateTimeFilterObjectSchema as NestedDateTimeFilterObjectSchema } from './NestedDateTimeFilter.schema'
+
+const makeSchema = () => z.object({
+  equals: z.date().optional(),
+  in: z.union([z.date().array(), z.string().datetime().array()]).optional(),
+  notIn: z.union([z.date().array(), z.string().datetime().array()]).optional(),
+  lt: z.date().optional(),
+  lte: z.date().optional(),
+  gt: z.date().optional(),
+  gte: z.date().optional(),
+  not: z.union([z.date(), z.lazy(() => NestedDateTimeFilterObjectSchema)]).optional()
+}).strict();
+export const DateTimeFilterObjectSchema: z.ZodType<Prisma.DateTimeFilter> = makeSchema() as unknown as z.ZodType<Prisma.DateTimeFilter>;
+export const DateTimeFilterObjectZodSchema = makeSchema();

package/tests/multi-provider/schemas/sqlserver/generated/schemas/objects/DateTimeWithAggregatesFilter.schema.ts

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

package/tests/multi-provider/schemas/sqlserver/generated/schemas/objects/IntFieldUpdateOperationsInput.schema.ts

@@ -0,0 +1,13 @@
+import * as z from 'zod';
+import type { Prisma } from '@prisma/client';
+
+
+const makeSchema = () => z.object({
+  set: z.number().int().optional(),
+  increment: z.number().int().optional(),
+  decrement: z.number().int().optional(),
+  multiply: z.number().int().optional(),
+  divide: z.number().int().optional()
+}).strict();
+export const IntFieldUpdateOperationsInputObjectSchema: z.ZodType<Prisma.IntFieldUpdateOperationsInput> = makeSchema() as unknown as z.ZodType<Prisma.IntFieldUpdateOperationsInput>;
+export const IntFieldUpdateOperationsInputObjectZodSchema = makeSchema();

package/tests/multi-provider/schemas/sqlserver/generated/schemas/objects/IntFilter.schema.ts

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

package/tests/multi-provider/schemas/sqlserver/generated/schemas/objects/IntNullableFilter.schema.ts

@@ -0,0 +1,16 @@
+import * as z from 'zod';
+import type { Prisma } from '@prisma/client';
+import { NestedIntNullableFilterObjectSchema as NestedIntNullableFilterObjectSchema } from './NestedIntNullableFilter.schema'
+
+const makeSchema = () => z.object({
+  equals: z.number().int().optional().nullable(),
+  in: z.number().int().array().optional().nullable(),
+  notIn: z.number().int().array().optional().nullable(),
+  lt: z.number().int().optional(),
+  lte: z.number().int().optional(),
+  gt: z.number().int().optional(),
+  gte: z.number().int().optional(),
+  not: z.union([z.number().int(), z.lazy(() => NestedIntNullableFilterObjectSchema)]).optional().nullable()
+}).strict();
+export const IntNullableFilterObjectSchema: z.ZodType<Prisma.IntNullableFilter> = makeSchema() as unknown as z.ZodType<Prisma.IntNullableFilter>;
+export const IntNullableFilterObjectZodSchema = makeSchema();

package/tests/multi-provider/schemas/sqlserver/generated/schemas/objects/IntNullableWithAggregatesFilter.schema.ts

@@ -0,0 +1,23 @@
+import * as z from 'zod';
+import type { Prisma } from '@prisma/client';
+import { NestedIntNullableWithAggregatesFilterObjectSchema as NestedIntNullableWithAggregatesFilterObjectSchema } from './NestedIntNullableWithAggregatesFilter.schema';
+import { NestedIntNullableFilterObjectSchema as NestedIntNullableFilterObjectSchema } from './NestedIntNullableFilter.schema';
+import { NestedFloatNullableFilterObjectSchema as NestedFloatNullableFilterObjectSchema } from './NestedFloatNullableFilter.schema'
+
+const makeSchema = () => z.object({
+  equals: z.number().int().optional().nullable(),
+  in: z.number().int().array().optional().nullable(),
+  notIn: z.number().int().array().optional().nullable(),
+  lt: z.number().int().optional(),
+  lte: z.number().int().optional(),
+  gt: z.number().int().optional(),
+  gte: z.number().int().optional(),
+  not: z.union([z.number().int(), z.lazy(() => NestedIntNullableWithAggregatesFilterObjectSchema)]).optional().nullable(),
+  _count: z.lazy(() => NestedIntNullableFilterObjectSchema).optional(),
+  _avg: z.lazy(() => NestedFloatNullableFilterObjectSchema).optional(),
+  _sum: z.lazy(() => NestedIntNullableFilterObjectSchema).optional(),
+  _min: z.lazy(() => NestedIntNullableFilterObjectSchema).optional(),
+  _max: z.lazy(() => NestedIntNullableFilterObjectSchema).optional()
+}).strict();
+export const IntNullableWithAggregatesFilterObjectSchema: z.ZodType<Prisma.IntNullableWithAggregatesFilter> = makeSchema() as unknown as z.ZodType<Prisma.IntNullableWithAggregatesFilter>;
+export const IntNullableWithAggregatesFilterObjectZodSchema = makeSchema();

package/tests/multi-provider/schemas/sqlserver/generated/schemas/objects/IntWithAggregatesFilter.schema.ts

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

package/tests/multi-provider/schemas/sqlserver/generated/schemas/objects/NestedBoolFilter.schema.ts

@@ -0,0 +1,10 @@
+import * as z from 'zod';
+import type { Prisma } from '@prisma/client';
+
+
+const nestedboolfilterSchema = z.object({
+  equals: z.boolean().optional(),
+  not: z.union([z.boolean(), z.lazy(() => NestedBoolFilterObjectSchema)]).optional()
+}).strict();
+export const NestedBoolFilterObjectSchema: z.ZodType<Prisma.NestedBoolFilter> = nestedboolfilterSchema as unknown as z.ZodType<Prisma.NestedBoolFilter>;
+export const NestedBoolFilterObjectZodSchema = nestedboolfilterSchema;

package/tests/multi-provider/schemas/sqlserver/generated/schemas/objects/NestedBoolWithAggregatesFilter.schema.ts

@@ -0,0 +1,14 @@
+import * as z from 'zod';
+import type { Prisma } from '@prisma/client';
+import { NestedIntFilterObjectSchema as NestedIntFilterObjectSchema } from './NestedIntFilter.schema';
+import { NestedBoolFilterObjectSchema as NestedBoolFilterObjectSchema } from './NestedBoolFilter.schema'
+
+const nestedboolwithaggregatesfilterSchema = z.object({
+  equals: z.boolean().optional(),
+  not: z.union([z.boolean(), z.lazy(() => NestedBoolWithAggregatesFilterObjectSchema)]).optional(),
+  _count: z.lazy(() => NestedIntFilterObjectSchema).optional(),
+  _min: z.lazy(() => NestedBoolFilterObjectSchema).optional(),
+  _max: z.lazy(() => NestedBoolFilterObjectSchema).optional()
+}).strict();
+export const NestedBoolWithAggregatesFilterObjectSchema: z.ZodType<Prisma.NestedBoolWithAggregatesFilter> = nestedboolwithaggregatesfilterSchema as unknown as z.ZodType<Prisma.NestedBoolWithAggregatesFilter>;
+export const NestedBoolWithAggregatesFilterObjectZodSchema = nestedboolwithaggregatesfilterSchema;

package/tests/multi-provider/schemas/sqlserver/generated/schemas/objects/NestedDateTimeFilter.schema.ts

@@ -0,0 +1,16 @@
+import * as z from 'zod';
+import type { Prisma } from '@prisma/client';
+
+
+const nesteddatetimefilterSchema = z.object({
+  equals: z.date().optional(),
+  in: z.union([z.date().array(), z.string().datetime().array()]).optional(),
+  notIn: z.union([z.date().array(), z.string().datetime().array()]).optional(),
+  lt: z.date().optional(),
+  lte: z.date().optional(),
+  gt: z.date().optional(),
+  gte: z.date().optional(),
+  not: z.union([z.date(), z.lazy(() => NestedDateTimeFilterObjectSchema)]).optional()
+}).strict();
+export const NestedDateTimeFilterObjectSchema: z.ZodType<Prisma.NestedDateTimeFilter> = nesteddatetimefilterSchema as unknown as z.ZodType<Prisma.NestedDateTimeFilter>;
+export const NestedDateTimeFilterObjectZodSchema = nesteddatetimefilterSchema;

package/tests/multi-provider/schemas/sqlserver/generated/schemas/objects/NestedDateTimeWithAggregatesFilter.schema.ts

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

package/tests/multi-provider/schemas/sqlserver/generated/schemas/objects/NestedFloatFilter.schema.ts

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

package/tests/multi-provider/schemas/sqlserver/generated/schemas/objects/NestedFloatNullableFilter.schema.ts

@@ -0,0 +1,16 @@
+import * as z from 'zod';
+import type { Prisma } from '@prisma/client';
+
+
+const nestedfloatnullablefilterSchema = z.object({
+  equals: z.number().optional().nullable(),
+  in: z.number().array().optional().nullable(),
+  notIn: z.number().array().optional().nullable(),
+  lt: z.number().optional(),
+  lte: z.number().optional(),
+  gt: z.number().optional(),
+  gte: z.number().optional(),
+  not: z.union([z.number(), z.lazy(() => NestedFloatNullableFilterObjectSchema)]).optional().nullable()
+}).strict();
+export const NestedFloatNullableFilterObjectSchema: z.ZodType<Prisma.NestedFloatNullableFilter> = nestedfloatnullablefilterSchema as unknown as z.ZodType<Prisma.NestedFloatNullableFilter>;
+export const NestedFloatNullableFilterObjectZodSchema = nestedfloatnullablefilterSchema;

package/tests/multi-provider/schemas/sqlserver/generated/schemas/objects/NestedIntFilter.schema.ts

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

package/tests/multi-provider/schemas/sqlserver/generated/schemas/objects/NestedIntNullableFilter.schema.ts

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