diff --git a/leaky-ships/lib/zodSchemas.ts b/leaky-ships/lib/zodSchemas.ts
index 41c2a94..311072b 100644
--- a/leaky-ships/lib/zodSchemas.ts
+++ b/leaky-ships/lib/zodSchemas.ts
@@ -1,13 +1,8 @@
-import { GameState } from "@prisma/client"
+import { GameSchema } from "../prisma/generated/zod"
 import { z } from "zod"
 
-export const createSchema = z.object({
-  game: z.object({
-    id: z.string(),
-    createdAt: z.date(),
-    updatedAt: z.date(),
-    state: z.nativeEnum(GameState),
-  }),
+export const CreateSchema = z.object({
+  game: GameSchema.strict(),
   pin: z.string().optional(),
   player: z.object({
     id: z.string(),
diff --git a/leaky-ships/package.json b/leaky-ships/package.json
index a220e6c..83f786c 100644
--- a/leaky-ships/package.json
+++ b/leaky-ships/package.json
@@ -37,7 +37,8 @@
     "socket.io-client": "^4.6.1",
     "typescript": "4.9.4",
     "unique-names-generator": "^4.7.1",
-    "zod": "^3.21.4"
+    "zod": "^3.21.1",
+    "zod-prisma-types": "^2.5.6"
   },
   "devDependencies": {
     "@total-typescript/ts-reset": "^0.3.7",
diff --git a/leaky-ships/pages/api/game/create.ts b/leaky-ships/pages/api/game/create.ts
index 12604bc..b11b5bd 100644
--- a/leaky-ships/pages/api/game/create.ts
+++ b/leaky-ships/pages/api/game/create.ts
@@ -3,12 +3,12 @@ import { getAnyRunningGame } from "./running"
 import sendResponse from "@backend/sendResponse"
 import { rejectionErrors } from "@lib/backend/errors"
 import prisma from "@lib/prisma"
-import { createSchema } from "@lib/zodSchemas"
+import { CreateSchema } from "@lib/zodSchemas"
 import type { NextApiRequest, NextApiResponse } from "next"
 import { getServerSession } from "next-auth"
 import { z } from "zod"
 
-type Data = z.infer<typeof createSchema>
+type Data = z.infer<typeof CreateSchema>
 
 export default async function create(
   req: NextApiRequest,
diff --git a/leaky-ships/pages/start.tsx b/leaky-ships/pages/start.tsx
index 7b2cc78..c0715b2 100644
--- a/leaky-ships/pages/start.tsx
+++ b/leaky-ships/pages/start.tsx
@@ -5,7 +5,7 @@ import { faEye, faLeftLong } from "@fortawesome/pro-regular-svg-icons"
 import { faPlus, faUserPlus } from "@fortawesome/pro-solid-svg-icons"
 import { FontAwesomeIcon } from "@fortawesome/react-fontawesome"
 import useGameState from "@lib/hooks/useGameState"
-import { createSchema } from "@lib/zodSchemas"
+import { CreateSchema } from "@lib/zodSchemas"
 import status from "http-status"
 import { GetServerSideProps } from "next"
 import { useRouter } from "next/router"
@@ -61,7 +61,7 @@ export default function Home({ q }: Props) {
         body: JSON.stringify({ pin }),
       })
         .then(isAuthenticated)
-        .then((game) => createSchema.parse(game))
+        .then((game) => CreateSchema.parse(game))
 
       const res = await toast.promise(gamePromise, {
         pending: {
diff --git a/leaky-ships/pnpm-lock.yaml b/leaky-ships/pnpm-lock.yaml
index 090c71d..29054d9 100644
--- a/leaky-ships/pnpm-lock.yaml
+++ b/leaky-ships/pnpm-lock.yaml
@@ -86,8 +86,11 @@ dependencies:
     specifier: ^4.7.1
     version: 4.7.1
   zod:
-    specifier: ^3.21.4
-    version: 3.21.4
+    specifier: ^3.21.1
+    version: 3.21.1
+  zod-prisma-types:
+    specifier: ^2.5.6
+    version: 2.5.6
 
 devDependencies:
   '@total-typescript/ts-reset':
@@ -548,6 +551,16 @@ packages:
       prisma: 4.12.0
     dev: false
 
+  /@prisma/debug@4.13.0:
+    resolution: {integrity: sha512-JrltTewF/paRb5mcM5OvcEi9DtdX0sINOAswruxKQrwOLA7Phqb52OfY38MIzGrsrJ8iUGVqQ5bpYZYpxOGCsQ==}
+    dependencies:
+      '@types/debug': 4.1.7
+      debug: 4.3.4
+      strip-ansi: 6.0.1
+    transitivePeerDependencies:
+      - supports-color
+    dev: false
+
   /@prisma/engines-version@4.12.0-67.659ef412370fa3b41cd7bf6e94587c1dfb7f67e7:
     resolution: {integrity: sha512-JIHNj5jlXb9mcaJwakM0vpgRYJIAurxTUqM0iX0tfEQA5XLZ9ONkIckkhuAKdAzocZ+80GYg7QSsfpjg7OxbOA==}
     dev: false
@@ -557,6 +570,17 @@ packages:
     requiresBuild: true
     dev: false
 
+  /@prisma/generator-helper@4.13.0:
+    resolution: {integrity: sha512-Zx9rtbsEIU/9DKnGRvmjLdyeyhzeeXNFp1alkRh1w//rQ5jTcobiay/jU4Qo+EQOs2bnWEfUeiBoOjfaysdLNg==}
+    dependencies:
+      '@prisma/debug': 4.13.0
+      '@types/cross-spawn': 6.0.2
+      chalk: 4.1.2
+      cross-spawn: 7.0.3
+    transitivePeerDependencies:
+      - supports-color
+    dev: false
+
   /@rushstack/eslint-patch@1.2.0:
     resolution: {integrity: sha512-sXo/qW2/pAcmT43VoRKOJbDOfV3cYpq3szSVfIThQXNt+E4DfKj361vaAt3c88U5tPUxzEswam7GW48PJqtKAg==}
     dev: false
@@ -605,10 +629,26 @@ packages:
       '@types/node': 18.15.11
     dev: false
 
+  /@types/cross-spawn@6.0.2:
+    resolution: {integrity: sha512-KuwNhp3eza+Rhu8IFI5HUXRP0LIhqH5cAjubUvGXXthh4YYBuP2ntwEX+Cz8GJoZUHlKo247wPWOfA9LYEq4cw==}
+    dependencies:
+      '@types/node': 18.15.11
+    dev: false
+
+  /@types/debug@4.1.7:
+    resolution: {integrity: sha512-9AonUzyTjXXhEOa0DnqpzZi6VHlqKMswga9EXjpXnnqxwLtdvPPtlO8evrI5D9S6asFRCQ6v+wpiUKbw+vKqyg==}
+    dependencies:
+      '@types/ms': 0.7.31
+    dev: false
+
   /@types/json5@0.0.29:
     resolution: {integrity: sha512-dRLjCWHYg4oaA77cxO64oO+7JwCwnIzkZPdrrC71jQmQtlhM556pwKo5bUzqvZndkVbeFLIIi+9TC40JNF5hNQ==}
     dev: false
 
+  /@types/ms@0.7.31:
+    resolution: {integrity: sha512-iiUgKzV9AuaEkZqkOLDIvlQiL6ltuZd9tGcW3gwpnX8JbuiuhFlEGmmFXEXkN50Cvq7Os88IY2v0dkDqXYWVgA==}
+    dev: false
+
   /@types/node@18.15.11:
     resolution: {integrity: sha512-E5Kwq2n4SbMzQOn6wnmBjuK9ouqlURrcZDVfbo9ftDDTFt3nk7ZKK4GMOzoYgnpQJKcxwQw+lGaBvvlMo0qN/Q==}
 
@@ -955,6 +995,10 @@ packages:
     engines: {node: '>=6'}
     dev: false
 
+  /code-block-writer@11.0.3:
+    resolution: {integrity: sha512-NiujjUFB4SwScJq2bwbYUtXbZhBSlY6vYzm++3Q6oC+U+injTqfPYFK8wS9COOmb2lueqp0ZRB4nK1VYeHgNyw==}
+    dev: false
+
   /color-convert@1.9.3:
     resolution: {integrity: sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg==}
     dependencies:
@@ -2105,7 +2149,6 @@ packages:
 
   /lodash@4.17.21:
     resolution: {integrity: sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg==}
-    dev: true
 
   /loose-envify@1.4.0:
     resolution: {integrity: sha512-lyuxPGr/Wfhrlem2CL/UcnUc1zcqKAImBDzukY7Y5F/yQiNdko6+fRLevlw1HgMySw7f611UIY408EtxRSoK3Q==}
@@ -3227,6 +3270,22 @@ packages:
     resolution: {integrity: sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==}
     engines: {node: '>=10'}
 
+  /zod-prisma-types@2.5.6:
+    resolution: {integrity: sha512-Cck7hzz15t4+ADmoZWa475fPiDxxd1/hve+vfS85BsEVr3u8y3zphKi/5/yhkT/mKuJhiMkIfc4VJLrJt/cTpw==}
+    hasBin: true
+    dependencies:
+      '@prisma/generator-helper': 4.13.0
+      code-block-writer: 11.0.3
+      lodash: 4.17.21
+      zod: 3.21.4
+    transitivePeerDependencies:
+      - supports-color
+    dev: false
+
+  /zod@3.21.1:
+    resolution: {integrity: sha512-+dTu2m6gmCbO9Ahm4ZBDapx2O6ZY9QSPXst2WXjcznPMwf2YNpn3RevLx4KkZp1OPW/ouFcoBtBzFz/LeY69oA==}
+    dev: false
+
   /zod@3.21.4:
     resolution: {integrity: sha512-m46AKbrzKVzOzs/DZgVnG5H55N1sv1M8qZU3A8RIKbs3mrACDNeIOeilDymVb2HdmP8uwshOCF4uJ8uM9rCqJw==}
     dev: false
diff --git a/leaky-ships/prisma/generated/zod/index.ts b/leaky-ships/prisma/generated/zod/index.ts
new file mode 100644
index 0000000..a9ee6ed
--- /dev/null
+++ b/leaky-ships/prisma/generated/zod/index.ts
@@ -0,0 +1,4461 @@
+import { z } from 'zod';
+import type { Prisma } from '@prisma/client';
+
+/////////////////////////////////////////
+// HELPER FUNCTIONS
+/////////////////////////////////////////
+
+
+/////////////////////////////////////////
+// ENUMS
+/////////////////////////////////////////
+
+export const AccountScalarFieldEnumSchema = z.enum(['id','userId','type','provider','providerAccountId','refresh_token','access_token','expires_at','ext_expires_in','token_type','scope','id_token','session_state','oauth_token_secret','oauth_token']);
+
+export const ChatScalarFieldEnumSchema = z.enum(['id','createdAt','message','event','user_game_id']);
+
+export const GameScalarFieldEnumSchema = z.enum(['id','createdAt','updatedAt','state']);
+
+export const GamepinScalarFieldEnumSchema = z.enum(['id','createdAt','pin','gameId']);
+
+export const MoveScalarFieldEnumSchema = z.enum(['id','createdAt','index','user_game_id']);
+
+export const SessionScalarFieldEnumSchema = z.enum(['id','sessionToken','userId','expires']);
+
+export const SortOrderSchema = z.enum(['asc','desc']);
+
+export const TransactionIsolationLevelSchema = z.enum(['ReadUncommitted','ReadCommitted','RepeatableRead','Serializable']);
+
+export const UserScalarFieldEnumSchema = z.enum(['id','name','email','emailVerified','image','createdAt','updatedAt']);
+
+export const User_GameScalarFieldEnumSchema = z.enum(['id','createdAt','gameId','userId','isOwner']);
+
+export const VerificationTokenScalarFieldEnumSchema = z.enum(['identifier','token','expires']);
+
+export const GameStateSchema = z.enum(['launching','running','ended']);
+
+export type GameStateType = `${z.infer<typeof GameStateSchema>}`
+
+/////////////////////////////////////////
+// MODELS
+/////////////////////////////////////////
+
+/////////////////////////////////////////
+// ACCOUNT SCHEMA
+/////////////////////////////////////////
+
+export const AccountSchema = z.object({
+  id: z.string().cuid(),
+  userId: z.string(),
+  type: z.string(),
+  provider: z.string(),
+  providerAccountId: z.string(),
+  refresh_token: z.string().nullable(),
+  access_token: z.string().nullable(),
+  expires_at: z.number().int().nullable(),
+  ext_expires_in: z.number().int().nullable(),
+  token_type: z.string().nullable(),
+  scope: z.string().nullable(),
+  id_token: z.string().nullable(),
+  session_state: z.string().nullable(),
+  oauth_token_secret: z.string().nullable(),
+  oauth_token: z.string().nullable(),
+})
+
+export type Account = z.infer<typeof AccountSchema>
+
+/////////////////////////////////////////
+// SESSION SCHEMA
+/////////////////////////////////////////
+
+export const SessionSchema = z.object({
+  id: z.string().cuid(),
+  sessionToken: z.string(),
+  userId: z.string(),
+  expires: z.coerce.date(),
+})
+
+export type Session = z.infer<typeof SessionSchema>
+
+/////////////////////////////////////////
+// USER SCHEMA
+/////////////////////////////////////////
+
+export const UserSchema = z.object({
+  id: z.string().cuid(),
+  name: z.string().nullable(),
+  email: z.string().nullable(),
+  emailVerified: z.coerce.date().nullable(),
+  image: z.string().nullable(),
+  createdAt: z.coerce.date(),
+  updatedAt: z.coerce.date(),
+})
+
+export type User = z.infer<typeof UserSchema>
+
+/////////////////////////////////////////
+// VERIFICATION TOKEN SCHEMA
+/////////////////////////////////////////
+
+export const VerificationTokenSchema = z.object({
+  identifier: z.string(),
+  token: z.string(),
+  expires: z.coerce.date(),
+})
+
+export type VerificationToken = z.infer<typeof VerificationTokenSchema>
+
+/////////////////////////////////////////
+// GAME SCHEMA
+/////////////////////////////////////////
+
+export const GameSchema = z.object({
+  state: GameStateSchema,
+  id: z.string().cuid(),
+  createdAt: z.coerce.date(),
+  updatedAt: z.coerce.date(),
+})
+
+export type Game = z.infer<typeof GameSchema>
+
+/////////////////////////////////////////
+// GAMEPIN SCHEMA
+/////////////////////////////////////////
+
+export const GamepinSchema = z.object({
+  id: z.string().cuid(),
+  createdAt: z.coerce.date(),
+  pin: z.string(),
+  gameId: z.string(),
+})
+
+export type Gamepin = z.infer<typeof GamepinSchema>
+
+/////////////////////////////////////////
+// USER GAME SCHEMA
+/////////////////////////////////////////
+
+export const User_GameSchema = z.object({
+  id: z.string().cuid(),
+  createdAt: z.coerce.date(),
+  gameId: z.string(),
+  userId: z.string(),
+  isOwner: z.boolean(),
+})
+
+export type User_Game = z.infer<typeof User_GameSchema>
+
+/////////////////////////////////////////
+// MOVE SCHEMA
+/////////////////////////////////////////
+
+export const MoveSchema = z.object({
+  id: z.string().cuid(),
+  createdAt: z.coerce.date(),
+  index: z.number().int(),
+  user_game_id: z.string(),
+})
+
+export type Move = z.infer<typeof MoveSchema>
+
+/////////////////////////////////////////
+// CHAT SCHEMA
+/////////////////////////////////////////
+
+export const ChatSchema = z.object({
+  id: z.string().cuid(),
+  createdAt: z.coerce.date(),
+  message: z.string().nullable(),
+  event: z.string().nullable(),
+  user_game_id: z.string(),
+})
+
+export type Chat = z.infer<typeof ChatSchema>
+
+/////////////////////////////////////////
+// SELECT & INCLUDE
+/////////////////////////////////////////
+
+// ACCOUNT
+//------------------------------------------------------
+
+export const AccountIncludeSchema: z.ZodType<Prisma.AccountInclude> = z.object({
+  user: z.union([z.boolean(),z.lazy(() => UserArgsSchema)]).optional(),
+}).strict()
+
+export const AccountArgsSchema: z.ZodType<Prisma.AccountArgs> = z.object({
+  select: z.lazy(() => AccountSelectSchema).optional(),
+  include: z.lazy(() => AccountIncludeSchema).optional(),
+}).strict();
+
+export const AccountSelectSchema: z.ZodType<Prisma.AccountSelect> = z.object({
+  id: z.boolean().optional(),
+  userId: z.boolean().optional(),
+  type: z.boolean().optional(),
+  provider: z.boolean().optional(),
+  providerAccountId: z.boolean().optional(),
+  refresh_token: z.boolean().optional(),
+  access_token: z.boolean().optional(),
+  expires_at: z.boolean().optional(),
+  ext_expires_in: z.boolean().optional(),
+  token_type: z.boolean().optional(),
+  scope: z.boolean().optional(),
+  id_token: z.boolean().optional(),
+  session_state: z.boolean().optional(),
+  oauth_token_secret: z.boolean().optional(),
+  oauth_token: z.boolean().optional(),
+  user: z.union([z.boolean(),z.lazy(() => UserArgsSchema)]).optional(),
+}).strict()
+
+// SESSION
+//------------------------------------------------------
+
+export const SessionIncludeSchema: z.ZodType<Prisma.SessionInclude> = z.object({
+  user: z.union([z.boolean(),z.lazy(() => UserArgsSchema)]).optional(),
+}).strict()
+
+export const SessionArgsSchema: z.ZodType<Prisma.SessionArgs> = z.object({
+  select: z.lazy(() => SessionSelectSchema).optional(),
+  include: z.lazy(() => SessionIncludeSchema).optional(),
+}).strict();
+
+export const SessionSelectSchema: z.ZodType<Prisma.SessionSelect> = z.object({
+  id: z.boolean().optional(),
+  sessionToken: z.boolean().optional(),
+  userId: z.boolean().optional(),
+  expires: z.boolean().optional(),
+  user: z.union([z.boolean(),z.lazy(() => UserArgsSchema)]).optional(),
+}).strict()
+
+// USER
+//------------------------------------------------------
+
+export const UserIncludeSchema: z.ZodType<Prisma.UserInclude> = z.object({
+  games: z.union([z.boolean(),z.lazy(() => User_GameFindManyArgsSchema)]).optional(),
+  accounts: z.union([z.boolean(),z.lazy(() => AccountFindManyArgsSchema)]).optional(),
+  sessions: z.union([z.boolean(),z.lazy(() => SessionFindManyArgsSchema)]).optional(),
+  _count: z.union([z.boolean(),z.lazy(() => UserCountOutputTypeArgsSchema)]).optional(),
+}).strict()
+
+export const UserArgsSchema: z.ZodType<Prisma.UserArgs> = z.object({
+  select: z.lazy(() => UserSelectSchema).optional(),
+  include: z.lazy(() => UserIncludeSchema).optional(),
+}).strict();
+
+export const UserCountOutputTypeArgsSchema: z.ZodType<Prisma.UserCountOutputTypeArgs> = z.object({
+  select: z.lazy(() => UserCountOutputTypeSelectSchema).nullish(),
+}).strict();
+
+export const UserCountOutputTypeSelectSchema: z.ZodType<Prisma.UserCountOutputTypeSelect> = z.object({
+  games: z.boolean().optional(),
+  accounts: z.boolean().optional(),
+  sessions: z.boolean().optional(),
+}).strict();
+
+export const UserSelectSchema: z.ZodType<Prisma.UserSelect> = z.object({
+  id: z.boolean().optional(),
+  name: z.boolean().optional(),
+  email: z.boolean().optional(),
+  emailVerified: z.boolean().optional(),
+  image: z.boolean().optional(),
+  createdAt: z.boolean().optional(),
+  updatedAt: z.boolean().optional(),
+  games: z.union([z.boolean(),z.lazy(() => User_GameFindManyArgsSchema)]).optional(),
+  accounts: z.union([z.boolean(),z.lazy(() => AccountFindManyArgsSchema)]).optional(),
+  sessions: z.union([z.boolean(),z.lazy(() => SessionFindManyArgsSchema)]).optional(),
+  _count: z.union([z.boolean(),z.lazy(() => UserCountOutputTypeArgsSchema)]).optional(),
+}).strict()
+
+// VERIFICATION TOKEN
+//------------------------------------------------------
+
+export const VerificationTokenSelectSchema: z.ZodType<Prisma.VerificationTokenSelect> = z.object({
+  identifier: z.boolean().optional(),
+  token: z.boolean().optional(),
+  expires: z.boolean().optional(),
+}).strict()
+
+// GAME
+//------------------------------------------------------
+
+export const GameIncludeSchema: z.ZodType<Prisma.GameInclude> = z.object({
+  gamePin: z.union([z.boolean(),z.lazy(() => GamepinArgsSchema)]).optional(),
+  users: z.union([z.boolean(),z.lazy(() => User_GameFindManyArgsSchema)]).optional(),
+  _count: z.union([z.boolean(),z.lazy(() => GameCountOutputTypeArgsSchema)]).optional(),
+}).strict()
+
+export const GameArgsSchema: z.ZodType<Prisma.GameArgs> = z.object({
+  select: z.lazy(() => GameSelectSchema).optional(),
+  include: z.lazy(() => GameIncludeSchema).optional(),
+}).strict();
+
+export const GameCountOutputTypeArgsSchema: z.ZodType<Prisma.GameCountOutputTypeArgs> = z.object({
+  select: z.lazy(() => GameCountOutputTypeSelectSchema).nullish(),
+}).strict();
+
+export const GameCountOutputTypeSelectSchema: z.ZodType<Prisma.GameCountOutputTypeSelect> = z.object({
+  users: z.boolean().optional(),
+}).strict();
+
+export const GameSelectSchema: z.ZodType<Prisma.GameSelect> = z.object({
+  id: z.boolean().optional(),
+  createdAt: z.boolean().optional(),
+  updatedAt: z.boolean().optional(),
+  state: z.boolean().optional(),
+  gamePin: z.union([z.boolean(),z.lazy(() => GamepinArgsSchema)]).optional(),
+  users: z.union([z.boolean(),z.lazy(() => User_GameFindManyArgsSchema)]).optional(),
+  _count: z.union([z.boolean(),z.lazy(() => GameCountOutputTypeArgsSchema)]).optional(),
+}).strict()
+
+// GAMEPIN
+//------------------------------------------------------
+
+export const GamepinIncludeSchema: z.ZodType<Prisma.GamepinInclude> = z.object({
+  game: z.union([z.boolean(),z.lazy(() => GameArgsSchema)]).optional(),
+}).strict()
+
+export const GamepinArgsSchema: z.ZodType<Prisma.GamepinArgs> = z.object({
+  select: z.lazy(() => GamepinSelectSchema).optional(),
+  include: z.lazy(() => GamepinIncludeSchema).optional(),
+}).strict();
+
+export const GamepinSelectSchema: z.ZodType<Prisma.GamepinSelect> = z.object({
+  id: z.boolean().optional(),
+  createdAt: z.boolean().optional(),
+  pin: z.boolean().optional(),
+  gameId: z.boolean().optional(),
+  game: z.union([z.boolean(),z.lazy(() => GameArgsSchema)]).optional(),
+}).strict()
+
+// USER GAME
+//------------------------------------------------------
+
+export const User_GameIncludeSchema: z.ZodType<Prisma.User_GameInclude> = z.object({
+  moves: z.union([z.boolean(),z.lazy(() => MoveFindManyArgsSchema)]).optional(),
+  chats: z.union([z.boolean(),z.lazy(() => ChatFindManyArgsSchema)]).optional(),
+  game: z.union([z.boolean(),z.lazy(() => GameArgsSchema)]).optional(),
+  user: z.union([z.boolean(),z.lazy(() => UserArgsSchema)]).optional(),
+  _count: z.union([z.boolean(),z.lazy(() => User_GameCountOutputTypeArgsSchema)]).optional(),
+}).strict()
+
+export const User_GameArgsSchema: z.ZodType<Prisma.User_GameArgs> = z.object({
+  select: z.lazy(() => User_GameSelectSchema).optional(),
+  include: z.lazy(() => User_GameIncludeSchema).optional(),
+}).strict();
+
+export const User_GameCountOutputTypeArgsSchema: z.ZodType<Prisma.User_GameCountOutputTypeArgs> = z.object({
+  select: z.lazy(() => User_GameCountOutputTypeSelectSchema).nullish(),
+}).strict();
+
+export const User_GameCountOutputTypeSelectSchema: z.ZodType<Prisma.User_GameCountOutputTypeSelect> = z.object({
+  moves: z.boolean().optional(),
+  chats: z.boolean().optional(),
+}).strict();
+
+export const User_GameSelectSchema: z.ZodType<Prisma.User_GameSelect> = z.object({
+  id: z.boolean().optional(),
+  createdAt: z.boolean().optional(),
+  gameId: z.boolean().optional(),
+  userId: z.boolean().optional(),
+  isOwner: z.boolean().optional(),
+  moves: z.union([z.boolean(),z.lazy(() => MoveFindManyArgsSchema)]).optional(),
+  chats: z.union([z.boolean(),z.lazy(() => ChatFindManyArgsSchema)]).optional(),
+  game: z.union([z.boolean(),z.lazy(() => GameArgsSchema)]).optional(),
+  user: z.union([z.boolean(),z.lazy(() => UserArgsSchema)]).optional(),
+  _count: z.union([z.boolean(),z.lazy(() => User_GameCountOutputTypeArgsSchema)]).optional(),
+}).strict()
+
+// MOVE
+//------------------------------------------------------
+
+export const MoveIncludeSchema: z.ZodType<Prisma.MoveInclude> = z.object({
+  user_game: z.union([z.boolean(),z.lazy(() => User_GameArgsSchema)]).optional(),
+}).strict()
+
+export const MoveArgsSchema: z.ZodType<Prisma.MoveArgs> = z.object({
+  select: z.lazy(() => MoveSelectSchema).optional(),
+  include: z.lazy(() => MoveIncludeSchema).optional(),
+}).strict();
+
+export const MoveSelectSchema: z.ZodType<Prisma.MoveSelect> = z.object({
+  id: z.boolean().optional(),
+  createdAt: z.boolean().optional(),
+  index: z.boolean().optional(),
+  user_game_id: z.boolean().optional(),
+  user_game: z.union([z.boolean(),z.lazy(() => User_GameArgsSchema)]).optional(),
+}).strict()
+
+// CHAT
+//------------------------------------------------------
+
+export const ChatIncludeSchema: z.ZodType<Prisma.ChatInclude> = z.object({
+  user_game: z.union([z.boolean(),z.lazy(() => User_GameArgsSchema)]).optional(),
+}).strict()
+
+export const ChatArgsSchema: z.ZodType<Prisma.ChatArgs> = z.object({
+  select: z.lazy(() => ChatSelectSchema).optional(),
+  include: z.lazy(() => ChatIncludeSchema).optional(),
+}).strict();
+
+export const ChatSelectSchema: z.ZodType<Prisma.ChatSelect> = z.object({
+  id: z.boolean().optional(),
+  createdAt: z.boolean().optional(),
+  message: z.boolean().optional(),
+  event: z.boolean().optional(),
+  user_game_id: z.boolean().optional(),
+  user_game: z.union([z.boolean(),z.lazy(() => User_GameArgsSchema)]).optional(),
+}).strict()
+
+
+/////////////////////////////////////////
+// INPUT TYPES
+/////////////////////////////////////////
+
+export const AccountWhereInputSchema: z.ZodType<Prisma.AccountWhereInput> = z.object({
+  AND: z.union([ z.lazy(() => AccountWhereInputSchema),z.lazy(() => AccountWhereInputSchema).array() ]).optional(),
+  OR: z.lazy(() => AccountWhereInputSchema).array().optional(),
+  NOT: z.union([ z.lazy(() => AccountWhereInputSchema),z.lazy(() => AccountWhereInputSchema).array() ]).optional(),
+  id: z.union([ z.lazy(() => StringFilterSchema),z.string() ]).optional(),
+  userId: z.union([ z.lazy(() => StringFilterSchema),z.string() ]).optional(),
+  type: z.union([ z.lazy(() => StringFilterSchema),z.string() ]).optional(),
+  provider: z.union([ z.lazy(() => StringFilterSchema),z.string() ]).optional(),
+  providerAccountId: z.union([ z.lazy(() => StringFilterSchema),z.string() ]).optional(),
+  refresh_token: z.union([ z.lazy(() => StringNullableFilterSchema),z.string() ]).optional().nullable(),
+  access_token: z.union([ z.lazy(() => StringNullableFilterSchema),z.string() ]).optional().nullable(),
+  expires_at: z.union([ z.lazy(() => IntNullableFilterSchema),z.number() ]).optional().nullable(),
+  ext_expires_in: z.union([ z.lazy(() => IntNullableFilterSchema),z.number() ]).optional().nullable(),
+  token_type: z.union([ z.lazy(() => StringNullableFilterSchema),z.string() ]).optional().nullable(),
+  scope: z.union([ z.lazy(() => StringNullableFilterSchema),z.string() ]).optional().nullable(),
+  id_token: z.union([ z.lazy(() => StringNullableFilterSchema),z.string() ]).optional().nullable(),
+  session_state: z.union([ z.lazy(() => StringNullableFilterSchema),z.string() ]).optional().nullable(),
+  oauth_token_secret: z.union([ z.lazy(() => StringNullableFilterSchema),z.string() ]).optional().nullable(),
+  oauth_token: z.union([ z.lazy(() => StringNullableFilterSchema),z.string() ]).optional().nullable(),
+  user: z.union([ z.lazy(() => UserRelationFilterSchema),z.lazy(() => UserWhereInputSchema) ]).optional(),
+}).strict();
+
+export const AccountOrderByWithRelationInputSchema: z.ZodType<Prisma.AccountOrderByWithRelationInput> = z.object({
+  id: z.lazy(() => SortOrderSchema).optional(),
+  userId: z.lazy(() => SortOrderSchema).optional(),
+  type: z.lazy(() => SortOrderSchema).optional(),
+  provider: z.lazy(() => SortOrderSchema).optional(),
+  providerAccountId: z.lazy(() => SortOrderSchema).optional(),
+  refresh_token: z.lazy(() => SortOrderSchema).optional(),
+  access_token: z.lazy(() => SortOrderSchema).optional(),
+  expires_at: z.lazy(() => SortOrderSchema).optional(),
+  ext_expires_in: z.lazy(() => SortOrderSchema).optional(),
+  token_type: z.lazy(() => SortOrderSchema).optional(),
+  scope: z.lazy(() => SortOrderSchema).optional(),
+  id_token: z.lazy(() => SortOrderSchema).optional(),
+  session_state: z.lazy(() => SortOrderSchema).optional(),
+  oauth_token_secret: z.lazy(() => SortOrderSchema).optional(),
+  oauth_token: z.lazy(() => SortOrderSchema).optional(),
+  user: z.lazy(() => UserOrderByWithRelationInputSchema).optional()
+}).strict();
+
+export const AccountWhereUniqueInputSchema: z.ZodType<Prisma.AccountWhereUniqueInput> = z.object({
+  id: z.string().cuid().optional(),
+  provider_providerAccountId: z.lazy(() => AccountProviderProviderAccountIdCompoundUniqueInputSchema).optional()
+}).strict();
+
+export const AccountOrderByWithAggregationInputSchema: z.ZodType<Prisma.AccountOrderByWithAggregationInput> = z.object({
+  id: z.lazy(() => SortOrderSchema).optional(),
+  userId: z.lazy(() => SortOrderSchema).optional(),
+  type: z.lazy(() => SortOrderSchema).optional(),
+  provider: z.lazy(() => SortOrderSchema).optional(),
+  providerAccountId: z.lazy(() => SortOrderSchema).optional(),
+  refresh_token: z.lazy(() => SortOrderSchema).optional(),
+  access_token: z.lazy(() => SortOrderSchema).optional(),
+  expires_at: z.lazy(() => SortOrderSchema).optional(),
+  ext_expires_in: z.lazy(() => SortOrderSchema).optional(),
+  token_type: z.lazy(() => SortOrderSchema).optional(),
+  scope: z.lazy(() => SortOrderSchema).optional(),
+  id_token: z.lazy(() => SortOrderSchema).optional(),
+  session_state: z.lazy(() => SortOrderSchema).optional(),
+  oauth_token_secret: z.lazy(() => SortOrderSchema).optional(),
+  oauth_token: z.lazy(() => SortOrderSchema).optional(),
+  _count: z.lazy(() => AccountCountOrderByAggregateInputSchema).optional(),
+  _avg: z.lazy(() => AccountAvgOrderByAggregateInputSchema).optional(),
+  _max: z.lazy(() => AccountMaxOrderByAggregateInputSchema).optional(),
+  _min: z.lazy(() => AccountMinOrderByAggregateInputSchema).optional(),
+  _sum: z.lazy(() => AccountSumOrderByAggregateInputSchema).optional()
+}).strict();
+
+export const AccountScalarWhereWithAggregatesInputSchema: z.ZodType<Prisma.AccountScalarWhereWithAggregatesInput> = z.object({
+  AND: z.union([ z.lazy(() => AccountScalarWhereWithAggregatesInputSchema),z.lazy(() => AccountScalarWhereWithAggregatesInputSchema).array() ]).optional(),
+  OR: z.lazy(() => AccountScalarWhereWithAggregatesInputSchema).array().optional(),
+  NOT: z.union([ z.lazy(() => AccountScalarWhereWithAggregatesInputSchema),z.lazy(() => AccountScalarWhereWithAggregatesInputSchema).array() ]).optional(),
+  id: z.union([ z.lazy(() => StringWithAggregatesFilterSchema),z.string() ]).optional(),
+  userId: z.union([ z.lazy(() => StringWithAggregatesFilterSchema),z.string() ]).optional(),
+  type: z.union([ z.lazy(() => StringWithAggregatesFilterSchema),z.string() ]).optional(),
+  provider: z.union([ z.lazy(() => StringWithAggregatesFilterSchema),z.string() ]).optional(),
+  providerAccountId: z.union([ z.lazy(() => StringWithAggregatesFilterSchema),z.string() ]).optional(),
+  refresh_token: z.union([ z.lazy(() => StringNullableWithAggregatesFilterSchema),z.string() ]).optional().nullable(),
+  access_token: z.union([ z.lazy(() => StringNullableWithAggregatesFilterSchema),z.string() ]).optional().nullable(),
+  expires_at: z.union([ z.lazy(() => IntNullableWithAggregatesFilterSchema),z.number() ]).optional().nullable(),
+  ext_expires_in: z.union([ z.lazy(() => IntNullableWithAggregatesFilterSchema),z.number() ]).optional().nullable(),
+  token_type: z.union([ z.lazy(() => StringNullableWithAggregatesFilterSchema),z.string() ]).optional().nullable(),
+  scope: z.union([ z.lazy(() => StringNullableWithAggregatesFilterSchema),z.string() ]).optional().nullable(),
+  id_token: z.union([ z.lazy(() => StringNullableWithAggregatesFilterSchema),z.string() ]).optional().nullable(),
+  session_state: z.union([ z.lazy(() => StringNullableWithAggregatesFilterSchema),z.string() ]).optional().nullable(),
+  oauth_token_secret: z.union([ z.lazy(() => StringNullableWithAggregatesFilterSchema),z.string() ]).optional().nullable(),
+  oauth_token: z.union([ z.lazy(() => StringNullableWithAggregatesFilterSchema),z.string() ]).optional().nullable(),
+}).strict();
+
+export const SessionWhereInputSchema: z.ZodType<Prisma.SessionWhereInput> = z.object({
+  AND: z.union([ z.lazy(() => SessionWhereInputSchema),z.lazy(() => SessionWhereInputSchema).array() ]).optional(),
+  OR: z.lazy(() => SessionWhereInputSchema).array().optional(),
+  NOT: z.union([ z.lazy(() => SessionWhereInputSchema),z.lazy(() => SessionWhereInputSchema).array() ]).optional(),
+  id: z.union([ z.lazy(() => StringFilterSchema),z.string() ]).optional(),
+  sessionToken: z.union([ z.lazy(() => StringFilterSchema),z.string() ]).optional(),
+  userId: z.union([ z.lazy(() => StringFilterSchema),z.string() ]).optional(),
+  expires: z.union([ z.lazy(() => DateTimeFilterSchema),z.coerce.date() ]).optional(),
+  user: z.union([ z.lazy(() => UserRelationFilterSchema),z.lazy(() => UserWhereInputSchema) ]).optional(),
+}).strict();
+
+export const SessionOrderByWithRelationInputSchema: z.ZodType<Prisma.SessionOrderByWithRelationInput> = z.object({
+  id: z.lazy(() => SortOrderSchema).optional(),
+  sessionToken: z.lazy(() => SortOrderSchema).optional(),
+  userId: z.lazy(() => SortOrderSchema).optional(),
+  expires: z.lazy(() => SortOrderSchema).optional(),
+  user: z.lazy(() => UserOrderByWithRelationInputSchema).optional()
+}).strict();
+
+export const SessionWhereUniqueInputSchema: z.ZodType<Prisma.SessionWhereUniqueInput> = z.object({
+  id: z.string().cuid().optional(),
+  sessionToken: z.string().optional()
+}).strict();
+
+export const SessionOrderByWithAggregationInputSchema: z.ZodType<Prisma.SessionOrderByWithAggregationInput> = z.object({
+  id: z.lazy(() => SortOrderSchema).optional(),
+  sessionToken: z.lazy(() => SortOrderSchema).optional(),
+  userId: z.lazy(() => SortOrderSchema).optional(),
+  expires: z.lazy(() => SortOrderSchema).optional(),
+  _count: z.lazy(() => SessionCountOrderByAggregateInputSchema).optional(),
+  _max: z.lazy(() => SessionMaxOrderByAggregateInputSchema).optional(),
+  _min: z.lazy(() => SessionMinOrderByAggregateInputSchema).optional()
+}).strict();
+
+export const SessionScalarWhereWithAggregatesInputSchema: z.ZodType<Prisma.SessionScalarWhereWithAggregatesInput> = z.object({
+  AND: z.union([ z.lazy(() => SessionScalarWhereWithAggregatesInputSchema),z.lazy(() => SessionScalarWhereWithAggregatesInputSchema).array() ]).optional(),
+  OR: z.lazy(() => SessionScalarWhereWithAggregatesInputSchema).array().optional(),
+  NOT: z.union([ z.lazy(() => SessionScalarWhereWithAggregatesInputSchema),z.lazy(() => SessionScalarWhereWithAggregatesInputSchema).array() ]).optional(),
+  id: z.union([ z.lazy(() => StringWithAggregatesFilterSchema),z.string() ]).optional(),
+  sessionToken: z.union([ z.lazy(() => StringWithAggregatesFilterSchema),z.string() ]).optional(),
+  userId: z.union([ z.lazy(() => StringWithAggregatesFilterSchema),z.string() ]).optional(),
+  expires: z.union([ z.lazy(() => DateTimeWithAggregatesFilterSchema),z.coerce.date() ]).optional(),
+}).strict();
+
+export const UserWhereInputSchema: z.ZodType<Prisma.UserWhereInput> = z.object({
+  AND: z.union([ z.lazy(() => UserWhereInputSchema),z.lazy(() => UserWhereInputSchema).array() ]).optional(),
+  OR: z.lazy(() => UserWhereInputSchema).array().optional(),
+  NOT: z.union([ z.lazy(() => UserWhereInputSchema),z.lazy(() => UserWhereInputSchema).array() ]).optional(),
+  id: z.union([ z.lazy(() => StringFilterSchema),z.string() ]).optional(),
+  name: z.union([ z.lazy(() => StringNullableFilterSchema),z.string() ]).optional().nullable(),
+  email: z.union([ z.lazy(() => StringNullableFilterSchema),z.string() ]).optional().nullable(),
+  emailVerified: z.union([ z.lazy(() => DateTimeNullableFilterSchema),z.coerce.date() ]).optional().nullable(),
+  image: z.union([ z.lazy(() => StringNullableFilterSchema),z.string() ]).optional().nullable(),
+  createdAt: z.union([ z.lazy(() => DateTimeFilterSchema),z.coerce.date() ]).optional(),
+  updatedAt: z.union([ z.lazy(() => DateTimeFilterSchema),z.coerce.date() ]).optional(),
+  games: z.lazy(() => User_GameListRelationFilterSchema).optional(),
+  accounts: z.lazy(() => AccountListRelationFilterSchema).optional(),
+  sessions: z.lazy(() => SessionListRelationFilterSchema).optional()
+}).strict();
+
+export const UserOrderByWithRelationInputSchema: z.ZodType<Prisma.UserOrderByWithRelationInput> = z.object({
+  id: z.lazy(() => SortOrderSchema).optional(),
+  name: z.lazy(() => SortOrderSchema).optional(),
+  email: z.lazy(() => SortOrderSchema).optional(),
+  emailVerified: z.lazy(() => SortOrderSchema).optional(),
+  image: z.lazy(() => SortOrderSchema).optional(),
+  createdAt: z.lazy(() => SortOrderSchema).optional(),
+  updatedAt: z.lazy(() => SortOrderSchema).optional(),
+  games: z.lazy(() => User_GameOrderByRelationAggregateInputSchema).optional(),
+  accounts: z.lazy(() => AccountOrderByRelationAggregateInputSchema).optional(),
+  sessions: z.lazy(() => SessionOrderByRelationAggregateInputSchema).optional()
+}).strict();
+
+export const UserWhereUniqueInputSchema: z.ZodType<Prisma.UserWhereUniqueInput> = z.object({
+  id: z.string().cuid().optional(),
+  email: z.string().optional()
+}).strict();
+
+export const UserOrderByWithAggregationInputSchema: z.ZodType<Prisma.UserOrderByWithAggregationInput> = z.object({
+  id: z.lazy(() => SortOrderSchema).optional(),
+  name: z.lazy(() => SortOrderSchema).optional(),
+  email: z.lazy(() => SortOrderSchema).optional(),
+  emailVerified: z.lazy(() => SortOrderSchema).optional(),
+  image: z.lazy(() => SortOrderSchema).optional(),
+  createdAt: z.lazy(() => SortOrderSchema).optional(),
+  updatedAt: z.lazy(() => SortOrderSchema).optional(),
+  _count: z.lazy(() => UserCountOrderByAggregateInputSchema).optional(),
+  _max: z.lazy(() => UserMaxOrderByAggregateInputSchema).optional(),
+  _min: z.lazy(() => UserMinOrderByAggregateInputSchema).optional()
+}).strict();
+
+export const UserScalarWhereWithAggregatesInputSchema: z.ZodType<Prisma.UserScalarWhereWithAggregatesInput> = z.object({
+  AND: z.union([ z.lazy(() => UserScalarWhereWithAggregatesInputSchema),z.lazy(() => UserScalarWhereWithAggregatesInputSchema).array() ]).optional(),
+  OR: z.lazy(() => UserScalarWhereWithAggregatesInputSchema).array().optional(),
+  NOT: z.union([ z.lazy(() => UserScalarWhereWithAggregatesInputSchema),z.lazy(() => UserScalarWhereWithAggregatesInputSchema).array() ]).optional(),
+  id: z.union([ z.lazy(() => StringWithAggregatesFilterSchema),z.string() ]).optional(),
+  name: z.union([ z.lazy(() => StringNullableWithAggregatesFilterSchema),z.string() ]).optional().nullable(),
+  email: z.union([ z.lazy(() => StringNullableWithAggregatesFilterSchema),z.string() ]).optional().nullable(),
+  emailVerified: z.union([ z.lazy(() => DateTimeNullableWithAggregatesFilterSchema),z.coerce.date() ]).optional().nullable(),
+  image: z.union([ z.lazy(() => StringNullableWithAggregatesFilterSchema),z.string() ]).optional().nullable(),
+  createdAt: z.union([ z.lazy(() => DateTimeWithAggregatesFilterSchema),z.coerce.date() ]).optional(),
+  updatedAt: z.union([ z.lazy(() => DateTimeWithAggregatesFilterSchema),z.coerce.date() ]).optional(),
+}).strict();
+
+export const VerificationTokenWhereInputSchema: z.ZodType<Prisma.VerificationTokenWhereInput> = z.object({
+  AND: z.union([ z.lazy(() => VerificationTokenWhereInputSchema),z.lazy(() => VerificationTokenWhereInputSchema).array() ]).optional(),
+  OR: z.lazy(() => VerificationTokenWhereInputSchema).array().optional(),
+  NOT: z.union([ z.lazy(() => VerificationTokenWhereInputSchema),z.lazy(() => VerificationTokenWhereInputSchema).array() ]).optional(),
+  identifier: z.union([ z.lazy(() => StringFilterSchema),z.string() ]).optional(),
+  token: z.union([ z.lazy(() => StringFilterSchema),z.string() ]).optional(),
+  expires: z.union([ z.lazy(() => DateTimeFilterSchema),z.coerce.date() ]).optional(),
+}).strict();
+
+export const VerificationTokenOrderByWithRelationInputSchema: z.ZodType<Prisma.VerificationTokenOrderByWithRelationInput> = z.object({
+  identifier: z.lazy(() => SortOrderSchema).optional(),
+  token: z.lazy(() => SortOrderSchema).optional(),
+  expires: z.lazy(() => SortOrderSchema).optional()
+}).strict();
+
+export const VerificationTokenWhereUniqueInputSchema: z.ZodType<Prisma.VerificationTokenWhereUniqueInput> = z.object({
+  token: z.string().optional(),
+  identifier_token: z.lazy(() => VerificationTokenIdentifierTokenCompoundUniqueInputSchema).optional()
+}).strict();
+
+export const VerificationTokenOrderByWithAggregationInputSchema: z.ZodType<Prisma.VerificationTokenOrderByWithAggregationInput> = z.object({
+  identifier: z.lazy(() => SortOrderSchema).optional(),
+  token: z.lazy(() => SortOrderSchema).optional(),
+  expires: z.lazy(() => SortOrderSchema).optional(),
+  _count: z.lazy(() => VerificationTokenCountOrderByAggregateInputSchema).optional(),
+  _max: z.lazy(() => VerificationTokenMaxOrderByAggregateInputSchema).optional(),
+  _min: z.lazy(() => VerificationTokenMinOrderByAggregateInputSchema).optional()
+}).strict();
+
+export const VerificationTokenScalarWhereWithAggregatesInputSchema: z.ZodType<Prisma.VerificationTokenScalarWhereWithAggregatesInput> = z.object({
+  AND: z.union([ z.lazy(() => VerificationTokenScalarWhereWithAggregatesInputSchema),z.lazy(() => VerificationTokenScalarWhereWithAggregatesInputSchema).array() ]).optional(),
+  OR: z.lazy(() => VerificationTokenScalarWhereWithAggregatesInputSchema).array().optional(),
+  NOT: z.union([ z.lazy(() => VerificationTokenScalarWhereWithAggregatesInputSchema),z.lazy(() => VerificationTokenScalarWhereWithAggregatesInputSchema).array() ]).optional(),
+  identifier: z.union([ z.lazy(() => StringWithAggregatesFilterSchema),z.string() ]).optional(),
+  token: z.union([ z.lazy(() => StringWithAggregatesFilterSchema),z.string() ]).optional(),
+  expires: z.union([ z.lazy(() => DateTimeWithAggregatesFilterSchema),z.coerce.date() ]).optional(),
+}).strict();
+
+export const GameWhereInputSchema: z.ZodType<Prisma.GameWhereInput> = z.object({
+  AND: z.union([ z.lazy(() => GameWhereInputSchema),z.lazy(() => GameWhereInputSchema).array() ]).optional(),
+  OR: z.lazy(() => GameWhereInputSchema).array().optional(),
+  NOT: z.union([ z.lazy(() => GameWhereInputSchema),z.lazy(() => GameWhereInputSchema).array() ]).optional(),
+  id: z.union([ z.lazy(() => StringFilterSchema),z.string() ]).optional(),
+  createdAt: z.union([ z.lazy(() => DateTimeFilterSchema),z.coerce.date() ]).optional(),
+  updatedAt: z.union([ z.lazy(() => DateTimeFilterSchema),z.coerce.date() ]).optional(),
+  state: z.union([ z.lazy(() => EnumGameStateFilterSchema),z.lazy(() => GameStateSchema) ]).optional(),
+  gamePin: z.union([ z.lazy(() => GamepinRelationFilterSchema),z.lazy(() => GamepinWhereInputSchema) ]).optional().nullable(),
+  users: z.lazy(() => User_GameListRelationFilterSchema).optional()
+}).strict();
+
+export const GameOrderByWithRelationInputSchema: z.ZodType<Prisma.GameOrderByWithRelationInput> = z.object({
+  id: z.lazy(() => SortOrderSchema).optional(),
+  createdAt: z.lazy(() => SortOrderSchema).optional(),
+  updatedAt: z.lazy(() => SortOrderSchema).optional(),
+  state: z.lazy(() => SortOrderSchema).optional(),
+  gamePin: z.lazy(() => GamepinOrderByWithRelationInputSchema).optional(),
+  users: z.lazy(() => User_GameOrderByRelationAggregateInputSchema).optional()
+}).strict();
+
+export const GameWhereUniqueInputSchema: z.ZodType<Prisma.GameWhereUniqueInput> = z.object({
+  id: z.string().cuid().optional()
+}).strict();
+
+export const GameOrderByWithAggregationInputSchema: z.ZodType<Prisma.GameOrderByWithAggregationInput> = z.object({
+  id: z.lazy(() => SortOrderSchema).optional(),
+  createdAt: z.lazy(() => SortOrderSchema).optional(),
+  updatedAt: z.lazy(() => SortOrderSchema).optional(),
+  state: z.lazy(() => SortOrderSchema).optional(),
+  _count: z.lazy(() => GameCountOrderByAggregateInputSchema).optional(),
+  _max: z.lazy(() => GameMaxOrderByAggregateInputSchema).optional(),
+  _min: z.lazy(() => GameMinOrderByAggregateInputSchema).optional()
+}).strict();
+
+export const GameScalarWhereWithAggregatesInputSchema: z.ZodType<Prisma.GameScalarWhereWithAggregatesInput> = z.object({
+  AND: z.union([ z.lazy(() => GameScalarWhereWithAggregatesInputSchema),z.lazy(() => GameScalarWhereWithAggregatesInputSchema).array() ]).optional(),
+  OR: z.lazy(() => GameScalarWhereWithAggregatesInputSchema).array().optional(),
+  NOT: z.union([ z.lazy(() => GameScalarWhereWithAggregatesInputSchema),z.lazy(() => GameScalarWhereWithAggregatesInputSchema).array() ]).optional(),
+  id: z.union([ z.lazy(() => StringWithAggregatesFilterSchema),z.string() ]).optional(),
+  createdAt: z.union([ z.lazy(() => DateTimeWithAggregatesFilterSchema),z.coerce.date() ]).optional(),
+  updatedAt: z.union([ z.lazy(() => DateTimeWithAggregatesFilterSchema),z.coerce.date() ]).optional(),
+  state: z.union([ z.lazy(() => EnumGameStateWithAggregatesFilterSchema),z.lazy(() => GameStateSchema) ]).optional(),
+}).strict();
+
+export const GamepinWhereInputSchema: z.ZodType<Prisma.GamepinWhereInput> = z.object({
+  AND: z.union([ z.lazy(() => GamepinWhereInputSchema),z.lazy(() => GamepinWhereInputSchema).array() ]).optional(),
+  OR: z.lazy(() => GamepinWhereInputSchema).array().optional(),
+  NOT: z.union([ z.lazy(() => GamepinWhereInputSchema),z.lazy(() => GamepinWhereInputSchema).array() ]).optional(),
+  id: z.union([ z.lazy(() => StringFilterSchema),z.string() ]).optional(),
+  createdAt: z.union([ z.lazy(() => DateTimeFilterSchema),z.coerce.date() ]).optional(),
+  pin: z.union([ z.lazy(() => StringFilterSchema),z.string() ]).optional(),
+  gameId: z.union([ z.lazy(() => StringFilterSchema),z.string() ]).optional(),
+  game: z.union([ z.lazy(() => GameRelationFilterSchema),z.lazy(() => GameWhereInputSchema) ]).optional(),
+}).strict();
+
+export const GamepinOrderByWithRelationInputSchema: z.ZodType<Prisma.GamepinOrderByWithRelationInput> = z.object({
+  id: z.lazy(() => SortOrderSchema).optional(),
+  createdAt: z.lazy(() => SortOrderSchema).optional(),
+  pin: z.lazy(() => SortOrderSchema).optional(),
+  gameId: z.lazy(() => SortOrderSchema).optional(),
+  game: z.lazy(() => GameOrderByWithRelationInputSchema).optional()
+}).strict();
+
+export const GamepinWhereUniqueInputSchema: z.ZodType<Prisma.GamepinWhereUniqueInput> = z.object({
+  id: z.string().cuid().optional(),
+  pin: z.string().optional(),
+  gameId: z.string().optional()
+}).strict();
+
+export const GamepinOrderByWithAggregationInputSchema: z.ZodType<Prisma.GamepinOrderByWithAggregationInput> = z.object({
+  id: z.lazy(() => SortOrderSchema).optional(),
+  createdAt: z.lazy(() => SortOrderSchema).optional(),
+  pin: z.lazy(() => SortOrderSchema).optional(),
+  gameId: z.lazy(() => SortOrderSchema).optional(),
+  _count: z.lazy(() => GamepinCountOrderByAggregateInputSchema).optional(),
+  _max: z.lazy(() => GamepinMaxOrderByAggregateInputSchema).optional(),
+  _min: z.lazy(() => GamepinMinOrderByAggregateInputSchema).optional()
+}).strict();
+
+export const GamepinScalarWhereWithAggregatesInputSchema: z.ZodType<Prisma.GamepinScalarWhereWithAggregatesInput> = z.object({
+  AND: z.union([ z.lazy(() => GamepinScalarWhereWithAggregatesInputSchema),z.lazy(() => GamepinScalarWhereWithAggregatesInputSchema).array() ]).optional(),
+  OR: z.lazy(() => GamepinScalarWhereWithAggregatesInputSchema).array().optional(),
+  NOT: z.union([ z.lazy(() => GamepinScalarWhereWithAggregatesInputSchema),z.lazy(() => GamepinScalarWhereWithAggregatesInputSchema).array() ]).optional(),
+  id: z.union([ z.lazy(() => StringWithAggregatesFilterSchema),z.string() ]).optional(),
+  createdAt: z.union([ z.lazy(() => DateTimeWithAggregatesFilterSchema),z.coerce.date() ]).optional(),
+  pin: z.union([ z.lazy(() => StringWithAggregatesFilterSchema),z.string() ]).optional(),
+  gameId: z.union([ z.lazy(() => StringWithAggregatesFilterSchema),z.string() ]).optional(),
+}).strict();
+
+export const User_GameWhereInputSchema: z.ZodType<Prisma.User_GameWhereInput> = z.object({
+  AND: z.union([ z.lazy(() => User_GameWhereInputSchema),z.lazy(() => User_GameWhereInputSchema).array() ]).optional(),
+  OR: z.lazy(() => User_GameWhereInputSchema).array().optional(),
+  NOT: z.union([ z.lazy(() => User_GameWhereInputSchema),z.lazy(() => User_GameWhereInputSchema).array() ]).optional(),
+  id: z.union([ z.lazy(() => StringFilterSchema),z.string() ]).optional(),
+  createdAt: z.union([ z.lazy(() => DateTimeFilterSchema),z.coerce.date() ]).optional(),
+  gameId: z.union([ z.lazy(() => StringFilterSchema),z.string() ]).optional(),
+  userId: z.union([ z.lazy(() => StringFilterSchema),z.string() ]).optional(),
+  isOwner: z.union([ z.lazy(() => BoolFilterSchema),z.boolean() ]).optional(),
+  moves: z.lazy(() => MoveListRelationFilterSchema).optional(),
+  chats: z.lazy(() => ChatListRelationFilterSchema).optional(),
+  game: z.union([ z.lazy(() => GameRelationFilterSchema),z.lazy(() => GameWhereInputSchema) ]).optional(),
+  user: z.union([ z.lazy(() => UserRelationFilterSchema),z.lazy(() => UserWhereInputSchema) ]).optional(),
+}).strict();
+
+export const User_GameOrderByWithRelationInputSchema: z.ZodType<Prisma.User_GameOrderByWithRelationInput> = z.object({
+  id: z.lazy(() => SortOrderSchema).optional(),
+  createdAt: z.lazy(() => SortOrderSchema).optional(),
+  gameId: z.lazy(() => SortOrderSchema).optional(),
+  userId: z.lazy(() => SortOrderSchema).optional(),
+  isOwner: z.lazy(() => SortOrderSchema).optional(),
+  moves: z.lazy(() => MoveOrderByRelationAggregateInputSchema).optional(),
+  chats: z.lazy(() => ChatOrderByRelationAggregateInputSchema).optional(),
+  game: z.lazy(() => GameOrderByWithRelationInputSchema).optional(),
+  user: z.lazy(() => UserOrderByWithRelationInputSchema).optional()
+}).strict();
+
+export const User_GameWhereUniqueInputSchema: z.ZodType<Prisma.User_GameWhereUniqueInput> = z.object({
+  id: z.string().cuid().optional(),
+  gameId_userId: z.lazy(() => User_GameGameIdUserIdCompoundUniqueInputSchema).optional()
+}).strict();
+
+export const User_GameOrderByWithAggregationInputSchema: z.ZodType<Prisma.User_GameOrderByWithAggregationInput> = z.object({
+  id: z.lazy(() => SortOrderSchema).optional(),
+  createdAt: z.lazy(() => SortOrderSchema).optional(),
+  gameId: z.lazy(() => SortOrderSchema).optional(),
+  userId: z.lazy(() => SortOrderSchema).optional(),
+  isOwner: z.lazy(() => SortOrderSchema).optional(),
+  _count: z.lazy(() => User_GameCountOrderByAggregateInputSchema).optional(),
+  _max: z.lazy(() => User_GameMaxOrderByAggregateInputSchema).optional(),
+  _min: z.lazy(() => User_GameMinOrderByAggregateInputSchema).optional()
+}).strict();
+
+export const User_GameScalarWhereWithAggregatesInputSchema: z.ZodType<Prisma.User_GameScalarWhereWithAggregatesInput> = z.object({
+  AND: z.union([ z.lazy(() => User_GameScalarWhereWithAggregatesInputSchema),z.lazy(() => User_GameScalarWhereWithAggregatesInputSchema).array() ]).optional(),
+  OR: z.lazy(() => User_GameScalarWhereWithAggregatesInputSchema).array().optional(),
+  NOT: z.union([ z.lazy(() => User_GameScalarWhereWithAggregatesInputSchema),z.lazy(() => User_GameScalarWhereWithAggregatesInputSchema).array() ]).optional(),
+  id: z.union([ z.lazy(() => StringWithAggregatesFilterSchema),z.string() ]).optional(),
+  createdAt: z.union([ z.lazy(() => DateTimeWithAggregatesFilterSchema),z.coerce.date() ]).optional(),
+  gameId: z.union([ z.lazy(() => StringWithAggregatesFilterSchema),z.string() ]).optional(),
+  userId: z.union([ z.lazy(() => StringWithAggregatesFilterSchema),z.string() ]).optional(),
+  isOwner: z.union([ z.lazy(() => BoolWithAggregatesFilterSchema),z.boolean() ]).optional(),
+}).strict();
+
+export const MoveWhereInputSchema: z.ZodType<Prisma.MoveWhereInput> = z.object({
+  AND: z.union([ z.lazy(() => MoveWhereInputSchema),z.lazy(() => MoveWhereInputSchema).array() ]).optional(),
+  OR: z.lazy(() => MoveWhereInputSchema).array().optional(),
+  NOT: z.union([ z.lazy(() => MoveWhereInputSchema),z.lazy(() => MoveWhereInputSchema).array() ]).optional(),
+  id: z.union([ z.lazy(() => StringFilterSchema),z.string() ]).optional(),
+  createdAt: z.union([ z.lazy(() => DateTimeFilterSchema),z.coerce.date() ]).optional(),
+  index: z.union([ z.lazy(() => IntFilterSchema),z.number() ]).optional(),
+  user_game_id: z.union([ z.lazy(() => StringFilterSchema),z.string() ]).optional(),
+  user_game: z.union([ z.lazy(() => User_GameRelationFilterSchema),z.lazy(() => User_GameWhereInputSchema) ]).optional(),
+}).strict();
+
+export const MoveOrderByWithRelationInputSchema: z.ZodType<Prisma.MoveOrderByWithRelationInput> = z.object({
+  id: z.lazy(() => SortOrderSchema).optional(),
+  createdAt: z.lazy(() => SortOrderSchema).optional(),
+  index: z.lazy(() => SortOrderSchema).optional(),
+  user_game_id: z.lazy(() => SortOrderSchema).optional(),
+  user_game: z.lazy(() => User_GameOrderByWithRelationInputSchema).optional()
+}).strict();
+
+export const MoveWhereUniqueInputSchema: z.ZodType<Prisma.MoveWhereUniqueInput> = z.object({
+  id: z.string().cuid().optional()
+}).strict();
+
+export const MoveOrderByWithAggregationInputSchema: z.ZodType<Prisma.MoveOrderByWithAggregationInput> = z.object({
+  id: z.lazy(() => SortOrderSchema).optional(),
+  createdAt: z.lazy(() => SortOrderSchema).optional(),
+  index: z.lazy(() => SortOrderSchema).optional(),
+  user_game_id: z.lazy(() => SortOrderSchema).optional(),
+  _count: z.lazy(() => MoveCountOrderByAggregateInputSchema).optional(),
+  _avg: z.lazy(() => MoveAvgOrderByAggregateInputSchema).optional(),
+  _max: z.lazy(() => MoveMaxOrderByAggregateInputSchema).optional(),
+  _min: z.lazy(() => MoveMinOrderByAggregateInputSchema).optional(),
+  _sum: z.lazy(() => MoveSumOrderByAggregateInputSchema).optional()
+}).strict();
+
+export const MoveScalarWhereWithAggregatesInputSchema: z.ZodType<Prisma.MoveScalarWhereWithAggregatesInput> = z.object({
+  AND: z.union([ z.lazy(() => MoveScalarWhereWithAggregatesInputSchema),z.lazy(() => MoveScalarWhereWithAggregatesInputSchema).array() ]).optional(),
+  OR: z.lazy(() => MoveScalarWhereWithAggregatesInputSchema).array().optional(),
+  NOT: z.union([ z.lazy(() => MoveScalarWhereWithAggregatesInputSchema),z.lazy(() => MoveScalarWhereWithAggregatesInputSchema).array() ]).optional(),
+  id: z.union([ z.lazy(() => StringWithAggregatesFilterSchema),z.string() ]).optional(),
+  createdAt: z.union([ z.lazy(() => DateTimeWithAggregatesFilterSchema),z.coerce.date() ]).optional(),
+  index: z.union([ z.lazy(() => IntWithAggregatesFilterSchema),z.number() ]).optional(),
+  user_game_id: z.union([ z.lazy(() => StringWithAggregatesFilterSchema),z.string() ]).optional(),
+}).strict();
+
+export const ChatWhereInputSchema: z.ZodType<Prisma.ChatWhereInput> = z.object({
+  AND: z.union([ z.lazy(() => ChatWhereInputSchema),z.lazy(() => ChatWhereInputSchema).array() ]).optional(),
+  OR: z.lazy(() => ChatWhereInputSchema).array().optional(),
+  NOT: z.union([ z.lazy(() => ChatWhereInputSchema),z.lazy(() => ChatWhereInputSchema).array() ]).optional(),
+  id: z.union([ z.lazy(() => StringFilterSchema),z.string() ]).optional(),
+  createdAt: z.union([ z.lazy(() => DateTimeFilterSchema),z.coerce.date() ]).optional(),
+  message: z.union([ z.lazy(() => StringNullableFilterSchema),z.string() ]).optional().nullable(),
+  event: z.union([ z.lazy(() => StringNullableFilterSchema),z.string() ]).optional().nullable(),
+  user_game_id: z.union([ z.lazy(() => StringFilterSchema),z.string() ]).optional(),
+  user_game: z.union([ z.lazy(() => User_GameRelationFilterSchema),z.lazy(() => User_GameWhereInputSchema) ]).optional(),
+}).strict();
+
+export const ChatOrderByWithRelationInputSchema: z.ZodType<Prisma.ChatOrderByWithRelationInput> = z.object({
+  id: z.lazy(() => SortOrderSchema).optional(),
+  createdAt: z.lazy(() => SortOrderSchema).optional(),
+  message: z.lazy(() => SortOrderSchema).optional(),
+  event: z.lazy(() => SortOrderSchema).optional(),
+  user_game_id: z.lazy(() => SortOrderSchema).optional(),
+  user_game: z.lazy(() => User_GameOrderByWithRelationInputSchema).optional()
+}).strict();
+
+export const ChatWhereUniqueInputSchema: z.ZodType<Prisma.ChatWhereUniqueInput> = z.object({
+  id: z.string().cuid().optional()
+}).strict();
+
+export const ChatOrderByWithAggregationInputSchema: z.ZodType<Prisma.ChatOrderByWithAggregationInput> = z.object({
+  id: z.lazy(() => SortOrderSchema).optional(),
+  createdAt: z.lazy(() => SortOrderSchema).optional(),
+  message: z.lazy(() => SortOrderSchema).optional(),
+  event: z.lazy(() => SortOrderSchema).optional(),
+  user_game_id: z.lazy(() => SortOrderSchema).optional(),
+  _count: z.lazy(() => ChatCountOrderByAggregateInputSchema).optional(),
+  _max: z.lazy(() => ChatMaxOrderByAggregateInputSchema).optional(),
+  _min: z.lazy(() => ChatMinOrderByAggregateInputSchema).optional()
+}).strict();
+
+export const ChatScalarWhereWithAggregatesInputSchema: z.ZodType<Prisma.ChatScalarWhereWithAggregatesInput> = z.object({
+  AND: z.union([ z.lazy(() => ChatScalarWhereWithAggregatesInputSchema),z.lazy(() => ChatScalarWhereWithAggregatesInputSchema).array() ]).optional(),
+  OR: z.lazy(() => ChatScalarWhereWithAggregatesInputSchema).array().optional(),
+  NOT: z.union([ z.lazy(() => ChatScalarWhereWithAggregatesInputSchema),z.lazy(() => ChatScalarWhereWithAggregatesInputSchema).array() ]).optional(),
+  id: z.union([ z.lazy(() => StringWithAggregatesFilterSchema),z.string() ]).optional(),
+  createdAt: z.union([ z.lazy(() => DateTimeWithAggregatesFilterSchema),z.coerce.date() ]).optional(),
+  message: z.union([ z.lazy(() => StringNullableWithAggregatesFilterSchema),z.string() ]).optional().nullable(),
+  event: z.union([ z.lazy(() => StringNullableWithAggregatesFilterSchema),z.string() ]).optional().nullable(),
+  user_game_id: z.union([ z.lazy(() => StringWithAggregatesFilterSchema),z.string() ]).optional(),
+}).strict();
+
+export const AccountCreateInputSchema: z.ZodType<Prisma.AccountCreateInput> = z.object({
+  id: z.string().cuid().optional(),
+  type: z.string(),
+  provider: z.string(),
+  providerAccountId: z.string(),
+  refresh_token: z.string().optional().nullable(),
+  access_token: z.string().optional().nullable(),
+  expires_at: z.number().int().optional().nullable(),
+  ext_expires_in: z.number().int().optional().nullable(),
+  token_type: z.string().optional().nullable(),
+  scope: z.string().optional().nullable(),
+  id_token: z.string().optional().nullable(),
+  session_state: z.string().optional().nullable(),
+  oauth_token_secret: z.string().optional().nullable(),
+  oauth_token: z.string().optional().nullable(),
+  user: z.lazy(() => UserCreateNestedOneWithoutAccountsInputSchema)
+}).strict();
+
+export const AccountUncheckedCreateInputSchema: z.ZodType<Prisma.AccountUncheckedCreateInput> = z.object({
+  id: z.string().cuid().optional(),
+  userId: z.string(),
+  type: z.string(),
+  provider: z.string(),
+  providerAccountId: z.string(),
+  refresh_token: z.string().optional().nullable(),
+  access_token: z.string().optional().nullable(),
+  expires_at: z.number().int().optional().nullable(),
+  ext_expires_in: z.number().int().optional().nullable(),
+  token_type: z.string().optional().nullable(),
+  scope: z.string().optional().nullable(),
+  id_token: z.string().optional().nullable(),
+  session_state: z.string().optional().nullable(),
+  oauth_token_secret: z.string().optional().nullable(),
+  oauth_token: z.string().optional().nullable()
+}).strict();
+
+export const AccountUpdateInputSchema: z.ZodType<Prisma.AccountUpdateInput> = z.object({
+  id: z.union([ z.string().cuid(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  type: z.union([ z.string(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  provider: z.union([ z.string(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  providerAccountId: z.union([ z.string(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  refresh_token: z.union([ z.string(),z.lazy(() => NullableStringFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  access_token: z.union([ z.string(),z.lazy(() => NullableStringFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  expires_at: z.union([ z.number().int(),z.lazy(() => NullableIntFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  ext_expires_in: z.union([ z.number().int(),z.lazy(() => NullableIntFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  token_type: z.union([ z.string(),z.lazy(() => NullableStringFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  scope: z.union([ z.string(),z.lazy(() => NullableStringFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  id_token: z.union([ z.string(),z.lazy(() => NullableStringFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  session_state: z.union([ z.string(),z.lazy(() => NullableStringFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  oauth_token_secret: z.union([ z.string(),z.lazy(() => NullableStringFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  oauth_token: z.union([ z.string(),z.lazy(() => NullableStringFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  user: z.lazy(() => UserUpdateOneRequiredWithoutAccountsNestedInputSchema).optional()
+}).strict();
+
+export const AccountUncheckedUpdateInputSchema: z.ZodType<Prisma.AccountUncheckedUpdateInput> = z.object({
+  id: z.union([ z.string().cuid(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  userId: z.union([ z.string(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  type: z.union([ z.string(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  provider: z.union([ z.string(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  providerAccountId: z.union([ z.string(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  refresh_token: z.union([ z.string(),z.lazy(() => NullableStringFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  access_token: z.union([ z.string(),z.lazy(() => NullableStringFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  expires_at: z.union([ z.number().int(),z.lazy(() => NullableIntFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  ext_expires_in: z.union([ z.number().int(),z.lazy(() => NullableIntFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  token_type: z.union([ z.string(),z.lazy(() => NullableStringFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  scope: z.union([ z.string(),z.lazy(() => NullableStringFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  id_token: z.union([ z.string(),z.lazy(() => NullableStringFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  session_state: z.union([ z.string(),z.lazy(() => NullableStringFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  oauth_token_secret: z.union([ z.string(),z.lazy(() => NullableStringFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  oauth_token: z.union([ z.string(),z.lazy(() => NullableStringFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+}).strict();
+
+export const AccountCreateManyInputSchema: z.ZodType<Prisma.AccountCreateManyInput> = z.object({
+  id: z.string().cuid().optional(),
+  userId: z.string(),
+  type: z.string(),
+  provider: z.string(),
+  providerAccountId: z.string(),
+  refresh_token: z.string().optional().nullable(),
+  access_token: z.string().optional().nullable(),
+  expires_at: z.number().int().optional().nullable(),
+  ext_expires_in: z.number().int().optional().nullable(),
+  token_type: z.string().optional().nullable(),
+  scope: z.string().optional().nullable(),
+  id_token: z.string().optional().nullable(),
+  session_state: z.string().optional().nullable(),
+  oauth_token_secret: z.string().optional().nullable(),
+  oauth_token: z.string().optional().nullable()
+}).strict();
+
+export const AccountUpdateManyMutationInputSchema: z.ZodType<Prisma.AccountUpdateManyMutationInput> = z.object({
+  id: z.union([ z.string().cuid(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  type: z.union([ z.string(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  provider: z.union([ z.string(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  providerAccountId: z.union([ z.string(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  refresh_token: z.union([ z.string(),z.lazy(() => NullableStringFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  access_token: z.union([ z.string(),z.lazy(() => NullableStringFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  expires_at: z.union([ z.number().int(),z.lazy(() => NullableIntFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  ext_expires_in: z.union([ z.number().int(),z.lazy(() => NullableIntFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  token_type: z.union([ z.string(),z.lazy(() => NullableStringFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  scope: z.union([ z.string(),z.lazy(() => NullableStringFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  id_token: z.union([ z.string(),z.lazy(() => NullableStringFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  session_state: z.union([ z.string(),z.lazy(() => NullableStringFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  oauth_token_secret: z.union([ z.string(),z.lazy(() => NullableStringFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  oauth_token: z.union([ z.string(),z.lazy(() => NullableStringFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+}).strict();
+
+export const AccountUncheckedUpdateManyInputSchema: z.ZodType<Prisma.AccountUncheckedUpdateManyInput> = z.object({
+  id: z.union([ z.string().cuid(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  userId: z.union([ z.string(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  type: z.union([ z.string(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  provider: z.union([ z.string(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  providerAccountId: z.union([ z.string(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  refresh_token: z.union([ z.string(),z.lazy(() => NullableStringFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  access_token: z.union([ z.string(),z.lazy(() => NullableStringFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  expires_at: z.union([ z.number().int(),z.lazy(() => NullableIntFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  ext_expires_in: z.union([ z.number().int(),z.lazy(() => NullableIntFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  token_type: z.union([ z.string(),z.lazy(() => NullableStringFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  scope: z.union([ z.string(),z.lazy(() => NullableStringFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  id_token: z.union([ z.string(),z.lazy(() => NullableStringFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  session_state: z.union([ z.string(),z.lazy(() => NullableStringFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  oauth_token_secret: z.union([ z.string(),z.lazy(() => NullableStringFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  oauth_token: z.union([ z.string(),z.lazy(() => NullableStringFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+}).strict();
+
+export const SessionCreateInputSchema: z.ZodType<Prisma.SessionCreateInput> = z.object({
+  id: z.string().cuid().optional(),
+  sessionToken: z.string(),
+  expires: z.coerce.date(),
+  user: z.lazy(() => UserCreateNestedOneWithoutSessionsInputSchema)
+}).strict();
+
+export const SessionUncheckedCreateInputSchema: z.ZodType<Prisma.SessionUncheckedCreateInput> = z.object({
+  id: z.string().cuid().optional(),
+  sessionToken: z.string(),
+  userId: z.string(),
+  expires: z.coerce.date()
+}).strict();
+
+export const SessionUpdateInputSchema: z.ZodType<Prisma.SessionUpdateInput> = z.object({
+  id: z.union([ z.string().cuid(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  sessionToken: z.union([ z.string(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  expires: z.union([ z.coerce.date(),z.lazy(() => DateTimeFieldUpdateOperationsInputSchema) ]).optional(),
+  user: z.lazy(() => UserUpdateOneRequiredWithoutSessionsNestedInputSchema).optional()
+}).strict();
+
+export const SessionUncheckedUpdateInputSchema: z.ZodType<Prisma.SessionUncheckedUpdateInput> = z.object({
+  id: z.union([ z.string().cuid(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  sessionToken: z.union([ z.string(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  userId: z.union([ z.string(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  expires: z.union([ z.coerce.date(),z.lazy(() => DateTimeFieldUpdateOperationsInputSchema) ]).optional(),
+}).strict();
+
+export const SessionCreateManyInputSchema: z.ZodType<Prisma.SessionCreateManyInput> = z.object({
+  id: z.string().cuid().optional(),
+  sessionToken: z.string(),
+  userId: z.string(),
+  expires: z.coerce.date()
+}).strict();
+
+export const SessionUpdateManyMutationInputSchema: z.ZodType<Prisma.SessionUpdateManyMutationInput> = z.object({
+  id: z.union([ z.string().cuid(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  sessionToken: z.union([ z.string(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  expires: z.union([ z.coerce.date(),z.lazy(() => DateTimeFieldUpdateOperationsInputSchema) ]).optional(),
+}).strict();
+
+export const SessionUncheckedUpdateManyInputSchema: z.ZodType<Prisma.SessionUncheckedUpdateManyInput> = z.object({
+  id: z.union([ z.string().cuid(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  sessionToken: z.union([ z.string(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  userId: z.union([ z.string(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  expires: z.union([ z.coerce.date(),z.lazy(() => DateTimeFieldUpdateOperationsInputSchema) ]).optional(),
+}).strict();
+
+export const UserCreateInputSchema: z.ZodType<Prisma.UserCreateInput> = z.object({
+  id: z.string().cuid().optional(),
+  name: z.string().optional().nullable(),
+  email: z.string().optional().nullable(),
+  emailVerified: z.coerce.date().optional().nullable(),
+  image: z.string().optional().nullable(),
+  createdAt: z.coerce.date().optional(),
+  updatedAt: z.coerce.date().optional(),
+  games: z.lazy(() => User_GameCreateNestedManyWithoutUserInputSchema).optional(),
+  accounts: z.lazy(() => AccountCreateNestedManyWithoutUserInputSchema).optional(),
+  sessions: z.lazy(() => SessionCreateNestedManyWithoutUserInputSchema).optional()
+}).strict();
+
+export const UserUncheckedCreateInputSchema: z.ZodType<Prisma.UserUncheckedCreateInput> = z.object({
+  id: z.string().cuid().optional(),
+  name: z.string().optional().nullable(),
+  email: z.string().optional().nullable(),
+  emailVerified: z.coerce.date().optional().nullable(),
+  image: z.string().optional().nullable(),
+  createdAt: z.coerce.date().optional(),
+  updatedAt: z.coerce.date().optional(),
+  games: z.lazy(() => User_GameUncheckedCreateNestedManyWithoutUserInputSchema).optional(),
+  accounts: z.lazy(() => AccountUncheckedCreateNestedManyWithoutUserInputSchema).optional(),
+  sessions: z.lazy(() => SessionUncheckedCreateNestedManyWithoutUserInputSchema).optional()
+}).strict();
+
+export const UserUpdateInputSchema: z.ZodType<Prisma.UserUpdateInput> = z.object({
+  id: z.union([ z.string().cuid(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  name: z.union([ z.string(),z.lazy(() => NullableStringFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  email: z.union([ z.string(),z.lazy(() => NullableStringFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  emailVerified: z.union([ z.coerce.date(),z.lazy(() => NullableDateTimeFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  image: z.union([ z.string(),z.lazy(() => NullableStringFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  createdAt: z.union([ z.coerce.date(),z.lazy(() => DateTimeFieldUpdateOperationsInputSchema) ]).optional(),
+  updatedAt: z.union([ z.coerce.date(),z.lazy(() => DateTimeFieldUpdateOperationsInputSchema) ]).optional(),
+  games: z.lazy(() => User_GameUpdateManyWithoutUserNestedInputSchema).optional(),
+  accounts: z.lazy(() => AccountUpdateManyWithoutUserNestedInputSchema).optional(),
+  sessions: z.lazy(() => SessionUpdateManyWithoutUserNestedInputSchema).optional()
+}).strict();
+
+export const UserUncheckedUpdateInputSchema: z.ZodType<Prisma.UserUncheckedUpdateInput> = z.object({
+  id: z.union([ z.string().cuid(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  name: z.union([ z.string(),z.lazy(() => NullableStringFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  email: z.union([ z.string(),z.lazy(() => NullableStringFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  emailVerified: z.union([ z.coerce.date(),z.lazy(() => NullableDateTimeFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  image: z.union([ z.string(),z.lazy(() => NullableStringFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  createdAt: z.union([ z.coerce.date(),z.lazy(() => DateTimeFieldUpdateOperationsInputSchema) ]).optional(),
+  updatedAt: z.union([ z.coerce.date(),z.lazy(() => DateTimeFieldUpdateOperationsInputSchema) ]).optional(),
+  games: z.lazy(() => User_GameUncheckedUpdateManyWithoutUserNestedInputSchema).optional(),
+  accounts: z.lazy(() => AccountUncheckedUpdateManyWithoutUserNestedInputSchema).optional(),
+  sessions: z.lazy(() => SessionUncheckedUpdateManyWithoutUserNestedInputSchema).optional()
+}).strict();
+
+export const UserCreateManyInputSchema: z.ZodType<Prisma.UserCreateManyInput> = z.object({
+  id: z.string().cuid().optional(),
+  name: z.string().optional().nullable(),
+  email: z.string().optional().nullable(),
+  emailVerified: z.coerce.date().optional().nullable(),
+  image: z.string().optional().nullable(),
+  createdAt: z.coerce.date().optional(),
+  updatedAt: z.coerce.date().optional()
+}).strict();
+
+export const UserUpdateManyMutationInputSchema: z.ZodType<Prisma.UserUpdateManyMutationInput> = z.object({
+  id: z.union([ z.string().cuid(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  name: z.union([ z.string(),z.lazy(() => NullableStringFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  email: z.union([ z.string(),z.lazy(() => NullableStringFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  emailVerified: z.union([ z.coerce.date(),z.lazy(() => NullableDateTimeFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  image: z.union([ z.string(),z.lazy(() => NullableStringFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  createdAt: z.union([ z.coerce.date(),z.lazy(() => DateTimeFieldUpdateOperationsInputSchema) ]).optional(),
+  updatedAt: z.union([ z.coerce.date(),z.lazy(() => DateTimeFieldUpdateOperationsInputSchema) ]).optional(),
+}).strict();
+
+export const UserUncheckedUpdateManyInputSchema: z.ZodType<Prisma.UserUncheckedUpdateManyInput> = z.object({
+  id: z.union([ z.string().cuid(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  name: z.union([ z.string(),z.lazy(() => NullableStringFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  email: z.union([ z.string(),z.lazy(() => NullableStringFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  emailVerified: z.union([ z.coerce.date(),z.lazy(() => NullableDateTimeFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  image: z.union([ z.string(),z.lazy(() => NullableStringFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  createdAt: z.union([ z.coerce.date(),z.lazy(() => DateTimeFieldUpdateOperationsInputSchema) ]).optional(),
+  updatedAt: z.union([ z.coerce.date(),z.lazy(() => DateTimeFieldUpdateOperationsInputSchema) ]).optional(),
+}).strict();
+
+export const VerificationTokenCreateInputSchema: z.ZodType<Prisma.VerificationTokenCreateInput> = z.object({
+  identifier: z.string(),
+  token: z.string(),
+  expires: z.coerce.date()
+}).strict();
+
+export const VerificationTokenUncheckedCreateInputSchema: z.ZodType<Prisma.VerificationTokenUncheckedCreateInput> = z.object({
+  identifier: z.string(),
+  token: z.string(),
+  expires: z.coerce.date()
+}).strict();
+
+export const VerificationTokenUpdateInputSchema: z.ZodType<Prisma.VerificationTokenUpdateInput> = z.object({
+  identifier: z.union([ z.string(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  token: z.union([ z.string(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  expires: z.union([ z.coerce.date(),z.lazy(() => DateTimeFieldUpdateOperationsInputSchema) ]).optional(),
+}).strict();
+
+export const VerificationTokenUncheckedUpdateInputSchema: z.ZodType<Prisma.VerificationTokenUncheckedUpdateInput> = z.object({
+  identifier: z.union([ z.string(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  token: z.union([ z.string(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  expires: z.union([ z.coerce.date(),z.lazy(() => DateTimeFieldUpdateOperationsInputSchema) ]).optional(),
+}).strict();
+
+export const VerificationTokenCreateManyInputSchema: z.ZodType<Prisma.VerificationTokenCreateManyInput> = z.object({
+  identifier: z.string(),
+  token: z.string(),
+  expires: z.coerce.date()
+}).strict();
+
+export const VerificationTokenUpdateManyMutationInputSchema: z.ZodType<Prisma.VerificationTokenUpdateManyMutationInput> = z.object({
+  identifier: z.union([ z.string(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  token: z.union([ z.string(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  expires: z.union([ z.coerce.date(),z.lazy(() => DateTimeFieldUpdateOperationsInputSchema) ]).optional(),
+}).strict();
+
+export const VerificationTokenUncheckedUpdateManyInputSchema: z.ZodType<Prisma.VerificationTokenUncheckedUpdateManyInput> = z.object({
+  identifier: z.union([ z.string(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  token: z.union([ z.string(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  expires: z.union([ z.coerce.date(),z.lazy(() => DateTimeFieldUpdateOperationsInputSchema) ]).optional(),
+}).strict();
+
+export const GameCreateInputSchema: z.ZodType<Prisma.GameCreateInput> = z.object({
+  id: z.string().cuid().optional(),
+  createdAt: z.coerce.date().optional(),
+  updatedAt: z.coerce.date().optional(),
+  state: z.lazy(() => GameStateSchema).optional(),
+  gamePin: z.lazy(() => GamepinCreateNestedOneWithoutGameInputSchema).optional(),
+  users: z.lazy(() => User_GameCreateNestedManyWithoutGameInputSchema).optional()
+}).strict();
+
+export const GameUncheckedCreateInputSchema: z.ZodType<Prisma.GameUncheckedCreateInput> = z.object({
+  id: z.string().cuid().optional(),
+  createdAt: z.coerce.date().optional(),
+  updatedAt: z.coerce.date().optional(),
+  state: z.lazy(() => GameStateSchema).optional(),
+  gamePin: z.lazy(() => GamepinUncheckedCreateNestedOneWithoutGameInputSchema).optional(),
+  users: z.lazy(() => User_GameUncheckedCreateNestedManyWithoutGameInputSchema).optional()
+}).strict();
+
+export const GameUpdateInputSchema: z.ZodType<Prisma.GameUpdateInput> = z.object({
+  id: z.union([ z.string().cuid(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  createdAt: z.union([ z.coerce.date(),z.lazy(() => DateTimeFieldUpdateOperationsInputSchema) ]).optional(),
+  updatedAt: z.union([ z.coerce.date(),z.lazy(() => DateTimeFieldUpdateOperationsInputSchema) ]).optional(),
+  state: z.union([ z.lazy(() => GameStateSchema),z.lazy(() => EnumGameStateFieldUpdateOperationsInputSchema) ]).optional(),
+  gamePin: z.lazy(() => GamepinUpdateOneWithoutGameNestedInputSchema).optional(),
+  users: z.lazy(() => User_GameUpdateManyWithoutGameNestedInputSchema).optional()
+}).strict();
+
+export const GameUncheckedUpdateInputSchema: z.ZodType<Prisma.GameUncheckedUpdateInput> = z.object({
+  id: z.union([ z.string().cuid(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  createdAt: z.union([ z.coerce.date(),z.lazy(() => DateTimeFieldUpdateOperationsInputSchema) ]).optional(),
+  updatedAt: z.union([ z.coerce.date(),z.lazy(() => DateTimeFieldUpdateOperationsInputSchema) ]).optional(),
+  state: z.union([ z.lazy(() => GameStateSchema),z.lazy(() => EnumGameStateFieldUpdateOperationsInputSchema) ]).optional(),
+  gamePin: z.lazy(() => GamepinUncheckedUpdateOneWithoutGameNestedInputSchema).optional(),
+  users: z.lazy(() => User_GameUncheckedUpdateManyWithoutGameNestedInputSchema).optional()
+}).strict();
+
+export const GameCreateManyInputSchema: z.ZodType<Prisma.GameCreateManyInput> = z.object({
+  id: z.string().cuid().optional(),
+  createdAt: z.coerce.date().optional(),
+  updatedAt: z.coerce.date().optional(),
+  state: z.lazy(() => GameStateSchema).optional()
+}).strict();
+
+export const GameUpdateManyMutationInputSchema: z.ZodType<Prisma.GameUpdateManyMutationInput> = z.object({
+  id: z.union([ z.string().cuid(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  createdAt: z.union([ z.coerce.date(),z.lazy(() => DateTimeFieldUpdateOperationsInputSchema) ]).optional(),
+  updatedAt: z.union([ z.coerce.date(),z.lazy(() => DateTimeFieldUpdateOperationsInputSchema) ]).optional(),
+  state: z.union([ z.lazy(() => GameStateSchema),z.lazy(() => EnumGameStateFieldUpdateOperationsInputSchema) ]).optional(),
+}).strict();
+
+export const GameUncheckedUpdateManyInputSchema: z.ZodType<Prisma.GameUncheckedUpdateManyInput> = z.object({
+  id: z.union([ z.string().cuid(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  createdAt: z.union([ z.coerce.date(),z.lazy(() => DateTimeFieldUpdateOperationsInputSchema) ]).optional(),
+  updatedAt: z.union([ z.coerce.date(),z.lazy(() => DateTimeFieldUpdateOperationsInputSchema) ]).optional(),
+  state: z.union([ z.lazy(() => GameStateSchema),z.lazy(() => EnumGameStateFieldUpdateOperationsInputSchema) ]).optional(),
+}).strict();
+
+export const GamepinCreateInputSchema: z.ZodType<Prisma.GamepinCreateInput> = z.object({
+  id: z.string().cuid().optional(),
+  createdAt: z.coerce.date().optional(),
+  pin: z.string(),
+  game: z.lazy(() => GameCreateNestedOneWithoutGamePinInputSchema)
+}).strict();
+
+export const GamepinUncheckedCreateInputSchema: z.ZodType<Prisma.GamepinUncheckedCreateInput> = z.object({
+  id: z.string().cuid().optional(),
+  createdAt: z.coerce.date().optional(),
+  pin: z.string(),
+  gameId: z.string()
+}).strict();
+
+export const GamepinUpdateInputSchema: z.ZodType<Prisma.GamepinUpdateInput> = z.object({
+  id: z.union([ z.string().cuid(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  createdAt: z.union([ z.coerce.date(),z.lazy(() => DateTimeFieldUpdateOperationsInputSchema) ]).optional(),
+  pin: z.union([ z.string(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  game: z.lazy(() => GameUpdateOneRequiredWithoutGamePinNestedInputSchema).optional()
+}).strict();
+
+export const GamepinUncheckedUpdateInputSchema: z.ZodType<Prisma.GamepinUncheckedUpdateInput> = z.object({
+  id: z.union([ z.string().cuid(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  createdAt: z.union([ z.coerce.date(),z.lazy(() => DateTimeFieldUpdateOperationsInputSchema) ]).optional(),
+  pin: z.union([ z.string(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  gameId: z.union([ z.string(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+}).strict();
+
+export const GamepinCreateManyInputSchema: z.ZodType<Prisma.GamepinCreateManyInput> = z.object({
+  id: z.string().cuid().optional(),
+  createdAt: z.coerce.date().optional(),
+  pin: z.string(),
+  gameId: z.string()
+}).strict();
+
+export const GamepinUpdateManyMutationInputSchema: z.ZodType<Prisma.GamepinUpdateManyMutationInput> = z.object({
+  id: z.union([ z.string().cuid(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  createdAt: z.union([ z.coerce.date(),z.lazy(() => DateTimeFieldUpdateOperationsInputSchema) ]).optional(),
+  pin: z.union([ z.string(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+}).strict();
+
+export const GamepinUncheckedUpdateManyInputSchema: z.ZodType<Prisma.GamepinUncheckedUpdateManyInput> = z.object({
+  id: z.union([ z.string().cuid(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  createdAt: z.union([ z.coerce.date(),z.lazy(() => DateTimeFieldUpdateOperationsInputSchema) ]).optional(),
+  pin: z.union([ z.string(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  gameId: z.union([ z.string(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+}).strict();
+
+export const User_GameCreateInputSchema: z.ZodType<Prisma.User_GameCreateInput> = z.object({
+  id: z.string().cuid().optional(),
+  createdAt: z.coerce.date().optional(),
+  isOwner: z.boolean(),
+  moves: z.lazy(() => MoveCreateNestedManyWithoutUser_gameInputSchema).optional(),
+  chats: z.lazy(() => ChatCreateNestedManyWithoutUser_gameInputSchema).optional(),
+  game: z.lazy(() => GameCreateNestedOneWithoutUsersInputSchema),
+  user: z.lazy(() => UserCreateNestedOneWithoutGamesInputSchema)
+}).strict();
+
+export const User_GameUncheckedCreateInputSchema: z.ZodType<Prisma.User_GameUncheckedCreateInput> = z.object({
+  id: z.string().cuid().optional(),
+  createdAt: z.coerce.date().optional(),
+  gameId: z.string(),
+  userId: z.string(),
+  isOwner: z.boolean(),
+  moves: z.lazy(() => MoveUncheckedCreateNestedManyWithoutUser_gameInputSchema).optional(),
+  chats: z.lazy(() => ChatUncheckedCreateNestedManyWithoutUser_gameInputSchema).optional()
+}).strict();
+
+export const User_GameUpdateInputSchema: z.ZodType<Prisma.User_GameUpdateInput> = z.object({
+  id: z.union([ z.string().cuid(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  createdAt: z.union([ z.coerce.date(),z.lazy(() => DateTimeFieldUpdateOperationsInputSchema) ]).optional(),
+  isOwner: z.union([ z.boolean(),z.lazy(() => BoolFieldUpdateOperationsInputSchema) ]).optional(),
+  moves: z.lazy(() => MoveUpdateManyWithoutUser_gameNestedInputSchema).optional(),
+  chats: z.lazy(() => ChatUpdateManyWithoutUser_gameNestedInputSchema).optional(),
+  game: z.lazy(() => GameUpdateOneRequiredWithoutUsersNestedInputSchema).optional(),
+  user: z.lazy(() => UserUpdateOneRequiredWithoutGamesNestedInputSchema).optional()
+}).strict();
+
+export const User_GameUncheckedUpdateInputSchema: z.ZodType<Prisma.User_GameUncheckedUpdateInput> = z.object({
+  id: z.union([ z.string().cuid(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  createdAt: z.union([ z.coerce.date(),z.lazy(() => DateTimeFieldUpdateOperationsInputSchema) ]).optional(),
+  gameId: z.union([ z.string(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  userId: z.union([ z.string(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  isOwner: z.union([ z.boolean(),z.lazy(() => BoolFieldUpdateOperationsInputSchema) ]).optional(),
+  moves: z.lazy(() => MoveUncheckedUpdateManyWithoutUser_gameNestedInputSchema).optional(),
+  chats: z.lazy(() => ChatUncheckedUpdateManyWithoutUser_gameNestedInputSchema).optional()
+}).strict();
+
+export const User_GameCreateManyInputSchema: z.ZodType<Prisma.User_GameCreateManyInput> = z.object({
+  id: z.string().cuid().optional(),
+  createdAt: z.coerce.date().optional(),
+  gameId: z.string(),
+  userId: z.string(),
+  isOwner: z.boolean()
+}).strict();
+
+export const User_GameUpdateManyMutationInputSchema: z.ZodType<Prisma.User_GameUpdateManyMutationInput> = z.object({
+  id: z.union([ z.string().cuid(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  createdAt: z.union([ z.coerce.date(),z.lazy(() => DateTimeFieldUpdateOperationsInputSchema) ]).optional(),
+  isOwner: z.union([ z.boolean(),z.lazy(() => BoolFieldUpdateOperationsInputSchema) ]).optional(),
+}).strict();
+
+export const User_GameUncheckedUpdateManyInputSchema: z.ZodType<Prisma.User_GameUncheckedUpdateManyInput> = z.object({
+  id: z.union([ z.string().cuid(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  createdAt: z.union([ z.coerce.date(),z.lazy(() => DateTimeFieldUpdateOperationsInputSchema) ]).optional(),
+  gameId: z.union([ z.string(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  userId: z.union([ z.string(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  isOwner: z.union([ z.boolean(),z.lazy(() => BoolFieldUpdateOperationsInputSchema) ]).optional(),
+}).strict();
+
+export const MoveCreateInputSchema: z.ZodType<Prisma.MoveCreateInput> = z.object({
+  id: z.string().cuid().optional(),
+  createdAt: z.coerce.date().optional(),
+  index: z.number().int(),
+  user_game: z.lazy(() => User_GameCreateNestedOneWithoutMovesInputSchema)
+}).strict();
+
+export const MoveUncheckedCreateInputSchema: z.ZodType<Prisma.MoveUncheckedCreateInput> = z.object({
+  id: z.string().cuid().optional(),
+  createdAt: z.coerce.date().optional(),
+  index: z.number().int(),
+  user_game_id: z.string()
+}).strict();
+
+export const MoveUpdateInputSchema: z.ZodType<Prisma.MoveUpdateInput> = z.object({
+  id: z.union([ z.string().cuid(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  createdAt: z.union([ z.coerce.date(),z.lazy(() => DateTimeFieldUpdateOperationsInputSchema) ]).optional(),
+  index: z.union([ z.number().int(),z.lazy(() => IntFieldUpdateOperationsInputSchema) ]).optional(),
+  user_game: z.lazy(() => User_GameUpdateOneRequiredWithoutMovesNestedInputSchema).optional()
+}).strict();
+
+export const MoveUncheckedUpdateInputSchema: z.ZodType<Prisma.MoveUncheckedUpdateInput> = z.object({
+  id: z.union([ z.string().cuid(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  createdAt: z.union([ z.coerce.date(),z.lazy(() => DateTimeFieldUpdateOperationsInputSchema) ]).optional(),
+  index: z.union([ z.number().int(),z.lazy(() => IntFieldUpdateOperationsInputSchema) ]).optional(),
+  user_game_id: z.union([ z.string(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+}).strict();
+
+export const MoveCreateManyInputSchema: z.ZodType<Prisma.MoveCreateManyInput> = z.object({
+  id: z.string().cuid().optional(),
+  createdAt: z.coerce.date().optional(),
+  index: z.number().int(),
+  user_game_id: z.string()
+}).strict();
+
+export const MoveUpdateManyMutationInputSchema: z.ZodType<Prisma.MoveUpdateManyMutationInput> = z.object({
+  id: z.union([ z.string().cuid(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  createdAt: z.union([ z.coerce.date(),z.lazy(() => DateTimeFieldUpdateOperationsInputSchema) ]).optional(),
+  index: z.union([ z.number().int(),z.lazy(() => IntFieldUpdateOperationsInputSchema) ]).optional(),
+}).strict();
+
+export const MoveUncheckedUpdateManyInputSchema: z.ZodType<Prisma.MoveUncheckedUpdateManyInput> = z.object({
+  id: z.union([ z.string().cuid(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  createdAt: z.union([ z.coerce.date(),z.lazy(() => DateTimeFieldUpdateOperationsInputSchema) ]).optional(),
+  index: z.union([ z.number().int(),z.lazy(() => IntFieldUpdateOperationsInputSchema) ]).optional(),
+  user_game_id: z.union([ z.string(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+}).strict();
+
+export const ChatCreateInputSchema: z.ZodType<Prisma.ChatCreateInput> = z.object({
+  id: z.string().cuid().optional(),
+  createdAt: z.coerce.date().optional(),
+  message: z.string().optional().nullable(),
+  event: z.string().optional().nullable(),
+  user_game: z.lazy(() => User_GameCreateNestedOneWithoutChatsInputSchema)
+}).strict();
+
+export const ChatUncheckedCreateInputSchema: z.ZodType<Prisma.ChatUncheckedCreateInput> = z.object({
+  id: z.string().cuid().optional(),
+  createdAt: z.coerce.date().optional(),
+  message: z.string().optional().nullable(),
+  event: z.string().optional().nullable(),
+  user_game_id: z.string()
+}).strict();
+
+export const ChatUpdateInputSchema: z.ZodType<Prisma.ChatUpdateInput> = z.object({
+  id: z.union([ z.string().cuid(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  createdAt: z.union([ z.coerce.date(),z.lazy(() => DateTimeFieldUpdateOperationsInputSchema) ]).optional(),
+  message: z.union([ z.string(),z.lazy(() => NullableStringFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  event: z.union([ z.string(),z.lazy(() => NullableStringFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  user_game: z.lazy(() => User_GameUpdateOneRequiredWithoutChatsNestedInputSchema).optional()
+}).strict();
+
+export const ChatUncheckedUpdateInputSchema: z.ZodType<Prisma.ChatUncheckedUpdateInput> = z.object({
+  id: z.union([ z.string().cuid(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  createdAt: z.union([ z.coerce.date(),z.lazy(() => DateTimeFieldUpdateOperationsInputSchema) ]).optional(),
+  message: z.union([ z.string(),z.lazy(() => NullableStringFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  event: z.union([ z.string(),z.lazy(() => NullableStringFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  user_game_id: z.union([ z.string(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+}).strict();
+
+export const ChatCreateManyInputSchema: z.ZodType<Prisma.ChatCreateManyInput> = z.object({
+  id: z.string().cuid().optional(),
+  createdAt: z.coerce.date().optional(),
+  message: z.string().optional().nullable(),
+  event: z.string().optional().nullable(),
+  user_game_id: z.string()
+}).strict();
+
+export const ChatUpdateManyMutationInputSchema: z.ZodType<Prisma.ChatUpdateManyMutationInput> = z.object({
+  id: z.union([ z.string().cuid(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  createdAt: z.union([ z.coerce.date(),z.lazy(() => DateTimeFieldUpdateOperationsInputSchema) ]).optional(),
+  message: z.union([ z.string(),z.lazy(() => NullableStringFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  event: z.union([ z.string(),z.lazy(() => NullableStringFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+}).strict();
+
+export const ChatUncheckedUpdateManyInputSchema: z.ZodType<Prisma.ChatUncheckedUpdateManyInput> = z.object({
+  id: z.union([ z.string().cuid(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  createdAt: z.union([ z.coerce.date(),z.lazy(() => DateTimeFieldUpdateOperationsInputSchema) ]).optional(),
+  message: z.union([ z.string(),z.lazy(() => NullableStringFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  event: z.union([ z.string(),z.lazy(() => NullableStringFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  user_game_id: z.union([ z.string(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+}).strict();
+
+export const StringFilterSchema: z.ZodType<Prisma.StringFilter> = z.object({
+  equals: z.string().optional(),
+  in: z.string().array().optional(),
+  notIn: z.string().array().optional(),
+  lt: z.string().optional(),
+  lte: z.string().optional(),
+  gt: z.string().optional(),
+  gte: z.string().optional(),
+  contains: z.string().optional(),
+  startsWith: z.string().optional(),
+  endsWith: z.string().optional(),
+  not: z.union([ z.string(),z.lazy(() => NestedStringFilterSchema) ]).optional(),
+}).strict();
+
+export const StringNullableFilterSchema: z.ZodType<Prisma.StringNullableFilter> = z.object({
+  equals: z.string().optional().nullable(),
+  in: z.string().array().optional().nullable(),
+  notIn: z.string().array().optional().nullable(),
+  lt: z.string().optional(),
+  lte: z.string().optional(),
+  gt: z.string().optional(),
+  gte: z.string().optional(),
+  contains: z.string().optional(),
+  startsWith: z.string().optional(),
+  endsWith: z.string().optional(),
+  not: z.union([ z.string(),z.lazy(() => NestedStringNullableFilterSchema) ]).optional().nullable(),
+}).strict();
+
+export const IntNullableFilterSchema: z.ZodType<Prisma.IntNullableFilter> = 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(() => NestedIntNullableFilterSchema) ]).optional().nullable(),
+}).strict();
+
+export const UserRelationFilterSchema: z.ZodType<Prisma.UserRelationFilter> = z.object({
+  is: z.lazy(() => UserWhereInputSchema).optional(),
+  isNot: z.lazy(() => UserWhereInputSchema).optional()
+}).strict();
+
+export const AccountProviderProviderAccountIdCompoundUniqueInputSchema: z.ZodType<Prisma.AccountProviderProviderAccountIdCompoundUniqueInput> = z.object({
+  provider: z.string(),
+  providerAccountId: z.string()
+}).strict();
+
+export const AccountCountOrderByAggregateInputSchema: z.ZodType<Prisma.AccountCountOrderByAggregateInput> = z.object({
+  id: z.lazy(() => SortOrderSchema).optional(),
+  userId: z.lazy(() => SortOrderSchema).optional(),
+  type: z.lazy(() => SortOrderSchema).optional(),
+  provider: z.lazy(() => SortOrderSchema).optional(),
+  providerAccountId: z.lazy(() => SortOrderSchema).optional(),
+  refresh_token: z.lazy(() => SortOrderSchema).optional(),
+  access_token: z.lazy(() => SortOrderSchema).optional(),
+  expires_at: z.lazy(() => SortOrderSchema).optional(),
+  ext_expires_in: z.lazy(() => SortOrderSchema).optional(),
+  token_type: z.lazy(() => SortOrderSchema).optional(),
+  scope: z.lazy(() => SortOrderSchema).optional(),
+  id_token: z.lazy(() => SortOrderSchema).optional(),
+  session_state: z.lazy(() => SortOrderSchema).optional(),
+  oauth_token_secret: z.lazy(() => SortOrderSchema).optional(),
+  oauth_token: z.lazy(() => SortOrderSchema).optional()
+}).strict();
+
+export const AccountAvgOrderByAggregateInputSchema: z.ZodType<Prisma.AccountAvgOrderByAggregateInput> = z.object({
+  expires_at: z.lazy(() => SortOrderSchema).optional(),
+  ext_expires_in: z.lazy(() => SortOrderSchema).optional()
+}).strict();
+
+export const AccountMaxOrderByAggregateInputSchema: z.ZodType<Prisma.AccountMaxOrderByAggregateInput> = z.object({
+  id: z.lazy(() => SortOrderSchema).optional(),
+  userId: z.lazy(() => SortOrderSchema).optional(),
+  type: z.lazy(() => SortOrderSchema).optional(),
+  provider: z.lazy(() => SortOrderSchema).optional(),
+  providerAccountId: z.lazy(() => SortOrderSchema).optional(),
+  refresh_token: z.lazy(() => SortOrderSchema).optional(),
+  access_token: z.lazy(() => SortOrderSchema).optional(),
+  expires_at: z.lazy(() => SortOrderSchema).optional(),
+  ext_expires_in: z.lazy(() => SortOrderSchema).optional(),
+  token_type: z.lazy(() => SortOrderSchema).optional(),
+  scope: z.lazy(() => SortOrderSchema).optional(),
+  id_token: z.lazy(() => SortOrderSchema).optional(),
+  session_state: z.lazy(() => SortOrderSchema).optional(),
+  oauth_token_secret: z.lazy(() => SortOrderSchema).optional(),
+  oauth_token: z.lazy(() => SortOrderSchema).optional()
+}).strict();
+
+export const AccountMinOrderByAggregateInputSchema: z.ZodType<Prisma.AccountMinOrderByAggregateInput> = z.object({
+  id: z.lazy(() => SortOrderSchema).optional(),
+  userId: z.lazy(() => SortOrderSchema).optional(),
+  type: z.lazy(() => SortOrderSchema).optional(),
+  provider: z.lazy(() => SortOrderSchema).optional(),
+  providerAccountId: z.lazy(() => SortOrderSchema).optional(),
+  refresh_token: z.lazy(() => SortOrderSchema).optional(),
+  access_token: z.lazy(() => SortOrderSchema).optional(),
+  expires_at: z.lazy(() => SortOrderSchema).optional(),
+  ext_expires_in: z.lazy(() => SortOrderSchema).optional(),
+  token_type: z.lazy(() => SortOrderSchema).optional(),
+  scope: z.lazy(() => SortOrderSchema).optional(),
+  id_token: z.lazy(() => SortOrderSchema).optional(),
+  session_state: z.lazy(() => SortOrderSchema).optional(),
+  oauth_token_secret: z.lazy(() => SortOrderSchema).optional(),
+  oauth_token: z.lazy(() => SortOrderSchema).optional()
+}).strict();
+
+export const AccountSumOrderByAggregateInputSchema: z.ZodType<Prisma.AccountSumOrderByAggregateInput> = z.object({
+  expires_at: z.lazy(() => SortOrderSchema).optional(),
+  ext_expires_in: z.lazy(() => SortOrderSchema).optional()
+}).strict();
+
+export const StringWithAggregatesFilterSchema: z.ZodType<Prisma.StringWithAggregatesFilter> = z.object({
+  equals: z.string().optional(),
+  in: z.string().array().optional(),
+  notIn: z.string().array().optional(),
+  lt: z.string().optional(),
+  lte: z.string().optional(),
+  gt: z.string().optional(),
+  gte: z.string().optional(),
+  contains: z.string().optional(),
+  startsWith: z.string().optional(),
+  endsWith: z.string().optional(),
+  not: z.union([ z.string(),z.lazy(() => NestedStringWithAggregatesFilterSchema) ]).optional(),
+  _count: z.lazy(() => NestedIntFilterSchema).optional(),
+  _min: z.lazy(() => NestedStringFilterSchema).optional(),
+  _max: z.lazy(() => NestedStringFilterSchema).optional()
+}).strict();
+
+export const StringNullableWithAggregatesFilterSchema: z.ZodType<Prisma.StringNullableWithAggregatesFilter> = z.object({
+  equals: z.string().optional().nullable(),
+  in: z.string().array().optional().nullable(),
+  notIn: z.string().array().optional().nullable(),
+  lt: z.string().optional(),
+  lte: z.string().optional(),
+  gt: z.string().optional(),
+  gte: z.string().optional(),
+  contains: z.string().optional(),
+  startsWith: z.string().optional(),
+  endsWith: z.string().optional(),
+  not: z.union([ z.string(),z.lazy(() => NestedStringNullableWithAggregatesFilterSchema) ]).optional().nullable(),
+  _count: z.lazy(() => NestedIntNullableFilterSchema).optional(),
+  _min: z.lazy(() => NestedStringNullableFilterSchema).optional(),
+  _max: z.lazy(() => NestedStringNullableFilterSchema).optional()
+}).strict();
+
+export const IntNullableWithAggregatesFilterSchema: z.ZodType<Prisma.IntNullableWithAggregatesFilter> = 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(() => NestedIntNullableWithAggregatesFilterSchema) ]).optional().nullable(),
+  _count: z.lazy(() => NestedIntNullableFilterSchema).optional(),
+  _avg: z.lazy(() => NestedFloatNullableFilterSchema).optional(),
+  _sum: z.lazy(() => NestedIntNullableFilterSchema).optional(),
+  _min: z.lazy(() => NestedIntNullableFilterSchema).optional(),
+  _max: z.lazy(() => NestedIntNullableFilterSchema).optional()
+}).strict();
+
+export const DateTimeFilterSchema: z.ZodType<Prisma.DateTimeFilter> = z.object({
+  equals: z.coerce.date().optional(),
+  in: z.coerce.date().array().optional(),
+  notIn: z.coerce.date().array().optional(),
+  lt: z.coerce.date().optional(),
+  lte: z.coerce.date().optional(),
+  gt: z.coerce.date().optional(),
+  gte: z.coerce.date().optional(),
+  not: z.union([ z.coerce.date(),z.lazy(() => NestedDateTimeFilterSchema) ]).optional(),
+}).strict();
+
+export const SessionCountOrderByAggregateInputSchema: z.ZodType<Prisma.SessionCountOrderByAggregateInput> = z.object({
+  id: z.lazy(() => SortOrderSchema).optional(),
+  sessionToken: z.lazy(() => SortOrderSchema).optional(),
+  userId: z.lazy(() => SortOrderSchema).optional(),
+  expires: z.lazy(() => SortOrderSchema).optional()
+}).strict();
+
+export const SessionMaxOrderByAggregateInputSchema: z.ZodType<Prisma.SessionMaxOrderByAggregateInput> = z.object({
+  id: z.lazy(() => SortOrderSchema).optional(),
+  sessionToken: z.lazy(() => SortOrderSchema).optional(),
+  userId: z.lazy(() => SortOrderSchema).optional(),
+  expires: z.lazy(() => SortOrderSchema).optional()
+}).strict();
+
+export const SessionMinOrderByAggregateInputSchema: z.ZodType<Prisma.SessionMinOrderByAggregateInput> = z.object({
+  id: z.lazy(() => SortOrderSchema).optional(),
+  sessionToken: z.lazy(() => SortOrderSchema).optional(),
+  userId: z.lazy(() => SortOrderSchema).optional(),
+  expires: z.lazy(() => SortOrderSchema).optional()
+}).strict();
+
+export const DateTimeWithAggregatesFilterSchema: z.ZodType<Prisma.DateTimeWithAggregatesFilter> = z.object({
+  equals: z.coerce.date().optional(),
+  in: z.coerce.date().array().optional(),
+  notIn: z.coerce.date().array().optional(),
+  lt: z.coerce.date().optional(),
+  lte: z.coerce.date().optional(),
+  gt: z.coerce.date().optional(),
+  gte: z.coerce.date().optional(),
+  not: z.union([ z.coerce.date(),z.lazy(() => NestedDateTimeWithAggregatesFilterSchema) ]).optional(),
+  _count: z.lazy(() => NestedIntFilterSchema).optional(),
+  _min: z.lazy(() => NestedDateTimeFilterSchema).optional(),
+  _max: z.lazy(() => NestedDateTimeFilterSchema).optional()
+}).strict();
+
+export const DateTimeNullableFilterSchema: z.ZodType<Prisma.DateTimeNullableFilter> = z.object({
+  equals: z.coerce.date().optional().nullable(),
+  in: z.coerce.date().array().optional().nullable(),
+  notIn: z.coerce.date().array().optional().nullable(),
+  lt: z.coerce.date().optional(),
+  lte: z.coerce.date().optional(),
+  gt: z.coerce.date().optional(),
+  gte: z.coerce.date().optional(),
+  not: z.union([ z.coerce.date(),z.lazy(() => NestedDateTimeNullableFilterSchema) ]).optional().nullable(),
+}).strict();
+
+export const User_GameListRelationFilterSchema: z.ZodType<Prisma.User_GameListRelationFilter> = z.object({
+  every: z.lazy(() => User_GameWhereInputSchema).optional(),
+  some: z.lazy(() => User_GameWhereInputSchema).optional(),
+  none: z.lazy(() => User_GameWhereInputSchema).optional()
+}).strict();
+
+export const AccountListRelationFilterSchema: z.ZodType<Prisma.AccountListRelationFilter> = z.object({
+  every: z.lazy(() => AccountWhereInputSchema).optional(),
+  some: z.lazy(() => AccountWhereInputSchema).optional(),
+  none: z.lazy(() => AccountWhereInputSchema).optional()
+}).strict();
+
+export const SessionListRelationFilterSchema: z.ZodType<Prisma.SessionListRelationFilter> = z.object({
+  every: z.lazy(() => SessionWhereInputSchema).optional(),
+  some: z.lazy(() => SessionWhereInputSchema).optional(),
+  none: z.lazy(() => SessionWhereInputSchema).optional()
+}).strict();
+
+export const User_GameOrderByRelationAggregateInputSchema: z.ZodType<Prisma.User_GameOrderByRelationAggregateInput> = z.object({
+  _count: z.lazy(() => SortOrderSchema).optional()
+}).strict();
+
+export const AccountOrderByRelationAggregateInputSchema: z.ZodType<Prisma.AccountOrderByRelationAggregateInput> = z.object({
+  _count: z.lazy(() => SortOrderSchema).optional()
+}).strict();
+
+export const SessionOrderByRelationAggregateInputSchema: z.ZodType<Prisma.SessionOrderByRelationAggregateInput> = z.object({
+  _count: z.lazy(() => SortOrderSchema).optional()
+}).strict();
+
+export const UserCountOrderByAggregateInputSchema: z.ZodType<Prisma.UserCountOrderByAggregateInput> = z.object({
+  id: z.lazy(() => SortOrderSchema).optional(),
+  name: z.lazy(() => SortOrderSchema).optional(),
+  email: z.lazy(() => SortOrderSchema).optional(),
+  emailVerified: z.lazy(() => SortOrderSchema).optional(),
+  image: z.lazy(() => SortOrderSchema).optional(),
+  createdAt: z.lazy(() => SortOrderSchema).optional(),
+  updatedAt: z.lazy(() => SortOrderSchema).optional()
+}).strict();
+
+export const UserMaxOrderByAggregateInputSchema: z.ZodType<Prisma.UserMaxOrderByAggregateInput> = z.object({
+  id: z.lazy(() => SortOrderSchema).optional(),
+  name: z.lazy(() => SortOrderSchema).optional(),
+  email: z.lazy(() => SortOrderSchema).optional(),
+  emailVerified: z.lazy(() => SortOrderSchema).optional(),
+  image: z.lazy(() => SortOrderSchema).optional(),
+  createdAt: z.lazy(() => SortOrderSchema).optional(),
+  updatedAt: z.lazy(() => SortOrderSchema).optional()
+}).strict();
+
+export const UserMinOrderByAggregateInputSchema: z.ZodType<Prisma.UserMinOrderByAggregateInput> = z.object({
+  id: z.lazy(() => SortOrderSchema).optional(),
+  name: z.lazy(() => SortOrderSchema).optional(),
+  email: z.lazy(() => SortOrderSchema).optional(),
+  emailVerified: z.lazy(() => SortOrderSchema).optional(),
+  image: z.lazy(() => SortOrderSchema).optional(),
+  createdAt: z.lazy(() => SortOrderSchema).optional(),
+  updatedAt: z.lazy(() => SortOrderSchema).optional()
+}).strict();
+
+export const DateTimeNullableWithAggregatesFilterSchema: z.ZodType<Prisma.DateTimeNullableWithAggregatesFilter> = z.object({
+  equals: z.coerce.date().optional().nullable(),
+  in: z.coerce.date().array().optional().nullable(),
+  notIn: z.coerce.date().array().optional().nullable(),
+  lt: z.coerce.date().optional(),
+  lte: z.coerce.date().optional(),
+  gt: z.coerce.date().optional(),
+  gte: z.coerce.date().optional(),
+  not: z.union([ z.coerce.date(),z.lazy(() => NestedDateTimeNullableWithAggregatesFilterSchema) ]).optional().nullable(),
+  _count: z.lazy(() => NestedIntNullableFilterSchema).optional(),
+  _min: z.lazy(() => NestedDateTimeNullableFilterSchema).optional(),
+  _max: z.lazy(() => NestedDateTimeNullableFilterSchema).optional()
+}).strict();
+
+export const VerificationTokenIdentifierTokenCompoundUniqueInputSchema: z.ZodType<Prisma.VerificationTokenIdentifierTokenCompoundUniqueInput> = z.object({
+  identifier: z.string(),
+  token: z.string()
+}).strict();
+
+export const VerificationTokenCountOrderByAggregateInputSchema: z.ZodType<Prisma.VerificationTokenCountOrderByAggregateInput> = z.object({
+  identifier: z.lazy(() => SortOrderSchema).optional(),
+  token: z.lazy(() => SortOrderSchema).optional(),
+  expires: z.lazy(() => SortOrderSchema).optional()
+}).strict();
+
+export const VerificationTokenMaxOrderByAggregateInputSchema: z.ZodType<Prisma.VerificationTokenMaxOrderByAggregateInput> = z.object({
+  identifier: z.lazy(() => SortOrderSchema).optional(),
+  token: z.lazy(() => SortOrderSchema).optional(),
+  expires: z.lazy(() => SortOrderSchema).optional()
+}).strict();
+
+export const VerificationTokenMinOrderByAggregateInputSchema: z.ZodType<Prisma.VerificationTokenMinOrderByAggregateInput> = z.object({
+  identifier: z.lazy(() => SortOrderSchema).optional(),
+  token: z.lazy(() => SortOrderSchema).optional(),
+  expires: z.lazy(() => SortOrderSchema).optional()
+}).strict();
+
+export const EnumGameStateFilterSchema: z.ZodType<Prisma.EnumGameStateFilter> = z.object({
+  equals: z.lazy(() => GameStateSchema).optional(),
+  in: z.lazy(() => GameStateSchema).array().optional(),
+  notIn: z.lazy(() => GameStateSchema).array().optional(),
+  not: z.union([ z.lazy(() => GameStateSchema),z.lazy(() => NestedEnumGameStateFilterSchema) ]).optional(),
+}).strict();
+
+export const GamepinRelationFilterSchema: z.ZodType<Prisma.GamepinRelationFilter> = z.object({
+  is: z.lazy(() => GamepinWhereInputSchema).optional().nullable(),
+  isNot: z.lazy(() => GamepinWhereInputSchema).optional().nullable()
+}).strict();
+
+export const GameCountOrderByAggregateInputSchema: z.ZodType<Prisma.GameCountOrderByAggregateInput> = z.object({
+  id: z.lazy(() => SortOrderSchema).optional(),
+  createdAt: z.lazy(() => SortOrderSchema).optional(),
+  updatedAt: z.lazy(() => SortOrderSchema).optional(),
+  state: z.lazy(() => SortOrderSchema).optional()
+}).strict();
+
+export const GameMaxOrderByAggregateInputSchema: z.ZodType<Prisma.GameMaxOrderByAggregateInput> = z.object({
+  id: z.lazy(() => SortOrderSchema).optional(),
+  createdAt: z.lazy(() => SortOrderSchema).optional(),
+  updatedAt: z.lazy(() => SortOrderSchema).optional(),
+  state: z.lazy(() => SortOrderSchema).optional()
+}).strict();
+
+export const GameMinOrderByAggregateInputSchema: z.ZodType<Prisma.GameMinOrderByAggregateInput> = z.object({
+  id: z.lazy(() => SortOrderSchema).optional(),
+  createdAt: z.lazy(() => SortOrderSchema).optional(),
+  updatedAt: z.lazy(() => SortOrderSchema).optional(),
+  state: z.lazy(() => SortOrderSchema).optional()
+}).strict();
+
+export const EnumGameStateWithAggregatesFilterSchema: z.ZodType<Prisma.EnumGameStateWithAggregatesFilter> = z.object({
+  equals: z.lazy(() => GameStateSchema).optional(),
+  in: z.lazy(() => GameStateSchema).array().optional(),
+  notIn: z.lazy(() => GameStateSchema).array().optional(),
+  not: z.union([ z.lazy(() => GameStateSchema),z.lazy(() => NestedEnumGameStateWithAggregatesFilterSchema) ]).optional(),
+  _count: z.lazy(() => NestedIntFilterSchema).optional(),
+  _min: z.lazy(() => NestedEnumGameStateFilterSchema).optional(),
+  _max: z.lazy(() => NestedEnumGameStateFilterSchema).optional()
+}).strict();
+
+export const GameRelationFilterSchema: z.ZodType<Prisma.GameRelationFilter> = z.object({
+  is: z.lazy(() => GameWhereInputSchema).optional(),
+  isNot: z.lazy(() => GameWhereInputSchema).optional()
+}).strict();
+
+export const GamepinCountOrderByAggregateInputSchema: z.ZodType<Prisma.GamepinCountOrderByAggregateInput> = z.object({
+  id: z.lazy(() => SortOrderSchema).optional(),
+  createdAt: z.lazy(() => SortOrderSchema).optional(),
+  pin: z.lazy(() => SortOrderSchema).optional(),
+  gameId: z.lazy(() => SortOrderSchema).optional()
+}).strict();
+
+export const GamepinMaxOrderByAggregateInputSchema: z.ZodType<Prisma.GamepinMaxOrderByAggregateInput> = z.object({
+  id: z.lazy(() => SortOrderSchema).optional(),
+  createdAt: z.lazy(() => SortOrderSchema).optional(),
+  pin: z.lazy(() => SortOrderSchema).optional(),
+  gameId: z.lazy(() => SortOrderSchema).optional()
+}).strict();
+
+export const GamepinMinOrderByAggregateInputSchema: z.ZodType<Prisma.GamepinMinOrderByAggregateInput> = z.object({
+  id: z.lazy(() => SortOrderSchema).optional(),
+  createdAt: z.lazy(() => SortOrderSchema).optional(),
+  pin: z.lazy(() => SortOrderSchema).optional(),
+  gameId: z.lazy(() => SortOrderSchema).optional()
+}).strict();
+
+export const BoolFilterSchema: z.ZodType<Prisma.BoolFilter> = z.object({
+  equals: z.boolean().optional(),
+  not: z.union([ z.boolean(),z.lazy(() => NestedBoolFilterSchema) ]).optional(),
+}).strict();
+
+export const MoveListRelationFilterSchema: z.ZodType<Prisma.MoveListRelationFilter> = z.object({
+  every: z.lazy(() => MoveWhereInputSchema).optional(),
+  some: z.lazy(() => MoveWhereInputSchema).optional(),
+  none: z.lazy(() => MoveWhereInputSchema).optional()
+}).strict();
+
+export const ChatListRelationFilterSchema: z.ZodType<Prisma.ChatListRelationFilter> = z.object({
+  every: z.lazy(() => ChatWhereInputSchema).optional(),
+  some: z.lazy(() => ChatWhereInputSchema).optional(),
+  none: z.lazy(() => ChatWhereInputSchema).optional()
+}).strict();
+
+export const MoveOrderByRelationAggregateInputSchema: z.ZodType<Prisma.MoveOrderByRelationAggregateInput> = z.object({
+  _count: z.lazy(() => SortOrderSchema).optional()
+}).strict();
+
+export const ChatOrderByRelationAggregateInputSchema: z.ZodType<Prisma.ChatOrderByRelationAggregateInput> = z.object({
+  _count: z.lazy(() => SortOrderSchema).optional()
+}).strict();
+
+export const User_GameGameIdUserIdCompoundUniqueInputSchema: z.ZodType<Prisma.User_GameGameIdUserIdCompoundUniqueInput> = z.object({
+  gameId: z.string(),
+  userId: z.string()
+}).strict();
+
+export const User_GameCountOrderByAggregateInputSchema: z.ZodType<Prisma.User_GameCountOrderByAggregateInput> = z.object({
+  id: z.lazy(() => SortOrderSchema).optional(),
+  createdAt: z.lazy(() => SortOrderSchema).optional(),
+  gameId: z.lazy(() => SortOrderSchema).optional(),
+  userId: z.lazy(() => SortOrderSchema).optional(),
+  isOwner: z.lazy(() => SortOrderSchema).optional()
+}).strict();
+
+export const User_GameMaxOrderByAggregateInputSchema: z.ZodType<Prisma.User_GameMaxOrderByAggregateInput> = z.object({
+  id: z.lazy(() => SortOrderSchema).optional(),
+  createdAt: z.lazy(() => SortOrderSchema).optional(),
+  gameId: z.lazy(() => SortOrderSchema).optional(),
+  userId: z.lazy(() => SortOrderSchema).optional(),
+  isOwner: z.lazy(() => SortOrderSchema).optional()
+}).strict();
+
+export const User_GameMinOrderByAggregateInputSchema: z.ZodType<Prisma.User_GameMinOrderByAggregateInput> = z.object({
+  id: z.lazy(() => SortOrderSchema).optional(),
+  createdAt: z.lazy(() => SortOrderSchema).optional(),
+  gameId: z.lazy(() => SortOrderSchema).optional(),
+  userId: z.lazy(() => SortOrderSchema).optional(),
+  isOwner: z.lazy(() => SortOrderSchema).optional()
+}).strict();
+
+export const BoolWithAggregatesFilterSchema: z.ZodType<Prisma.BoolWithAggregatesFilter> = z.object({
+  equals: z.boolean().optional(),
+  not: z.union([ z.boolean(),z.lazy(() => NestedBoolWithAggregatesFilterSchema) ]).optional(),
+  _count: z.lazy(() => NestedIntFilterSchema).optional(),
+  _min: z.lazy(() => NestedBoolFilterSchema).optional(),
+  _max: z.lazy(() => NestedBoolFilterSchema).optional()
+}).strict();
+
+export const IntFilterSchema: z.ZodType<Prisma.IntFilter> = 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(() => NestedIntFilterSchema) ]).optional(),
+}).strict();
+
+export const User_GameRelationFilterSchema: z.ZodType<Prisma.User_GameRelationFilter> = z.object({
+  is: z.lazy(() => User_GameWhereInputSchema).optional(),
+  isNot: z.lazy(() => User_GameWhereInputSchema).optional()
+}).strict();
+
+export const MoveCountOrderByAggregateInputSchema: z.ZodType<Prisma.MoveCountOrderByAggregateInput> = z.object({
+  id: z.lazy(() => SortOrderSchema).optional(),
+  createdAt: z.lazy(() => SortOrderSchema).optional(),
+  index: z.lazy(() => SortOrderSchema).optional(),
+  user_game_id: z.lazy(() => SortOrderSchema).optional()
+}).strict();
+
+export const MoveAvgOrderByAggregateInputSchema: z.ZodType<Prisma.MoveAvgOrderByAggregateInput> = z.object({
+  index: z.lazy(() => SortOrderSchema).optional()
+}).strict();
+
+export const MoveMaxOrderByAggregateInputSchema: z.ZodType<Prisma.MoveMaxOrderByAggregateInput> = z.object({
+  id: z.lazy(() => SortOrderSchema).optional(),
+  createdAt: z.lazy(() => SortOrderSchema).optional(),
+  index: z.lazy(() => SortOrderSchema).optional(),
+  user_game_id: z.lazy(() => SortOrderSchema).optional()
+}).strict();
+
+export const MoveMinOrderByAggregateInputSchema: z.ZodType<Prisma.MoveMinOrderByAggregateInput> = z.object({
+  id: z.lazy(() => SortOrderSchema).optional(),
+  createdAt: z.lazy(() => SortOrderSchema).optional(),
+  index: z.lazy(() => SortOrderSchema).optional(),
+  user_game_id: z.lazy(() => SortOrderSchema).optional()
+}).strict();
+
+export const MoveSumOrderByAggregateInputSchema: z.ZodType<Prisma.MoveSumOrderByAggregateInput> = z.object({
+  index: z.lazy(() => SortOrderSchema).optional()
+}).strict();
+
+export const IntWithAggregatesFilterSchema: z.ZodType<Prisma.IntWithAggregatesFilter> = 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(() => NestedIntWithAggregatesFilterSchema) ]).optional(),
+  _count: z.lazy(() => NestedIntFilterSchema).optional(),
+  _avg: z.lazy(() => NestedFloatFilterSchema).optional(),
+  _sum: z.lazy(() => NestedIntFilterSchema).optional(),
+  _min: z.lazy(() => NestedIntFilterSchema).optional(),
+  _max: z.lazy(() => NestedIntFilterSchema).optional()
+}).strict();
+
+export const ChatCountOrderByAggregateInputSchema: z.ZodType<Prisma.ChatCountOrderByAggregateInput> = z.object({
+  id: z.lazy(() => SortOrderSchema).optional(),
+  createdAt: z.lazy(() => SortOrderSchema).optional(),
+  message: z.lazy(() => SortOrderSchema).optional(),
+  event: z.lazy(() => SortOrderSchema).optional(),
+  user_game_id: z.lazy(() => SortOrderSchema).optional()
+}).strict();
+
+export const ChatMaxOrderByAggregateInputSchema: z.ZodType<Prisma.ChatMaxOrderByAggregateInput> = z.object({
+  id: z.lazy(() => SortOrderSchema).optional(),
+  createdAt: z.lazy(() => SortOrderSchema).optional(),
+  message: z.lazy(() => SortOrderSchema).optional(),
+  event: z.lazy(() => SortOrderSchema).optional(),
+  user_game_id: z.lazy(() => SortOrderSchema).optional()
+}).strict();
+
+export const ChatMinOrderByAggregateInputSchema: z.ZodType<Prisma.ChatMinOrderByAggregateInput> = z.object({
+  id: z.lazy(() => SortOrderSchema).optional(),
+  createdAt: z.lazy(() => SortOrderSchema).optional(),
+  message: z.lazy(() => SortOrderSchema).optional(),
+  event: z.lazy(() => SortOrderSchema).optional(),
+  user_game_id: z.lazy(() => SortOrderSchema).optional()
+}).strict();
+
+export const UserCreateNestedOneWithoutAccountsInputSchema: z.ZodType<Prisma.UserCreateNestedOneWithoutAccountsInput> = z.object({
+  create: z.union([ z.lazy(() => UserCreateWithoutAccountsInputSchema),z.lazy(() => UserUncheckedCreateWithoutAccountsInputSchema) ]).optional(),
+  connectOrCreate: z.lazy(() => UserCreateOrConnectWithoutAccountsInputSchema).optional(),
+  connect: z.lazy(() => UserWhereUniqueInputSchema).optional()
+}).strict();
+
+export const StringFieldUpdateOperationsInputSchema: z.ZodType<Prisma.StringFieldUpdateOperationsInput> = z.object({
+  set: z.string().optional()
+}).strict();
+
+export const NullableStringFieldUpdateOperationsInputSchema: z.ZodType<Prisma.NullableStringFieldUpdateOperationsInput> = z.object({
+  set: z.string().optional().nullable()
+}).strict();
+
+export const NullableIntFieldUpdateOperationsInputSchema: z.ZodType<Prisma.NullableIntFieldUpdateOperationsInput> = z.object({
+  set: z.number().optional().nullable(),
+  increment: z.number().optional(),
+  decrement: z.number().optional(),
+  multiply: z.number().optional(),
+  divide: z.number().optional()
+}).strict();
+
+export const UserUpdateOneRequiredWithoutAccountsNestedInputSchema: z.ZodType<Prisma.UserUpdateOneRequiredWithoutAccountsNestedInput> = z.object({
+  create: z.union([ z.lazy(() => UserCreateWithoutAccountsInputSchema),z.lazy(() => UserUncheckedCreateWithoutAccountsInputSchema) ]).optional(),
+  connectOrCreate: z.lazy(() => UserCreateOrConnectWithoutAccountsInputSchema).optional(),
+  upsert: z.lazy(() => UserUpsertWithoutAccountsInputSchema).optional(),
+  connect: z.lazy(() => UserWhereUniqueInputSchema).optional(),
+  update: z.union([ z.lazy(() => UserUpdateWithoutAccountsInputSchema),z.lazy(() => UserUncheckedUpdateWithoutAccountsInputSchema) ]).optional(),
+}).strict();
+
+export const UserCreateNestedOneWithoutSessionsInputSchema: z.ZodType<Prisma.UserCreateNestedOneWithoutSessionsInput> = z.object({
+  create: z.union([ z.lazy(() => UserCreateWithoutSessionsInputSchema),z.lazy(() => UserUncheckedCreateWithoutSessionsInputSchema) ]).optional(),
+  connectOrCreate: z.lazy(() => UserCreateOrConnectWithoutSessionsInputSchema).optional(),
+  connect: z.lazy(() => UserWhereUniqueInputSchema).optional()
+}).strict();
+
+export const DateTimeFieldUpdateOperationsInputSchema: z.ZodType<Prisma.DateTimeFieldUpdateOperationsInput> = z.object({
+  set: z.coerce.date().optional()
+}).strict();
+
+export const UserUpdateOneRequiredWithoutSessionsNestedInputSchema: z.ZodType<Prisma.UserUpdateOneRequiredWithoutSessionsNestedInput> = z.object({
+  create: z.union([ z.lazy(() => UserCreateWithoutSessionsInputSchema),z.lazy(() => UserUncheckedCreateWithoutSessionsInputSchema) ]).optional(),
+  connectOrCreate: z.lazy(() => UserCreateOrConnectWithoutSessionsInputSchema).optional(),
+  upsert: z.lazy(() => UserUpsertWithoutSessionsInputSchema).optional(),
+  connect: z.lazy(() => UserWhereUniqueInputSchema).optional(),
+  update: z.union([ z.lazy(() => UserUpdateWithoutSessionsInputSchema),z.lazy(() => UserUncheckedUpdateWithoutSessionsInputSchema) ]).optional(),
+}).strict();
+
+export const User_GameCreateNestedManyWithoutUserInputSchema: z.ZodType<Prisma.User_GameCreateNestedManyWithoutUserInput> = z.object({
+  create: z.union([ z.lazy(() => User_GameCreateWithoutUserInputSchema),z.lazy(() => User_GameCreateWithoutUserInputSchema).array(),z.lazy(() => User_GameUncheckedCreateWithoutUserInputSchema),z.lazy(() => User_GameUncheckedCreateWithoutUserInputSchema).array() ]).optional(),
+  connectOrCreate: z.union([ z.lazy(() => User_GameCreateOrConnectWithoutUserInputSchema),z.lazy(() => User_GameCreateOrConnectWithoutUserInputSchema).array() ]).optional(),
+  createMany: z.lazy(() => User_GameCreateManyUserInputEnvelopeSchema).optional(),
+  connect: z.union([ z.lazy(() => User_GameWhereUniqueInputSchema),z.lazy(() => User_GameWhereUniqueInputSchema).array() ]).optional(),
+}).strict();
+
+export const AccountCreateNestedManyWithoutUserInputSchema: z.ZodType<Prisma.AccountCreateNestedManyWithoutUserInput> = z.object({
+  create: z.union([ z.lazy(() => AccountCreateWithoutUserInputSchema),z.lazy(() => AccountCreateWithoutUserInputSchema).array(),z.lazy(() => AccountUncheckedCreateWithoutUserInputSchema),z.lazy(() => AccountUncheckedCreateWithoutUserInputSchema).array() ]).optional(),
+  connectOrCreate: z.union([ z.lazy(() => AccountCreateOrConnectWithoutUserInputSchema),z.lazy(() => AccountCreateOrConnectWithoutUserInputSchema).array() ]).optional(),
+  createMany: z.lazy(() => AccountCreateManyUserInputEnvelopeSchema).optional(),
+  connect: z.union([ z.lazy(() => AccountWhereUniqueInputSchema),z.lazy(() => AccountWhereUniqueInputSchema).array() ]).optional(),
+}).strict();
+
+export const SessionCreateNestedManyWithoutUserInputSchema: z.ZodType<Prisma.SessionCreateNestedManyWithoutUserInput> = z.object({
+  create: z.union([ z.lazy(() => SessionCreateWithoutUserInputSchema),z.lazy(() => SessionCreateWithoutUserInputSchema).array(),z.lazy(() => SessionUncheckedCreateWithoutUserInputSchema),z.lazy(() => SessionUncheckedCreateWithoutUserInputSchema).array() ]).optional(),
+  connectOrCreate: z.union([ z.lazy(() => SessionCreateOrConnectWithoutUserInputSchema),z.lazy(() => SessionCreateOrConnectWithoutUserInputSchema).array() ]).optional(),
+  createMany: z.lazy(() => SessionCreateManyUserInputEnvelopeSchema).optional(),
+  connect: z.union([ z.lazy(() => SessionWhereUniqueInputSchema),z.lazy(() => SessionWhereUniqueInputSchema).array() ]).optional(),
+}).strict();
+
+export const User_GameUncheckedCreateNestedManyWithoutUserInputSchema: z.ZodType<Prisma.User_GameUncheckedCreateNestedManyWithoutUserInput> = z.object({
+  create: z.union([ z.lazy(() => User_GameCreateWithoutUserInputSchema),z.lazy(() => User_GameCreateWithoutUserInputSchema).array(),z.lazy(() => User_GameUncheckedCreateWithoutUserInputSchema),z.lazy(() => User_GameUncheckedCreateWithoutUserInputSchema).array() ]).optional(),
+  connectOrCreate: z.union([ z.lazy(() => User_GameCreateOrConnectWithoutUserInputSchema),z.lazy(() => User_GameCreateOrConnectWithoutUserInputSchema).array() ]).optional(),
+  createMany: z.lazy(() => User_GameCreateManyUserInputEnvelopeSchema).optional(),
+  connect: z.union([ z.lazy(() => User_GameWhereUniqueInputSchema),z.lazy(() => User_GameWhereUniqueInputSchema).array() ]).optional(),
+}).strict();
+
+export const AccountUncheckedCreateNestedManyWithoutUserInputSchema: z.ZodType<Prisma.AccountUncheckedCreateNestedManyWithoutUserInput> = z.object({
+  create: z.union([ z.lazy(() => AccountCreateWithoutUserInputSchema),z.lazy(() => AccountCreateWithoutUserInputSchema).array(),z.lazy(() => AccountUncheckedCreateWithoutUserInputSchema),z.lazy(() => AccountUncheckedCreateWithoutUserInputSchema).array() ]).optional(),
+  connectOrCreate: z.union([ z.lazy(() => AccountCreateOrConnectWithoutUserInputSchema),z.lazy(() => AccountCreateOrConnectWithoutUserInputSchema).array() ]).optional(),
+  createMany: z.lazy(() => AccountCreateManyUserInputEnvelopeSchema).optional(),
+  connect: z.union([ z.lazy(() => AccountWhereUniqueInputSchema),z.lazy(() => AccountWhereUniqueInputSchema).array() ]).optional(),
+}).strict();
+
+export const SessionUncheckedCreateNestedManyWithoutUserInputSchema: z.ZodType<Prisma.SessionUncheckedCreateNestedManyWithoutUserInput> = z.object({
+  create: z.union([ z.lazy(() => SessionCreateWithoutUserInputSchema),z.lazy(() => SessionCreateWithoutUserInputSchema).array(),z.lazy(() => SessionUncheckedCreateWithoutUserInputSchema),z.lazy(() => SessionUncheckedCreateWithoutUserInputSchema).array() ]).optional(),
+  connectOrCreate: z.union([ z.lazy(() => SessionCreateOrConnectWithoutUserInputSchema),z.lazy(() => SessionCreateOrConnectWithoutUserInputSchema).array() ]).optional(),
+  createMany: z.lazy(() => SessionCreateManyUserInputEnvelopeSchema).optional(),
+  connect: z.union([ z.lazy(() => SessionWhereUniqueInputSchema),z.lazy(() => SessionWhereUniqueInputSchema).array() ]).optional(),
+}).strict();
+
+export const NullableDateTimeFieldUpdateOperationsInputSchema: z.ZodType<Prisma.NullableDateTimeFieldUpdateOperationsInput> = z.object({
+  set: z.coerce.date().optional().nullable()
+}).strict();
+
+export const User_GameUpdateManyWithoutUserNestedInputSchema: z.ZodType<Prisma.User_GameUpdateManyWithoutUserNestedInput> = z.object({
+  create: z.union([ z.lazy(() => User_GameCreateWithoutUserInputSchema),z.lazy(() => User_GameCreateWithoutUserInputSchema).array(),z.lazy(() => User_GameUncheckedCreateWithoutUserInputSchema),z.lazy(() => User_GameUncheckedCreateWithoutUserInputSchema).array() ]).optional(),
+  connectOrCreate: z.union([ z.lazy(() => User_GameCreateOrConnectWithoutUserInputSchema),z.lazy(() => User_GameCreateOrConnectWithoutUserInputSchema).array() ]).optional(),
+  upsert: z.union([ z.lazy(() => User_GameUpsertWithWhereUniqueWithoutUserInputSchema),z.lazy(() => User_GameUpsertWithWhereUniqueWithoutUserInputSchema).array() ]).optional(),
+  createMany: z.lazy(() => User_GameCreateManyUserInputEnvelopeSchema).optional(),
+  set: z.union([ z.lazy(() => User_GameWhereUniqueInputSchema),z.lazy(() => User_GameWhereUniqueInputSchema).array() ]).optional(),
+  disconnect: z.union([ z.lazy(() => User_GameWhereUniqueInputSchema),z.lazy(() => User_GameWhereUniqueInputSchema).array() ]).optional(),
+  delete: z.union([ z.lazy(() => User_GameWhereUniqueInputSchema),z.lazy(() => User_GameWhereUniqueInputSchema).array() ]).optional(),
+  connect: z.union([ z.lazy(() => User_GameWhereUniqueInputSchema),z.lazy(() => User_GameWhereUniqueInputSchema).array() ]).optional(),
+  update: z.union([ z.lazy(() => User_GameUpdateWithWhereUniqueWithoutUserInputSchema),z.lazy(() => User_GameUpdateWithWhereUniqueWithoutUserInputSchema).array() ]).optional(),
+  updateMany: z.union([ z.lazy(() => User_GameUpdateManyWithWhereWithoutUserInputSchema),z.lazy(() => User_GameUpdateManyWithWhereWithoutUserInputSchema).array() ]).optional(),
+  deleteMany: z.union([ z.lazy(() => User_GameScalarWhereInputSchema),z.lazy(() => User_GameScalarWhereInputSchema).array() ]).optional(),
+}).strict();
+
+export const AccountUpdateManyWithoutUserNestedInputSchema: z.ZodType<Prisma.AccountUpdateManyWithoutUserNestedInput> = z.object({
+  create: z.union([ z.lazy(() => AccountCreateWithoutUserInputSchema),z.lazy(() => AccountCreateWithoutUserInputSchema).array(),z.lazy(() => AccountUncheckedCreateWithoutUserInputSchema),z.lazy(() => AccountUncheckedCreateWithoutUserInputSchema).array() ]).optional(),
+  connectOrCreate: z.union([ z.lazy(() => AccountCreateOrConnectWithoutUserInputSchema),z.lazy(() => AccountCreateOrConnectWithoutUserInputSchema).array() ]).optional(),
+  upsert: z.union([ z.lazy(() => AccountUpsertWithWhereUniqueWithoutUserInputSchema),z.lazy(() => AccountUpsertWithWhereUniqueWithoutUserInputSchema).array() ]).optional(),
+  createMany: z.lazy(() => AccountCreateManyUserInputEnvelopeSchema).optional(),
+  set: z.union([ z.lazy(() => AccountWhereUniqueInputSchema),z.lazy(() => AccountWhereUniqueInputSchema).array() ]).optional(),
+  disconnect: z.union([ z.lazy(() => AccountWhereUniqueInputSchema),z.lazy(() => AccountWhereUniqueInputSchema).array() ]).optional(),
+  delete: z.union([ z.lazy(() => AccountWhereUniqueInputSchema),z.lazy(() => AccountWhereUniqueInputSchema).array() ]).optional(),
+  connect: z.union([ z.lazy(() => AccountWhereUniqueInputSchema),z.lazy(() => AccountWhereUniqueInputSchema).array() ]).optional(),
+  update: z.union([ z.lazy(() => AccountUpdateWithWhereUniqueWithoutUserInputSchema),z.lazy(() => AccountUpdateWithWhereUniqueWithoutUserInputSchema).array() ]).optional(),
+  updateMany: z.union([ z.lazy(() => AccountUpdateManyWithWhereWithoutUserInputSchema),z.lazy(() => AccountUpdateManyWithWhereWithoutUserInputSchema).array() ]).optional(),
+  deleteMany: z.union([ z.lazy(() => AccountScalarWhereInputSchema),z.lazy(() => AccountScalarWhereInputSchema).array() ]).optional(),
+}).strict();
+
+export const SessionUpdateManyWithoutUserNestedInputSchema: z.ZodType<Prisma.SessionUpdateManyWithoutUserNestedInput> = z.object({
+  create: z.union([ z.lazy(() => SessionCreateWithoutUserInputSchema),z.lazy(() => SessionCreateWithoutUserInputSchema).array(),z.lazy(() => SessionUncheckedCreateWithoutUserInputSchema),z.lazy(() => SessionUncheckedCreateWithoutUserInputSchema).array() ]).optional(),
+  connectOrCreate: z.union([ z.lazy(() => SessionCreateOrConnectWithoutUserInputSchema),z.lazy(() => SessionCreateOrConnectWithoutUserInputSchema).array() ]).optional(),
+  upsert: z.union([ z.lazy(() => SessionUpsertWithWhereUniqueWithoutUserInputSchema),z.lazy(() => SessionUpsertWithWhereUniqueWithoutUserInputSchema).array() ]).optional(),
+  createMany: z.lazy(() => SessionCreateManyUserInputEnvelopeSchema).optional(),
+  set: z.union([ z.lazy(() => SessionWhereUniqueInputSchema),z.lazy(() => SessionWhereUniqueInputSchema).array() ]).optional(),
+  disconnect: z.union([ z.lazy(() => SessionWhereUniqueInputSchema),z.lazy(() => SessionWhereUniqueInputSchema).array() ]).optional(),
+  delete: z.union([ z.lazy(() => SessionWhereUniqueInputSchema),z.lazy(() => SessionWhereUniqueInputSchema).array() ]).optional(),
+  connect: z.union([ z.lazy(() => SessionWhereUniqueInputSchema),z.lazy(() => SessionWhereUniqueInputSchema).array() ]).optional(),
+  update: z.union([ z.lazy(() => SessionUpdateWithWhereUniqueWithoutUserInputSchema),z.lazy(() => SessionUpdateWithWhereUniqueWithoutUserInputSchema).array() ]).optional(),
+  updateMany: z.union([ z.lazy(() => SessionUpdateManyWithWhereWithoutUserInputSchema),z.lazy(() => SessionUpdateManyWithWhereWithoutUserInputSchema).array() ]).optional(),
+  deleteMany: z.union([ z.lazy(() => SessionScalarWhereInputSchema),z.lazy(() => SessionScalarWhereInputSchema).array() ]).optional(),
+}).strict();
+
+export const User_GameUncheckedUpdateManyWithoutUserNestedInputSchema: z.ZodType<Prisma.User_GameUncheckedUpdateManyWithoutUserNestedInput> = z.object({
+  create: z.union([ z.lazy(() => User_GameCreateWithoutUserInputSchema),z.lazy(() => User_GameCreateWithoutUserInputSchema).array(),z.lazy(() => User_GameUncheckedCreateWithoutUserInputSchema),z.lazy(() => User_GameUncheckedCreateWithoutUserInputSchema).array() ]).optional(),
+  connectOrCreate: z.union([ z.lazy(() => User_GameCreateOrConnectWithoutUserInputSchema),z.lazy(() => User_GameCreateOrConnectWithoutUserInputSchema).array() ]).optional(),
+  upsert: z.union([ z.lazy(() => User_GameUpsertWithWhereUniqueWithoutUserInputSchema),z.lazy(() => User_GameUpsertWithWhereUniqueWithoutUserInputSchema).array() ]).optional(),
+  createMany: z.lazy(() => User_GameCreateManyUserInputEnvelopeSchema).optional(),
+  set: z.union([ z.lazy(() => User_GameWhereUniqueInputSchema),z.lazy(() => User_GameWhereUniqueInputSchema).array() ]).optional(),
+  disconnect: z.union([ z.lazy(() => User_GameWhereUniqueInputSchema),z.lazy(() => User_GameWhereUniqueInputSchema).array() ]).optional(),
+  delete: z.union([ z.lazy(() => User_GameWhereUniqueInputSchema),z.lazy(() => User_GameWhereUniqueInputSchema).array() ]).optional(),
+  connect: z.union([ z.lazy(() => User_GameWhereUniqueInputSchema),z.lazy(() => User_GameWhereUniqueInputSchema).array() ]).optional(),
+  update: z.union([ z.lazy(() => User_GameUpdateWithWhereUniqueWithoutUserInputSchema),z.lazy(() => User_GameUpdateWithWhereUniqueWithoutUserInputSchema).array() ]).optional(),
+  updateMany: z.union([ z.lazy(() => User_GameUpdateManyWithWhereWithoutUserInputSchema),z.lazy(() => User_GameUpdateManyWithWhereWithoutUserInputSchema).array() ]).optional(),
+  deleteMany: z.union([ z.lazy(() => User_GameScalarWhereInputSchema),z.lazy(() => User_GameScalarWhereInputSchema).array() ]).optional(),
+}).strict();
+
+export const AccountUncheckedUpdateManyWithoutUserNestedInputSchema: z.ZodType<Prisma.AccountUncheckedUpdateManyWithoutUserNestedInput> = z.object({
+  create: z.union([ z.lazy(() => AccountCreateWithoutUserInputSchema),z.lazy(() => AccountCreateWithoutUserInputSchema).array(),z.lazy(() => AccountUncheckedCreateWithoutUserInputSchema),z.lazy(() => AccountUncheckedCreateWithoutUserInputSchema).array() ]).optional(),
+  connectOrCreate: z.union([ z.lazy(() => AccountCreateOrConnectWithoutUserInputSchema),z.lazy(() => AccountCreateOrConnectWithoutUserInputSchema).array() ]).optional(),
+  upsert: z.union([ z.lazy(() => AccountUpsertWithWhereUniqueWithoutUserInputSchema),z.lazy(() => AccountUpsertWithWhereUniqueWithoutUserInputSchema).array() ]).optional(),
+  createMany: z.lazy(() => AccountCreateManyUserInputEnvelopeSchema).optional(),
+  set: z.union([ z.lazy(() => AccountWhereUniqueInputSchema),z.lazy(() => AccountWhereUniqueInputSchema).array() ]).optional(),
+  disconnect: z.union([ z.lazy(() => AccountWhereUniqueInputSchema),z.lazy(() => AccountWhereUniqueInputSchema).array() ]).optional(),
+  delete: z.union([ z.lazy(() => AccountWhereUniqueInputSchema),z.lazy(() => AccountWhereUniqueInputSchema).array() ]).optional(),
+  connect: z.union([ z.lazy(() => AccountWhereUniqueInputSchema),z.lazy(() => AccountWhereUniqueInputSchema).array() ]).optional(),
+  update: z.union([ z.lazy(() => AccountUpdateWithWhereUniqueWithoutUserInputSchema),z.lazy(() => AccountUpdateWithWhereUniqueWithoutUserInputSchema).array() ]).optional(),
+  updateMany: z.union([ z.lazy(() => AccountUpdateManyWithWhereWithoutUserInputSchema),z.lazy(() => AccountUpdateManyWithWhereWithoutUserInputSchema).array() ]).optional(),
+  deleteMany: z.union([ z.lazy(() => AccountScalarWhereInputSchema),z.lazy(() => AccountScalarWhereInputSchema).array() ]).optional(),
+}).strict();
+
+export const SessionUncheckedUpdateManyWithoutUserNestedInputSchema: z.ZodType<Prisma.SessionUncheckedUpdateManyWithoutUserNestedInput> = z.object({
+  create: z.union([ z.lazy(() => SessionCreateWithoutUserInputSchema),z.lazy(() => SessionCreateWithoutUserInputSchema).array(),z.lazy(() => SessionUncheckedCreateWithoutUserInputSchema),z.lazy(() => SessionUncheckedCreateWithoutUserInputSchema).array() ]).optional(),
+  connectOrCreate: z.union([ z.lazy(() => SessionCreateOrConnectWithoutUserInputSchema),z.lazy(() => SessionCreateOrConnectWithoutUserInputSchema).array() ]).optional(),
+  upsert: z.union([ z.lazy(() => SessionUpsertWithWhereUniqueWithoutUserInputSchema),z.lazy(() => SessionUpsertWithWhereUniqueWithoutUserInputSchema).array() ]).optional(),
+  createMany: z.lazy(() => SessionCreateManyUserInputEnvelopeSchema).optional(),
+  set: z.union([ z.lazy(() => SessionWhereUniqueInputSchema),z.lazy(() => SessionWhereUniqueInputSchema).array() ]).optional(),
+  disconnect: z.union([ z.lazy(() => SessionWhereUniqueInputSchema),z.lazy(() => SessionWhereUniqueInputSchema).array() ]).optional(),
+  delete: z.union([ z.lazy(() => SessionWhereUniqueInputSchema),z.lazy(() => SessionWhereUniqueInputSchema).array() ]).optional(),
+  connect: z.union([ z.lazy(() => SessionWhereUniqueInputSchema),z.lazy(() => SessionWhereUniqueInputSchema).array() ]).optional(),
+  update: z.union([ z.lazy(() => SessionUpdateWithWhereUniqueWithoutUserInputSchema),z.lazy(() => SessionUpdateWithWhereUniqueWithoutUserInputSchema).array() ]).optional(),
+  updateMany: z.union([ z.lazy(() => SessionUpdateManyWithWhereWithoutUserInputSchema),z.lazy(() => SessionUpdateManyWithWhereWithoutUserInputSchema).array() ]).optional(),
+  deleteMany: z.union([ z.lazy(() => SessionScalarWhereInputSchema),z.lazy(() => SessionScalarWhereInputSchema).array() ]).optional(),
+}).strict();
+
+export const GamepinCreateNestedOneWithoutGameInputSchema: z.ZodType<Prisma.GamepinCreateNestedOneWithoutGameInput> = z.object({
+  create: z.union([ z.lazy(() => GamepinCreateWithoutGameInputSchema),z.lazy(() => GamepinUncheckedCreateWithoutGameInputSchema) ]).optional(),
+  connectOrCreate: z.lazy(() => GamepinCreateOrConnectWithoutGameInputSchema).optional(),
+  connect: z.lazy(() => GamepinWhereUniqueInputSchema).optional()
+}).strict();
+
+export const User_GameCreateNestedManyWithoutGameInputSchema: z.ZodType<Prisma.User_GameCreateNestedManyWithoutGameInput> = z.object({
+  create: z.union([ z.lazy(() => User_GameCreateWithoutGameInputSchema),z.lazy(() => User_GameCreateWithoutGameInputSchema).array(),z.lazy(() => User_GameUncheckedCreateWithoutGameInputSchema),z.lazy(() => User_GameUncheckedCreateWithoutGameInputSchema).array() ]).optional(),
+  connectOrCreate: z.union([ z.lazy(() => User_GameCreateOrConnectWithoutGameInputSchema),z.lazy(() => User_GameCreateOrConnectWithoutGameInputSchema).array() ]).optional(),
+  createMany: z.lazy(() => User_GameCreateManyGameInputEnvelopeSchema).optional(),
+  connect: z.union([ z.lazy(() => User_GameWhereUniqueInputSchema),z.lazy(() => User_GameWhereUniqueInputSchema).array() ]).optional(),
+}).strict();
+
+export const GamepinUncheckedCreateNestedOneWithoutGameInputSchema: z.ZodType<Prisma.GamepinUncheckedCreateNestedOneWithoutGameInput> = z.object({
+  create: z.union([ z.lazy(() => GamepinCreateWithoutGameInputSchema),z.lazy(() => GamepinUncheckedCreateWithoutGameInputSchema) ]).optional(),
+  connectOrCreate: z.lazy(() => GamepinCreateOrConnectWithoutGameInputSchema).optional(),
+  connect: z.lazy(() => GamepinWhereUniqueInputSchema).optional()
+}).strict();
+
+export const User_GameUncheckedCreateNestedManyWithoutGameInputSchema: z.ZodType<Prisma.User_GameUncheckedCreateNestedManyWithoutGameInput> = z.object({
+  create: z.union([ z.lazy(() => User_GameCreateWithoutGameInputSchema),z.lazy(() => User_GameCreateWithoutGameInputSchema).array(),z.lazy(() => User_GameUncheckedCreateWithoutGameInputSchema),z.lazy(() => User_GameUncheckedCreateWithoutGameInputSchema).array() ]).optional(),
+  connectOrCreate: z.union([ z.lazy(() => User_GameCreateOrConnectWithoutGameInputSchema),z.lazy(() => User_GameCreateOrConnectWithoutGameInputSchema).array() ]).optional(),
+  createMany: z.lazy(() => User_GameCreateManyGameInputEnvelopeSchema).optional(),
+  connect: z.union([ z.lazy(() => User_GameWhereUniqueInputSchema),z.lazy(() => User_GameWhereUniqueInputSchema).array() ]).optional(),
+}).strict();
+
+export const EnumGameStateFieldUpdateOperationsInputSchema: z.ZodType<Prisma.EnumGameStateFieldUpdateOperationsInput> = z.object({
+  set: z.lazy(() => GameStateSchema).optional()
+}).strict();
+
+export const GamepinUpdateOneWithoutGameNestedInputSchema: z.ZodType<Prisma.GamepinUpdateOneWithoutGameNestedInput> = z.object({
+  create: z.union([ z.lazy(() => GamepinCreateWithoutGameInputSchema),z.lazy(() => GamepinUncheckedCreateWithoutGameInputSchema) ]).optional(),
+  connectOrCreate: z.lazy(() => GamepinCreateOrConnectWithoutGameInputSchema).optional(),
+  upsert: z.lazy(() => GamepinUpsertWithoutGameInputSchema).optional(),
+  disconnect: z.boolean().optional(),
+  delete: z.boolean().optional(),
+  connect: z.lazy(() => GamepinWhereUniqueInputSchema).optional(),
+  update: z.union([ z.lazy(() => GamepinUpdateWithoutGameInputSchema),z.lazy(() => GamepinUncheckedUpdateWithoutGameInputSchema) ]).optional(),
+}).strict();
+
+export const User_GameUpdateManyWithoutGameNestedInputSchema: z.ZodType<Prisma.User_GameUpdateManyWithoutGameNestedInput> = z.object({
+  create: z.union([ z.lazy(() => User_GameCreateWithoutGameInputSchema),z.lazy(() => User_GameCreateWithoutGameInputSchema).array(),z.lazy(() => User_GameUncheckedCreateWithoutGameInputSchema),z.lazy(() => User_GameUncheckedCreateWithoutGameInputSchema).array() ]).optional(),
+  connectOrCreate: z.union([ z.lazy(() => User_GameCreateOrConnectWithoutGameInputSchema),z.lazy(() => User_GameCreateOrConnectWithoutGameInputSchema).array() ]).optional(),
+  upsert: z.union([ z.lazy(() => User_GameUpsertWithWhereUniqueWithoutGameInputSchema),z.lazy(() => User_GameUpsertWithWhereUniqueWithoutGameInputSchema).array() ]).optional(),
+  createMany: z.lazy(() => User_GameCreateManyGameInputEnvelopeSchema).optional(),
+  set: z.union([ z.lazy(() => User_GameWhereUniqueInputSchema),z.lazy(() => User_GameWhereUniqueInputSchema).array() ]).optional(),
+  disconnect: z.union([ z.lazy(() => User_GameWhereUniqueInputSchema),z.lazy(() => User_GameWhereUniqueInputSchema).array() ]).optional(),
+  delete: z.union([ z.lazy(() => User_GameWhereUniqueInputSchema),z.lazy(() => User_GameWhereUniqueInputSchema).array() ]).optional(),
+  connect: z.union([ z.lazy(() => User_GameWhereUniqueInputSchema),z.lazy(() => User_GameWhereUniqueInputSchema).array() ]).optional(),
+  update: z.union([ z.lazy(() => User_GameUpdateWithWhereUniqueWithoutGameInputSchema),z.lazy(() => User_GameUpdateWithWhereUniqueWithoutGameInputSchema).array() ]).optional(),
+  updateMany: z.union([ z.lazy(() => User_GameUpdateManyWithWhereWithoutGameInputSchema),z.lazy(() => User_GameUpdateManyWithWhereWithoutGameInputSchema).array() ]).optional(),
+  deleteMany: z.union([ z.lazy(() => User_GameScalarWhereInputSchema),z.lazy(() => User_GameScalarWhereInputSchema).array() ]).optional(),
+}).strict();
+
+export const GamepinUncheckedUpdateOneWithoutGameNestedInputSchema: z.ZodType<Prisma.GamepinUncheckedUpdateOneWithoutGameNestedInput> = z.object({
+  create: z.union([ z.lazy(() => GamepinCreateWithoutGameInputSchema),z.lazy(() => GamepinUncheckedCreateWithoutGameInputSchema) ]).optional(),
+  connectOrCreate: z.lazy(() => GamepinCreateOrConnectWithoutGameInputSchema).optional(),
+  upsert: z.lazy(() => GamepinUpsertWithoutGameInputSchema).optional(),
+  disconnect: z.boolean().optional(),
+  delete: z.boolean().optional(),
+  connect: z.lazy(() => GamepinWhereUniqueInputSchema).optional(),
+  update: z.union([ z.lazy(() => GamepinUpdateWithoutGameInputSchema),z.lazy(() => GamepinUncheckedUpdateWithoutGameInputSchema) ]).optional(),
+}).strict();
+
+export const User_GameUncheckedUpdateManyWithoutGameNestedInputSchema: z.ZodType<Prisma.User_GameUncheckedUpdateManyWithoutGameNestedInput> = z.object({
+  create: z.union([ z.lazy(() => User_GameCreateWithoutGameInputSchema),z.lazy(() => User_GameCreateWithoutGameInputSchema).array(),z.lazy(() => User_GameUncheckedCreateWithoutGameInputSchema),z.lazy(() => User_GameUncheckedCreateWithoutGameInputSchema).array() ]).optional(),
+  connectOrCreate: z.union([ z.lazy(() => User_GameCreateOrConnectWithoutGameInputSchema),z.lazy(() => User_GameCreateOrConnectWithoutGameInputSchema).array() ]).optional(),
+  upsert: z.union([ z.lazy(() => User_GameUpsertWithWhereUniqueWithoutGameInputSchema),z.lazy(() => User_GameUpsertWithWhereUniqueWithoutGameInputSchema).array() ]).optional(),
+  createMany: z.lazy(() => User_GameCreateManyGameInputEnvelopeSchema).optional(),
+  set: z.union([ z.lazy(() => User_GameWhereUniqueInputSchema),z.lazy(() => User_GameWhereUniqueInputSchema).array() ]).optional(),
+  disconnect: z.union([ z.lazy(() => User_GameWhereUniqueInputSchema),z.lazy(() => User_GameWhereUniqueInputSchema).array() ]).optional(),
+  delete: z.union([ z.lazy(() => User_GameWhereUniqueInputSchema),z.lazy(() => User_GameWhereUniqueInputSchema).array() ]).optional(),
+  connect: z.union([ z.lazy(() => User_GameWhereUniqueInputSchema),z.lazy(() => User_GameWhereUniqueInputSchema).array() ]).optional(),
+  update: z.union([ z.lazy(() => User_GameUpdateWithWhereUniqueWithoutGameInputSchema),z.lazy(() => User_GameUpdateWithWhereUniqueWithoutGameInputSchema).array() ]).optional(),
+  updateMany: z.union([ z.lazy(() => User_GameUpdateManyWithWhereWithoutGameInputSchema),z.lazy(() => User_GameUpdateManyWithWhereWithoutGameInputSchema).array() ]).optional(),
+  deleteMany: z.union([ z.lazy(() => User_GameScalarWhereInputSchema),z.lazy(() => User_GameScalarWhereInputSchema).array() ]).optional(),
+}).strict();
+
+export const GameCreateNestedOneWithoutGamePinInputSchema: z.ZodType<Prisma.GameCreateNestedOneWithoutGamePinInput> = z.object({
+  create: z.union([ z.lazy(() => GameCreateWithoutGamePinInputSchema),z.lazy(() => GameUncheckedCreateWithoutGamePinInputSchema) ]).optional(),
+  connectOrCreate: z.lazy(() => GameCreateOrConnectWithoutGamePinInputSchema).optional(),
+  connect: z.lazy(() => GameWhereUniqueInputSchema).optional()
+}).strict();
+
+export const GameUpdateOneRequiredWithoutGamePinNestedInputSchema: z.ZodType<Prisma.GameUpdateOneRequiredWithoutGamePinNestedInput> = z.object({
+  create: z.union([ z.lazy(() => GameCreateWithoutGamePinInputSchema),z.lazy(() => GameUncheckedCreateWithoutGamePinInputSchema) ]).optional(),
+  connectOrCreate: z.lazy(() => GameCreateOrConnectWithoutGamePinInputSchema).optional(),
+  upsert: z.lazy(() => GameUpsertWithoutGamePinInputSchema).optional(),
+  connect: z.lazy(() => GameWhereUniqueInputSchema).optional(),
+  update: z.union([ z.lazy(() => GameUpdateWithoutGamePinInputSchema),z.lazy(() => GameUncheckedUpdateWithoutGamePinInputSchema) ]).optional(),
+}).strict();
+
+export const MoveCreateNestedManyWithoutUser_gameInputSchema: z.ZodType<Prisma.MoveCreateNestedManyWithoutUser_gameInput> = z.object({
+  create: z.union([ z.lazy(() => MoveCreateWithoutUser_gameInputSchema),z.lazy(() => MoveCreateWithoutUser_gameInputSchema).array(),z.lazy(() => MoveUncheckedCreateWithoutUser_gameInputSchema),z.lazy(() => MoveUncheckedCreateWithoutUser_gameInputSchema).array() ]).optional(),
+  connectOrCreate: z.union([ z.lazy(() => MoveCreateOrConnectWithoutUser_gameInputSchema),z.lazy(() => MoveCreateOrConnectWithoutUser_gameInputSchema).array() ]).optional(),
+  createMany: z.lazy(() => MoveCreateManyUser_gameInputEnvelopeSchema).optional(),
+  connect: z.union([ z.lazy(() => MoveWhereUniqueInputSchema),z.lazy(() => MoveWhereUniqueInputSchema).array() ]).optional(),
+}).strict();
+
+export const ChatCreateNestedManyWithoutUser_gameInputSchema: z.ZodType<Prisma.ChatCreateNestedManyWithoutUser_gameInput> = z.object({
+  create: z.union([ z.lazy(() => ChatCreateWithoutUser_gameInputSchema),z.lazy(() => ChatCreateWithoutUser_gameInputSchema).array(),z.lazy(() => ChatUncheckedCreateWithoutUser_gameInputSchema),z.lazy(() => ChatUncheckedCreateWithoutUser_gameInputSchema).array() ]).optional(),
+  connectOrCreate: z.union([ z.lazy(() => ChatCreateOrConnectWithoutUser_gameInputSchema),z.lazy(() => ChatCreateOrConnectWithoutUser_gameInputSchema).array() ]).optional(),
+  createMany: z.lazy(() => ChatCreateManyUser_gameInputEnvelopeSchema).optional(),
+  connect: z.union([ z.lazy(() => ChatWhereUniqueInputSchema),z.lazy(() => ChatWhereUniqueInputSchema).array() ]).optional(),
+}).strict();
+
+export const GameCreateNestedOneWithoutUsersInputSchema: z.ZodType<Prisma.GameCreateNestedOneWithoutUsersInput> = z.object({
+  create: z.union([ z.lazy(() => GameCreateWithoutUsersInputSchema),z.lazy(() => GameUncheckedCreateWithoutUsersInputSchema) ]).optional(),
+  connectOrCreate: z.lazy(() => GameCreateOrConnectWithoutUsersInputSchema).optional(),
+  connect: z.lazy(() => GameWhereUniqueInputSchema).optional()
+}).strict();
+
+export const UserCreateNestedOneWithoutGamesInputSchema: z.ZodType<Prisma.UserCreateNestedOneWithoutGamesInput> = z.object({
+  create: z.union([ z.lazy(() => UserCreateWithoutGamesInputSchema),z.lazy(() => UserUncheckedCreateWithoutGamesInputSchema) ]).optional(),
+  connectOrCreate: z.lazy(() => UserCreateOrConnectWithoutGamesInputSchema).optional(),
+  connect: z.lazy(() => UserWhereUniqueInputSchema).optional()
+}).strict();
+
+export const MoveUncheckedCreateNestedManyWithoutUser_gameInputSchema: z.ZodType<Prisma.MoveUncheckedCreateNestedManyWithoutUser_gameInput> = z.object({
+  create: z.union([ z.lazy(() => MoveCreateWithoutUser_gameInputSchema),z.lazy(() => MoveCreateWithoutUser_gameInputSchema).array(),z.lazy(() => MoveUncheckedCreateWithoutUser_gameInputSchema),z.lazy(() => MoveUncheckedCreateWithoutUser_gameInputSchema).array() ]).optional(),
+  connectOrCreate: z.union([ z.lazy(() => MoveCreateOrConnectWithoutUser_gameInputSchema),z.lazy(() => MoveCreateOrConnectWithoutUser_gameInputSchema).array() ]).optional(),
+  createMany: z.lazy(() => MoveCreateManyUser_gameInputEnvelopeSchema).optional(),
+  connect: z.union([ z.lazy(() => MoveWhereUniqueInputSchema),z.lazy(() => MoveWhereUniqueInputSchema).array() ]).optional(),
+}).strict();
+
+export const ChatUncheckedCreateNestedManyWithoutUser_gameInputSchema: z.ZodType<Prisma.ChatUncheckedCreateNestedManyWithoutUser_gameInput> = z.object({
+  create: z.union([ z.lazy(() => ChatCreateWithoutUser_gameInputSchema),z.lazy(() => ChatCreateWithoutUser_gameInputSchema).array(),z.lazy(() => ChatUncheckedCreateWithoutUser_gameInputSchema),z.lazy(() => ChatUncheckedCreateWithoutUser_gameInputSchema).array() ]).optional(),
+  connectOrCreate: z.union([ z.lazy(() => ChatCreateOrConnectWithoutUser_gameInputSchema),z.lazy(() => ChatCreateOrConnectWithoutUser_gameInputSchema).array() ]).optional(),
+  createMany: z.lazy(() => ChatCreateManyUser_gameInputEnvelopeSchema).optional(),
+  connect: z.union([ z.lazy(() => ChatWhereUniqueInputSchema),z.lazy(() => ChatWhereUniqueInputSchema).array() ]).optional(),
+}).strict();
+
+export const BoolFieldUpdateOperationsInputSchema: z.ZodType<Prisma.BoolFieldUpdateOperationsInput> = z.object({
+  set: z.boolean().optional()
+}).strict();
+
+export const MoveUpdateManyWithoutUser_gameNestedInputSchema: z.ZodType<Prisma.MoveUpdateManyWithoutUser_gameNestedInput> = z.object({
+  create: z.union([ z.lazy(() => MoveCreateWithoutUser_gameInputSchema),z.lazy(() => MoveCreateWithoutUser_gameInputSchema).array(),z.lazy(() => MoveUncheckedCreateWithoutUser_gameInputSchema),z.lazy(() => MoveUncheckedCreateWithoutUser_gameInputSchema).array() ]).optional(),
+  connectOrCreate: z.union([ z.lazy(() => MoveCreateOrConnectWithoutUser_gameInputSchema),z.lazy(() => MoveCreateOrConnectWithoutUser_gameInputSchema).array() ]).optional(),
+  upsert: z.union([ z.lazy(() => MoveUpsertWithWhereUniqueWithoutUser_gameInputSchema),z.lazy(() => MoveUpsertWithWhereUniqueWithoutUser_gameInputSchema).array() ]).optional(),
+  createMany: z.lazy(() => MoveCreateManyUser_gameInputEnvelopeSchema).optional(),
+  set: z.union([ z.lazy(() => MoveWhereUniqueInputSchema),z.lazy(() => MoveWhereUniqueInputSchema).array() ]).optional(),
+  disconnect: z.union([ z.lazy(() => MoveWhereUniqueInputSchema),z.lazy(() => MoveWhereUniqueInputSchema).array() ]).optional(),
+  delete: z.union([ z.lazy(() => MoveWhereUniqueInputSchema),z.lazy(() => MoveWhereUniqueInputSchema).array() ]).optional(),
+  connect: z.union([ z.lazy(() => MoveWhereUniqueInputSchema),z.lazy(() => MoveWhereUniqueInputSchema).array() ]).optional(),
+  update: z.union([ z.lazy(() => MoveUpdateWithWhereUniqueWithoutUser_gameInputSchema),z.lazy(() => MoveUpdateWithWhereUniqueWithoutUser_gameInputSchema).array() ]).optional(),
+  updateMany: z.union([ z.lazy(() => MoveUpdateManyWithWhereWithoutUser_gameInputSchema),z.lazy(() => MoveUpdateManyWithWhereWithoutUser_gameInputSchema).array() ]).optional(),
+  deleteMany: z.union([ z.lazy(() => MoveScalarWhereInputSchema),z.lazy(() => MoveScalarWhereInputSchema).array() ]).optional(),
+}).strict();
+
+export const ChatUpdateManyWithoutUser_gameNestedInputSchema: z.ZodType<Prisma.ChatUpdateManyWithoutUser_gameNestedInput> = z.object({
+  create: z.union([ z.lazy(() => ChatCreateWithoutUser_gameInputSchema),z.lazy(() => ChatCreateWithoutUser_gameInputSchema).array(),z.lazy(() => ChatUncheckedCreateWithoutUser_gameInputSchema),z.lazy(() => ChatUncheckedCreateWithoutUser_gameInputSchema).array() ]).optional(),
+  connectOrCreate: z.union([ z.lazy(() => ChatCreateOrConnectWithoutUser_gameInputSchema),z.lazy(() => ChatCreateOrConnectWithoutUser_gameInputSchema).array() ]).optional(),
+  upsert: z.union([ z.lazy(() => ChatUpsertWithWhereUniqueWithoutUser_gameInputSchema),z.lazy(() => ChatUpsertWithWhereUniqueWithoutUser_gameInputSchema).array() ]).optional(),
+  createMany: z.lazy(() => ChatCreateManyUser_gameInputEnvelopeSchema).optional(),
+  set: z.union([ z.lazy(() => ChatWhereUniqueInputSchema),z.lazy(() => ChatWhereUniqueInputSchema).array() ]).optional(),
+  disconnect: z.union([ z.lazy(() => ChatWhereUniqueInputSchema),z.lazy(() => ChatWhereUniqueInputSchema).array() ]).optional(),
+  delete: z.union([ z.lazy(() => ChatWhereUniqueInputSchema),z.lazy(() => ChatWhereUniqueInputSchema).array() ]).optional(),
+  connect: z.union([ z.lazy(() => ChatWhereUniqueInputSchema),z.lazy(() => ChatWhereUniqueInputSchema).array() ]).optional(),
+  update: z.union([ z.lazy(() => ChatUpdateWithWhereUniqueWithoutUser_gameInputSchema),z.lazy(() => ChatUpdateWithWhereUniqueWithoutUser_gameInputSchema).array() ]).optional(),
+  updateMany: z.union([ z.lazy(() => ChatUpdateManyWithWhereWithoutUser_gameInputSchema),z.lazy(() => ChatUpdateManyWithWhereWithoutUser_gameInputSchema).array() ]).optional(),
+  deleteMany: z.union([ z.lazy(() => ChatScalarWhereInputSchema),z.lazy(() => ChatScalarWhereInputSchema).array() ]).optional(),
+}).strict();
+
+export const GameUpdateOneRequiredWithoutUsersNestedInputSchema: z.ZodType<Prisma.GameUpdateOneRequiredWithoutUsersNestedInput> = z.object({
+  create: z.union([ z.lazy(() => GameCreateWithoutUsersInputSchema),z.lazy(() => GameUncheckedCreateWithoutUsersInputSchema) ]).optional(),
+  connectOrCreate: z.lazy(() => GameCreateOrConnectWithoutUsersInputSchema).optional(),
+  upsert: z.lazy(() => GameUpsertWithoutUsersInputSchema).optional(),
+  connect: z.lazy(() => GameWhereUniqueInputSchema).optional(),
+  update: z.union([ z.lazy(() => GameUpdateWithoutUsersInputSchema),z.lazy(() => GameUncheckedUpdateWithoutUsersInputSchema) ]).optional(),
+}).strict();
+
+export const UserUpdateOneRequiredWithoutGamesNestedInputSchema: z.ZodType<Prisma.UserUpdateOneRequiredWithoutGamesNestedInput> = z.object({
+  create: z.union([ z.lazy(() => UserCreateWithoutGamesInputSchema),z.lazy(() => UserUncheckedCreateWithoutGamesInputSchema) ]).optional(),
+  connectOrCreate: z.lazy(() => UserCreateOrConnectWithoutGamesInputSchema).optional(),
+  upsert: z.lazy(() => UserUpsertWithoutGamesInputSchema).optional(),
+  connect: z.lazy(() => UserWhereUniqueInputSchema).optional(),
+  update: z.union([ z.lazy(() => UserUpdateWithoutGamesInputSchema),z.lazy(() => UserUncheckedUpdateWithoutGamesInputSchema) ]).optional(),
+}).strict();
+
+export const MoveUncheckedUpdateManyWithoutUser_gameNestedInputSchema: z.ZodType<Prisma.MoveUncheckedUpdateManyWithoutUser_gameNestedInput> = z.object({
+  create: z.union([ z.lazy(() => MoveCreateWithoutUser_gameInputSchema),z.lazy(() => MoveCreateWithoutUser_gameInputSchema).array(),z.lazy(() => MoveUncheckedCreateWithoutUser_gameInputSchema),z.lazy(() => MoveUncheckedCreateWithoutUser_gameInputSchema).array() ]).optional(),
+  connectOrCreate: z.union([ z.lazy(() => MoveCreateOrConnectWithoutUser_gameInputSchema),z.lazy(() => MoveCreateOrConnectWithoutUser_gameInputSchema).array() ]).optional(),
+  upsert: z.union([ z.lazy(() => MoveUpsertWithWhereUniqueWithoutUser_gameInputSchema),z.lazy(() => MoveUpsertWithWhereUniqueWithoutUser_gameInputSchema).array() ]).optional(),
+  createMany: z.lazy(() => MoveCreateManyUser_gameInputEnvelopeSchema).optional(),
+  set: z.union([ z.lazy(() => MoveWhereUniqueInputSchema),z.lazy(() => MoveWhereUniqueInputSchema).array() ]).optional(),
+  disconnect: z.union([ z.lazy(() => MoveWhereUniqueInputSchema),z.lazy(() => MoveWhereUniqueInputSchema).array() ]).optional(),
+  delete: z.union([ z.lazy(() => MoveWhereUniqueInputSchema),z.lazy(() => MoveWhereUniqueInputSchema).array() ]).optional(),
+  connect: z.union([ z.lazy(() => MoveWhereUniqueInputSchema),z.lazy(() => MoveWhereUniqueInputSchema).array() ]).optional(),
+  update: z.union([ z.lazy(() => MoveUpdateWithWhereUniqueWithoutUser_gameInputSchema),z.lazy(() => MoveUpdateWithWhereUniqueWithoutUser_gameInputSchema).array() ]).optional(),
+  updateMany: z.union([ z.lazy(() => MoveUpdateManyWithWhereWithoutUser_gameInputSchema),z.lazy(() => MoveUpdateManyWithWhereWithoutUser_gameInputSchema).array() ]).optional(),
+  deleteMany: z.union([ z.lazy(() => MoveScalarWhereInputSchema),z.lazy(() => MoveScalarWhereInputSchema).array() ]).optional(),
+}).strict();
+
+export const ChatUncheckedUpdateManyWithoutUser_gameNestedInputSchema: z.ZodType<Prisma.ChatUncheckedUpdateManyWithoutUser_gameNestedInput> = z.object({
+  create: z.union([ z.lazy(() => ChatCreateWithoutUser_gameInputSchema),z.lazy(() => ChatCreateWithoutUser_gameInputSchema).array(),z.lazy(() => ChatUncheckedCreateWithoutUser_gameInputSchema),z.lazy(() => ChatUncheckedCreateWithoutUser_gameInputSchema).array() ]).optional(),
+  connectOrCreate: z.union([ z.lazy(() => ChatCreateOrConnectWithoutUser_gameInputSchema),z.lazy(() => ChatCreateOrConnectWithoutUser_gameInputSchema).array() ]).optional(),
+  upsert: z.union([ z.lazy(() => ChatUpsertWithWhereUniqueWithoutUser_gameInputSchema),z.lazy(() => ChatUpsertWithWhereUniqueWithoutUser_gameInputSchema).array() ]).optional(),
+  createMany: z.lazy(() => ChatCreateManyUser_gameInputEnvelopeSchema).optional(),
+  set: z.union([ z.lazy(() => ChatWhereUniqueInputSchema),z.lazy(() => ChatWhereUniqueInputSchema).array() ]).optional(),
+  disconnect: z.union([ z.lazy(() => ChatWhereUniqueInputSchema),z.lazy(() => ChatWhereUniqueInputSchema).array() ]).optional(),
+  delete: z.union([ z.lazy(() => ChatWhereUniqueInputSchema),z.lazy(() => ChatWhereUniqueInputSchema).array() ]).optional(),
+  connect: z.union([ z.lazy(() => ChatWhereUniqueInputSchema),z.lazy(() => ChatWhereUniqueInputSchema).array() ]).optional(),
+  update: z.union([ z.lazy(() => ChatUpdateWithWhereUniqueWithoutUser_gameInputSchema),z.lazy(() => ChatUpdateWithWhereUniqueWithoutUser_gameInputSchema).array() ]).optional(),
+  updateMany: z.union([ z.lazy(() => ChatUpdateManyWithWhereWithoutUser_gameInputSchema),z.lazy(() => ChatUpdateManyWithWhereWithoutUser_gameInputSchema).array() ]).optional(),
+  deleteMany: z.union([ z.lazy(() => ChatScalarWhereInputSchema),z.lazy(() => ChatScalarWhereInputSchema).array() ]).optional(),
+}).strict();
+
+export const User_GameCreateNestedOneWithoutMovesInputSchema: z.ZodType<Prisma.User_GameCreateNestedOneWithoutMovesInput> = z.object({
+  create: z.union([ z.lazy(() => User_GameCreateWithoutMovesInputSchema),z.lazy(() => User_GameUncheckedCreateWithoutMovesInputSchema) ]).optional(),
+  connectOrCreate: z.lazy(() => User_GameCreateOrConnectWithoutMovesInputSchema).optional(),
+  connect: z.lazy(() => User_GameWhereUniqueInputSchema).optional()
+}).strict();
+
+export const IntFieldUpdateOperationsInputSchema: z.ZodType<Prisma.IntFieldUpdateOperationsInput> = z.object({
+  set: z.number().optional(),
+  increment: z.number().optional(),
+  decrement: z.number().optional(),
+  multiply: z.number().optional(),
+  divide: z.number().optional()
+}).strict();
+
+export const User_GameUpdateOneRequiredWithoutMovesNestedInputSchema: z.ZodType<Prisma.User_GameUpdateOneRequiredWithoutMovesNestedInput> = z.object({
+  create: z.union([ z.lazy(() => User_GameCreateWithoutMovesInputSchema),z.lazy(() => User_GameUncheckedCreateWithoutMovesInputSchema) ]).optional(),
+  connectOrCreate: z.lazy(() => User_GameCreateOrConnectWithoutMovesInputSchema).optional(),
+  upsert: z.lazy(() => User_GameUpsertWithoutMovesInputSchema).optional(),
+  connect: z.lazy(() => User_GameWhereUniqueInputSchema).optional(),
+  update: z.union([ z.lazy(() => User_GameUpdateWithoutMovesInputSchema),z.lazy(() => User_GameUncheckedUpdateWithoutMovesInputSchema) ]).optional(),
+}).strict();
+
+export const User_GameCreateNestedOneWithoutChatsInputSchema: z.ZodType<Prisma.User_GameCreateNestedOneWithoutChatsInput> = z.object({
+  create: z.union([ z.lazy(() => User_GameCreateWithoutChatsInputSchema),z.lazy(() => User_GameUncheckedCreateWithoutChatsInputSchema) ]).optional(),
+  connectOrCreate: z.lazy(() => User_GameCreateOrConnectWithoutChatsInputSchema).optional(),
+  connect: z.lazy(() => User_GameWhereUniqueInputSchema).optional()
+}).strict();
+
+export const User_GameUpdateOneRequiredWithoutChatsNestedInputSchema: z.ZodType<Prisma.User_GameUpdateOneRequiredWithoutChatsNestedInput> = z.object({
+  create: z.union([ z.lazy(() => User_GameCreateWithoutChatsInputSchema),z.lazy(() => User_GameUncheckedCreateWithoutChatsInputSchema) ]).optional(),
+  connectOrCreate: z.lazy(() => User_GameCreateOrConnectWithoutChatsInputSchema).optional(),
+  upsert: z.lazy(() => User_GameUpsertWithoutChatsInputSchema).optional(),
+  connect: z.lazy(() => User_GameWhereUniqueInputSchema).optional(),
+  update: z.union([ z.lazy(() => User_GameUpdateWithoutChatsInputSchema),z.lazy(() => User_GameUncheckedUpdateWithoutChatsInputSchema) ]).optional(),
+}).strict();
+
+export const NestedStringFilterSchema: z.ZodType<Prisma.NestedStringFilter> = z.object({
+  equals: z.string().optional(),
+  in: z.string().array().optional(),
+  notIn: z.string().array().optional(),
+  lt: z.string().optional(),
+  lte: z.string().optional(),
+  gt: z.string().optional(),
+  gte: z.string().optional(),
+  contains: z.string().optional(),
+  startsWith: z.string().optional(),
+  endsWith: z.string().optional(),
+  not: z.union([ z.string(),z.lazy(() => NestedStringFilterSchema) ]).optional(),
+}).strict();
+
+export const NestedStringNullableFilterSchema: z.ZodType<Prisma.NestedStringNullableFilter> = z.object({
+  equals: z.string().optional().nullable(),
+  in: z.string().array().optional().nullable(),
+  notIn: z.string().array().optional().nullable(),
+  lt: z.string().optional(),
+  lte: z.string().optional(),
+  gt: z.string().optional(),
+  gte: z.string().optional(),
+  contains: z.string().optional(),
+  startsWith: z.string().optional(),
+  endsWith: z.string().optional(),
+  not: z.union([ z.string(),z.lazy(() => NestedStringNullableFilterSchema) ]).optional().nullable(),
+}).strict();
+
+export const NestedIntNullableFilterSchema: z.ZodType<Prisma.NestedIntNullableFilter> = 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(() => NestedIntNullableFilterSchema) ]).optional().nullable(),
+}).strict();
+
+export const NestedStringWithAggregatesFilterSchema: z.ZodType<Prisma.NestedStringWithAggregatesFilter> = z.object({
+  equals: z.string().optional(),
+  in: z.string().array().optional(),
+  notIn: z.string().array().optional(),
+  lt: z.string().optional(),
+  lte: z.string().optional(),
+  gt: z.string().optional(),
+  gte: z.string().optional(),
+  contains: z.string().optional(),
+  startsWith: z.string().optional(),
+  endsWith: z.string().optional(),
+  not: z.union([ z.string(),z.lazy(() => NestedStringWithAggregatesFilterSchema) ]).optional(),
+  _count: z.lazy(() => NestedIntFilterSchema).optional(),
+  _min: z.lazy(() => NestedStringFilterSchema).optional(),
+  _max: z.lazy(() => NestedStringFilterSchema).optional()
+}).strict();
+
+export const NestedIntFilterSchema: z.ZodType<Prisma.NestedIntFilter> = 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(() => NestedIntFilterSchema) ]).optional(),
+}).strict();
+
+export const NestedStringNullableWithAggregatesFilterSchema: z.ZodType<Prisma.NestedStringNullableWithAggregatesFilter> = z.object({
+  equals: z.string().optional().nullable(),
+  in: z.string().array().optional().nullable(),
+  notIn: z.string().array().optional().nullable(),
+  lt: z.string().optional(),
+  lte: z.string().optional(),
+  gt: z.string().optional(),
+  gte: z.string().optional(),
+  contains: z.string().optional(),
+  startsWith: z.string().optional(),
+  endsWith: z.string().optional(),
+  not: z.union([ z.string(),z.lazy(() => NestedStringNullableWithAggregatesFilterSchema) ]).optional().nullable(),
+  _count: z.lazy(() => NestedIntNullableFilterSchema).optional(),
+  _min: z.lazy(() => NestedStringNullableFilterSchema).optional(),
+  _max: z.lazy(() => NestedStringNullableFilterSchema).optional()
+}).strict();
+
+export const NestedIntNullableWithAggregatesFilterSchema: z.ZodType<Prisma.NestedIntNullableWithAggregatesFilter> = 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(() => NestedIntNullableWithAggregatesFilterSchema) ]).optional().nullable(),
+  _count: z.lazy(() => NestedIntNullableFilterSchema).optional(),
+  _avg: z.lazy(() => NestedFloatNullableFilterSchema).optional(),
+  _sum: z.lazy(() => NestedIntNullableFilterSchema).optional(),
+  _min: z.lazy(() => NestedIntNullableFilterSchema).optional(),
+  _max: z.lazy(() => NestedIntNullableFilterSchema).optional()
+}).strict();
+
+export const NestedFloatNullableFilterSchema: z.ZodType<Prisma.NestedFloatNullableFilter> = 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(() => NestedFloatNullableFilterSchema) ]).optional().nullable(),
+}).strict();
+
+export const NestedDateTimeFilterSchema: z.ZodType<Prisma.NestedDateTimeFilter> = z.object({
+  equals: z.coerce.date().optional(),
+  in: z.coerce.date().array().optional(),
+  notIn: z.coerce.date().array().optional(),
+  lt: z.coerce.date().optional(),
+  lte: z.coerce.date().optional(),
+  gt: z.coerce.date().optional(),
+  gte: z.coerce.date().optional(),
+  not: z.union([ z.coerce.date(),z.lazy(() => NestedDateTimeFilterSchema) ]).optional(),
+}).strict();
+
+export const NestedDateTimeWithAggregatesFilterSchema: z.ZodType<Prisma.NestedDateTimeWithAggregatesFilter> = z.object({
+  equals: z.coerce.date().optional(),
+  in: z.coerce.date().array().optional(),
+  notIn: z.coerce.date().array().optional(),
+  lt: z.coerce.date().optional(),
+  lte: z.coerce.date().optional(),
+  gt: z.coerce.date().optional(),
+  gte: z.coerce.date().optional(),
+  not: z.union([ z.coerce.date(),z.lazy(() => NestedDateTimeWithAggregatesFilterSchema) ]).optional(),
+  _count: z.lazy(() => NestedIntFilterSchema).optional(),
+  _min: z.lazy(() => NestedDateTimeFilterSchema).optional(),
+  _max: z.lazy(() => NestedDateTimeFilterSchema).optional()
+}).strict();
+
+export const NestedDateTimeNullableFilterSchema: z.ZodType<Prisma.NestedDateTimeNullableFilter> = z.object({
+  equals: z.coerce.date().optional().nullable(),
+  in: z.coerce.date().array().optional().nullable(),
+  notIn: z.coerce.date().array().optional().nullable(),
+  lt: z.coerce.date().optional(),
+  lte: z.coerce.date().optional(),
+  gt: z.coerce.date().optional(),
+  gte: z.coerce.date().optional(),
+  not: z.union([ z.coerce.date(),z.lazy(() => NestedDateTimeNullableFilterSchema) ]).optional().nullable(),
+}).strict();
+
+export const NestedDateTimeNullableWithAggregatesFilterSchema: z.ZodType<Prisma.NestedDateTimeNullableWithAggregatesFilter> = z.object({
+  equals: z.coerce.date().optional().nullable(),
+  in: z.coerce.date().array().optional().nullable(),
+  notIn: z.coerce.date().array().optional().nullable(),
+  lt: z.coerce.date().optional(),
+  lte: z.coerce.date().optional(),
+  gt: z.coerce.date().optional(),
+  gte: z.coerce.date().optional(),
+  not: z.union([ z.coerce.date(),z.lazy(() => NestedDateTimeNullableWithAggregatesFilterSchema) ]).optional().nullable(),
+  _count: z.lazy(() => NestedIntNullableFilterSchema).optional(),
+  _min: z.lazy(() => NestedDateTimeNullableFilterSchema).optional(),
+  _max: z.lazy(() => NestedDateTimeNullableFilterSchema).optional()
+}).strict();
+
+export const NestedEnumGameStateFilterSchema: z.ZodType<Prisma.NestedEnumGameStateFilter> = z.object({
+  equals: z.lazy(() => GameStateSchema).optional(),
+  in: z.lazy(() => GameStateSchema).array().optional(),
+  notIn: z.lazy(() => GameStateSchema).array().optional(),
+  not: z.union([ z.lazy(() => GameStateSchema),z.lazy(() => NestedEnumGameStateFilterSchema) ]).optional(),
+}).strict();
+
+export const NestedEnumGameStateWithAggregatesFilterSchema: z.ZodType<Prisma.NestedEnumGameStateWithAggregatesFilter> = z.object({
+  equals: z.lazy(() => GameStateSchema).optional(),
+  in: z.lazy(() => GameStateSchema).array().optional(),
+  notIn: z.lazy(() => GameStateSchema).array().optional(),
+  not: z.union([ z.lazy(() => GameStateSchema),z.lazy(() => NestedEnumGameStateWithAggregatesFilterSchema) ]).optional(),
+  _count: z.lazy(() => NestedIntFilterSchema).optional(),
+  _min: z.lazy(() => NestedEnumGameStateFilterSchema).optional(),
+  _max: z.lazy(() => NestedEnumGameStateFilterSchema).optional()
+}).strict();
+
+export const NestedBoolFilterSchema: z.ZodType<Prisma.NestedBoolFilter> = z.object({
+  equals: z.boolean().optional(),
+  not: z.union([ z.boolean(),z.lazy(() => NestedBoolFilterSchema) ]).optional(),
+}).strict();
+
+export const NestedBoolWithAggregatesFilterSchema: z.ZodType<Prisma.NestedBoolWithAggregatesFilter> = z.object({
+  equals: z.boolean().optional(),
+  not: z.union([ z.boolean(),z.lazy(() => NestedBoolWithAggregatesFilterSchema) ]).optional(),
+  _count: z.lazy(() => NestedIntFilterSchema).optional(),
+  _min: z.lazy(() => NestedBoolFilterSchema).optional(),
+  _max: z.lazy(() => NestedBoolFilterSchema).optional()
+}).strict();
+
+export const NestedIntWithAggregatesFilterSchema: z.ZodType<Prisma.NestedIntWithAggregatesFilter> = 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(() => NestedIntWithAggregatesFilterSchema) ]).optional(),
+  _count: z.lazy(() => NestedIntFilterSchema).optional(),
+  _avg: z.lazy(() => NestedFloatFilterSchema).optional(),
+  _sum: z.lazy(() => NestedIntFilterSchema).optional(),
+  _min: z.lazy(() => NestedIntFilterSchema).optional(),
+  _max: z.lazy(() => NestedIntFilterSchema).optional()
+}).strict();
+
+export const NestedFloatFilterSchema: z.ZodType<Prisma.NestedFloatFilter> = 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(() => NestedFloatFilterSchema) ]).optional(),
+}).strict();
+
+export const UserCreateWithoutAccountsInputSchema: z.ZodType<Prisma.UserCreateWithoutAccountsInput> = z.object({
+  id: z.string().optional(),
+  name: z.string().optional().nullable(),
+  email: z.string().optional().nullable(),
+  emailVerified: z.coerce.date().optional().nullable(),
+  image: z.string().optional().nullable(),
+  createdAt: z.coerce.date().optional(),
+  updatedAt: z.coerce.date().optional(),
+  games: z.lazy(() => User_GameCreateNestedManyWithoutUserInputSchema).optional(),
+  sessions: z.lazy(() => SessionCreateNestedManyWithoutUserInputSchema).optional()
+}).strict();
+
+export const UserUncheckedCreateWithoutAccountsInputSchema: z.ZodType<Prisma.UserUncheckedCreateWithoutAccountsInput> = z.object({
+  id: z.string().optional(),
+  name: z.string().optional().nullable(),
+  email: z.string().optional().nullable(),
+  emailVerified: z.coerce.date().optional().nullable(),
+  image: z.string().optional().nullable(),
+  createdAt: z.coerce.date().optional(),
+  updatedAt: z.coerce.date().optional(),
+  games: z.lazy(() => User_GameUncheckedCreateNestedManyWithoutUserInputSchema).optional(),
+  sessions: z.lazy(() => SessionUncheckedCreateNestedManyWithoutUserInputSchema).optional()
+}).strict();
+
+export const UserCreateOrConnectWithoutAccountsInputSchema: z.ZodType<Prisma.UserCreateOrConnectWithoutAccountsInput> = z.object({
+  where: z.lazy(() => UserWhereUniqueInputSchema),
+  create: z.union([ z.lazy(() => UserCreateWithoutAccountsInputSchema),z.lazy(() => UserUncheckedCreateWithoutAccountsInputSchema) ]),
+}).strict();
+
+export const UserUpsertWithoutAccountsInputSchema: z.ZodType<Prisma.UserUpsertWithoutAccountsInput> = z.object({
+  update: z.union([ z.lazy(() => UserUpdateWithoutAccountsInputSchema),z.lazy(() => UserUncheckedUpdateWithoutAccountsInputSchema) ]),
+  create: z.union([ z.lazy(() => UserCreateWithoutAccountsInputSchema),z.lazy(() => UserUncheckedCreateWithoutAccountsInputSchema) ]),
+}).strict();
+
+export const UserUpdateWithoutAccountsInputSchema: z.ZodType<Prisma.UserUpdateWithoutAccountsInput> = z.object({
+  id: z.union([ z.string(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  name: z.union([ z.string(),z.lazy(() => NullableStringFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  email: z.union([ z.string(),z.lazy(() => NullableStringFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  emailVerified: z.union([ z.coerce.date(),z.lazy(() => NullableDateTimeFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  image: z.union([ z.string(),z.lazy(() => NullableStringFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  createdAt: z.union([ z.coerce.date(),z.lazy(() => DateTimeFieldUpdateOperationsInputSchema) ]).optional(),
+  updatedAt: z.union([ z.coerce.date(),z.lazy(() => DateTimeFieldUpdateOperationsInputSchema) ]).optional(),
+  games: z.lazy(() => User_GameUpdateManyWithoutUserNestedInputSchema).optional(),
+  sessions: z.lazy(() => SessionUpdateManyWithoutUserNestedInputSchema).optional()
+}).strict();
+
+export const UserUncheckedUpdateWithoutAccountsInputSchema: z.ZodType<Prisma.UserUncheckedUpdateWithoutAccountsInput> = z.object({
+  id: z.union([ z.string(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  name: z.union([ z.string(),z.lazy(() => NullableStringFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  email: z.union([ z.string(),z.lazy(() => NullableStringFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  emailVerified: z.union([ z.coerce.date(),z.lazy(() => NullableDateTimeFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  image: z.union([ z.string(),z.lazy(() => NullableStringFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  createdAt: z.union([ z.coerce.date(),z.lazy(() => DateTimeFieldUpdateOperationsInputSchema) ]).optional(),
+  updatedAt: z.union([ z.coerce.date(),z.lazy(() => DateTimeFieldUpdateOperationsInputSchema) ]).optional(),
+  games: z.lazy(() => User_GameUncheckedUpdateManyWithoutUserNestedInputSchema).optional(),
+  sessions: z.lazy(() => SessionUncheckedUpdateManyWithoutUserNestedInputSchema).optional()
+}).strict();
+
+export const UserCreateWithoutSessionsInputSchema: z.ZodType<Prisma.UserCreateWithoutSessionsInput> = z.object({
+  id: z.string().optional(),
+  name: z.string().optional().nullable(),
+  email: z.string().optional().nullable(),
+  emailVerified: z.coerce.date().optional().nullable(),
+  image: z.string().optional().nullable(),
+  createdAt: z.coerce.date().optional(),
+  updatedAt: z.coerce.date().optional(),
+  games: z.lazy(() => User_GameCreateNestedManyWithoutUserInputSchema).optional(),
+  accounts: z.lazy(() => AccountCreateNestedManyWithoutUserInputSchema).optional()
+}).strict();
+
+export const UserUncheckedCreateWithoutSessionsInputSchema: z.ZodType<Prisma.UserUncheckedCreateWithoutSessionsInput> = z.object({
+  id: z.string().optional(),
+  name: z.string().optional().nullable(),
+  email: z.string().optional().nullable(),
+  emailVerified: z.coerce.date().optional().nullable(),
+  image: z.string().optional().nullable(),
+  createdAt: z.coerce.date().optional(),
+  updatedAt: z.coerce.date().optional(),
+  games: z.lazy(() => User_GameUncheckedCreateNestedManyWithoutUserInputSchema).optional(),
+  accounts: z.lazy(() => AccountUncheckedCreateNestedManyWithoutUserInputSchema).optional()
+}).strict();
+
+export const UserCreateOrConnectWithoutSessionsInputSchema: z.ZodType<Prisma.UserCreateOrConnectWithoutSessionsInput> = z.object({
+  where: z.lazy(() => UserWhereUniqueInputSchema),
+  create: z.union([ z.lazy(() => UserCreateWithoutSessionsInputSchema),z.lazy(() => UserUncheckedCreateWithoutSessionsInputSchema) ]),
+}).strict();
+
+export const UserUpsertWithoutSessionsInputSchema: z.ZodType<Prisma.UserUpsertWithoutSessionsInput> = z.object({
+  update: z.union([ z.lazy(() => UserUpdateWithoutSessionsInputSchema),z.lazy(() => UserUncheckedUpdateWithoutSessionsInputSchema) ]),
+  create: z.union([ z.lazy(() => UserCreateWithoutSessionsInputSchema),z.lazy(() => UserUncheckedCreateWithoutSessionsInputSchema) ]),
+}).strict();
+
+export const UserUpdateWithoutSessionsInputSchema: z.ZodType<Prisma.UserUpdateWithoutSessionsInput> = z.object({
+  id: z.union([ z.string(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  name: z.union([ z.string(),z.lazy(() => NullableStringFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  email: z.union([ z.string(),z.lazy(() => NullableStringFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  emailVerified: z.union([ z.coerce.date(),z.lazy(() => NullableDateTimeFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  image: z.union([ z.string(),z.lazy(() => NullableStringFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  createdAt: z.union([ z.coerce.date(),z.lazy(() => DateTimeFieldUpdateOperationsInputSchema) ]).optional(),
+  updatedAt: z.union([ z.coerce.date(),z.lazy(() => DateTimeFieldUpdateOperationsInputSchema) ]).optional(),
+  games: z.lazy(() => User_GameUpdateManyWithoutUserNestedInputSchema).optional(),
+  accounts: z.lazy(() => AccountUpdateManyWithoutUserNestedInputSchema).optional()
+}).strict();
+
+export const UserUncheckedUpdateWithoutSessionsInputSchema: z.ZodType<Prisma.UserUncheckedUpdateWithoutSessionsInput> = z.object({
+  id: z.union([ z.string(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  name: z.union([ z.string(),z.lazy(() => NullableStringFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  email: z.union([ z.string(),z.lazy(() => NullableStringFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  emailVerified: z.union([ z.coerce.date(),z.lazy(() => NullableDateTimeFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  image: z.union([ z.string(),z.lazy(() => NullableStringFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  createdAt: z.union([ z.coerce.date(),z.lazy(() => DateTimeFieldUpdateOperationsInputSchema) ]).optional(),
+  updatedAt: z.union([ z.coerce.date(),z.lazy(() => DateTimeFieldUpdateOperationsInputSchema) ]).optional(),
+  games: z.lazy(() => User_GameUncheckedUpdateManyWithoutUserNestedInputSchema).optional(),
+  accounts: z.lazy(() => AccountUncheckedUpdateManyWithoutUserNestedInputSchema).optional()
+}).strict();
+
+export const User_GameCreateWithoutUserInputSchema: z.ZodType<Prisma.User_GameCreateWithoutUserInput> = z.object({
+  id: z.string().optional(),
+  createdAt: z.coerce.date().optional(),
+  isOwner: z.boolean(),
+  moves: z.lazy(() => MoveCreateNestedManyWithoutUser_gameInputSchema).optional(),
+  chats: z.lazy(() => ChatCreateNestedManyWithoutUser_gameInputSchema).optional(),
+  game: z.lazy(() => GameCreateNestedOneWithoutUsersInputSchema)
+}).strict();
+
+export const User_GameUncheckedCreateWithoutUserInputSchema: z.ZodType<Prisma.User_GameUncheckedCreateWithoutUserInput> = z.object({
+  id: z.string().optional(),
+  createdAt: z.coerce.date().optional(),
+  gameId: z.string(),
+  isOwner: z.boolean(),
+  moves: z.lazy(() => MoveUncheckedCreateNestedManyWithoutUser_gameInputSchema).optional(),
+  chats: z.lazy(() => ChatUncheckedCreateNestedManyWithoutUser_gameInputSchema).optional()
+}).strict();
+
+export const User_GameCreateOrConnectWithoutUserInputSchema: z.ZodType<Prisma.User_GameCreateOrConnectWithoutUserInput> = z.object({
+  where: z.lazy(() => User_GameWhereUniqueInputSchema),
+  create: z.union([ z.lazy(() => User_GameCreateWithoutUserInputSchema),z.lazy(() => User_GameUncheckedCreateWithoutUserInputSchema) ]),
+}).strict();
+
+export const User_GameCreateManyUserInputEnvelopeSchema: z.ZodType<Prisma.User_GameCreateManyUserInputEnvelope> = z.object({
+  data: z.union([ z.lazy(() => User_GameCreateManyUserInputSchema),z.lazy(() => User_GameCreateManyUserInputSchema).array() ]),
+  skipDuplicates: z.boolean().optional()
+}).strict();
+
+export const AccountCreateWithoutUserInputSchema: z.ZodType<Prisma.AccountCreateWithoutUserInput> = z.object({
+  id: z.string().optional(),
+  type: z.string(),
+  provider: z.string(),
+  providerAccountId: z.string(),
+  refresh_token: z.string().optional().nullable(),
+  access_token: z.string().optional().nullable(),
+  expires_at: z.number().optional().nullable(),
+  ext_expires_in: z.number().optional().nullable(),
+  token_type: z.string().optional().nullable(),
+  scope: z.string().optional().nullable(),
+  id_token: z.string().optional().nullable(),
+  session_state: z.string().optional().nullable(),
+  oauth_token_secret: z.string().optional().nullable(),
+  oauth_token: z.string().optional().nullable()
+}).strict();
+
+export const AccountUncheckedCreateWithoutUserInputSchema: z.ZodType<Prisma.AccountUncheckedCreateWithoutUserInput> = z.object({
+  id: z.string().optional(),
+  type: z.string(),
+  provider: z.string(),
+  providerAccountId: z.string(),
+  refresh_token: z.string().optional().nullable(),
+  access_token: z.string().optional().nullable(),
+  expires_at: z.number().optional().nullable(),
+  ext_expires_in: z.number().optional().nullable(),
+  token_type: z.string().optional().nullable(),
+  scope: z.string().optional().nullable(),
+  id_token: z.string().optional().nullable(),
+  session_state: z.string().optional().nullable(),
+  oauth_token_secret: z.string().optional().nullable(),
+  oauth_token: z.string().optional().nullable()
+}).strict();
+
+export const AccountCreateOrConnectWithoutUserInputSchema: z.ZodType<Prisma.AccountCreateOrConnectWithoutUserInput> = z.object({
+  where: z.lazy(() => AccountWhereUniqueInputSchema),
+  create: z.union([ z.lazy(() => AccountCreateWithoutUserInputSchema),z.lazy(() => AccountUncheckedCreateWithoutUserInputSchema) ]),
+}).strict();
+
+export const AccountCreateManyUserInputEnvelopeSchema: z.ZodType<Prisma.AccountCreateManyUserInputEnvelope> = z.object({
+  data: z.union([ z.lazy(() => AccountCreateManyUserInputSchema),z.lazy(() => AccountCreateManyUserInputSchema).array() ]),
+  skipDuplicates: z.boolean().optional()
+}).strict();
+
+export const SessionCreateWithoutUserInputSchema: z.ZodType<Prisma.SessionCreateWithoutUserInput> = z.object({
+  id: z.string().optional(),
+  sessionToken: z.string(),
+  expires: z.coerce.date()
+}).strict();
+
+export const SessionUncheckedCreateWithoutUserInputSchema: z.ZodType<Prisma.SessionUncheckedCreateWithoutUserInput> = z.object({
+  id: z.string().optional(),
+  sessionToken: z.string(),
+  expires: z.coerce.date()
+}).strict();
+
+export const SessionCreateOrConnectWithoutUserInputSchema: z.ZodType<Prisma.SessionCreateOrConnectWithoutUserInput> = z.object({
+  where: z.lazy(() => SessionWhereUniqueInputSchema),
+  create: z.union([ z.lazy(() => SessionCreateWithoutUserInputSchema),z.lazy(() => SessionUncheckedCreateWithoutUserInputSchema) ]),
+}).strict();
+
+export const SessionCreateManyUserInputEnvelopeSchema: z.ZodType<Prisma.SessionCreateManyUserInputEnvelope> = z.object({
+  data: z.union([ z.lazy(() => SessionCreateManyUserInputSchema),z.lazy(() => SessionCreateManyUserInputSchema).array() ]),
+  skipDuplicates: z.boolean().optional()
+}).strict();
+
+export const User_GameUpsertWithWhereUniqueWithoutUserInputSchema: z.ZodType<Prisma.User_GameUpsertWithWhereUniqueWithoutUserInput> = z.object({
+  where: z.lazy(() => User_GameWhereUniqueInputSchema),
+  update: z.union([ z.lazy(() => User_GameUpdateWithoutUserInputSchema),z.lazy(() => User_GameUncheckedUpdateWithoutUserInputSchema) ]),
+  create: z.union([ z.lazy(() => User_GameCreateWithoutUserInputSchema),z.lazy(() => User_GameUncheckedCreateWithoutUserInputSchema) ]),
+}).strict();
+
+export const User_GameUpdateWithWhereUniqueWithoutUserInputSchema: z.ZodType<Prisma.User_GameUpdateWithWhereUniqueWithoutUserInput> = z.object({
+  where: z.lazy(() => User_GameWhereUniqueInputSchema),
+  data: z.union([ z.lazy(() => User_GameUpdateWithoutUserInputSchema),z.lazy(() => User_GameUncheckedUpdateWithoutUserInputSchema) ]),
+}).strict();
+
+export const User_GameUpdateManyWithWhereWithoutUserInputSchema: z.ZodType<Prisma.User_GameUpdateManyWithWhereWithoutUserInput> = z.object({
+  where: z.lazy(() => User_GameScalarWhereInputSchema),
+  data: z.union([ z.lazy(() => User_GameUpdateManyMutationInputSchema),z.lazy(() => User_GameUncheckedUpdateManyWithoutGamesInputSchema) ]),
+}).strict();
+
+export const User_GameScalarWhereInputSchema: z.ZodType<Prisma.User_GameScalarWhereInput> = z.object({
+  AND: z.union([ z.lazy(() => User_GameScalarWhereInputSchema),z.lazy(() => User_GameScalarWhereInputSchema).array() ]).optional(),
+  OR: z.lazy(() => User_GameScalarWhereInputSchema).array().optional(),
+  NOT: z.union([ z.lazy(() => User_GameScalarWhereInputSchema),z.lazy(() => User_GameScalarWhereInputSchema).array() ]).optional(),
+  id: z.union([ z.lazy(() => StringFilterSchema),z.string() ]).optional(),
+  createdAt: z.union([ z.lazy(() => DateTimeFilterSchema),z.coerce.date() ]).optional(),
+  gameId: z.union([ z.lazy(() => StringFilterSchema),z.string() ]).optional(),
+  userId: z.union([ z.lazy(() => StringFilterSchema),z.string() ]).optional(),
+  isOwner: z.union([ z.lazy(() => BoolFilterSchema),z.boolean() ]).optional(),
+}).strict();
+
+export const AccountUpsertWithWhereUniqueWithoutUserInputSchema: z.ZodType<Prisma.AccountUpsertWithWhereUniqueWithoutUserInput> = z.object({
+  where: z.lazy(() => AccountWhereUniqueInputSchema),
+  update: z.union([ z.lazy(() => AccountUpdateWithoutUserInputSchema),z.lazy(() => AccountUncheckedUpdateWithoutUserInputSchema) ]),
+  create: z.union([ z.lazy(() => AccountCreateWithoutUserInputSchema),z.lazy(() => AccountUncheckedCreateWithoutUserInputSchema) ]),
+}).strict();
+
+export const AccountUpdateWithWhereUniqueWithoutUserInputSchema: z.ZodType<Prisma.AccountUpdateWithWhereUniqueWithoutUserInput> = z.object({
+  where: z.lazy(() => AccountWhereUniqueInputSchema),
+  data: z.union([ z.lazy(() => AccountUpdateWithoutUserInputSchema),z.lazy(() => AccountUncheckedUpdateWithoutUserInputSchema) ]),
+}).strict();
+
+export const AccountUpdateManyWithWhereWithoutUserInputSchema: z.ZodType<Prisma.AccountUpdateManyWithWhereWithoutUserInput> = z.object({
+  where: z.lazy(() => AccountScalarWhereInputSchema),
+  data: z.union([ z.lazy(() => AccountUpdateManyMutationInputSchema),z.lazy(() => AccountUncheckedUpdateManyWithoutAccountsInputSchema) ]),
+}).strict();
+
+export const AccountScalarWhereInputSchema: z.ZodType<Prisma.AccountScalarWhereInput> = z.object({
+  AND: z.union([ z.lazy(() => AccountScalarWhereInputSchema),z.lazy(() => AccountScalarWhereInputSchema).array() ]).optional(),
+  OR: z.lazy(() => AccountScalarWhereInputSchema).array().optional(),
+  NOT: z.union([ z.lazy(() => AccountScalarWhereInputSchema),z.lazy(() => AccountScalarWhereInputSchema).array() ]).optional(),
+  id: z.union([ z.lazy(() => StringFilterSchema),z.string() ]).optional(),
+  userId: z.union([ z.lazy(() => StringFilterSchema),z.string() ]).optional(),
+  type: z.union([ z.lazy(() => StringFilterSchema),z.string() ]).optional(),
+  provider: z.union([ z.lazy(() => StringFilterSchema),z.string() ]).optional(),
+  providerAccountId: z.union([ z.lazy(() => StringFilterSchema),z.string() ]).optional(),
+  refresh_token: z.union([ z.lazy(() => StringNullableFilterSchema),z.string() ]).optional().nullable(),
+  access_token: z.union([ z.lazy(() => StringNullableFilterSchema),z.string() ]).optional().nullable(),
+  expires_at: z.union([ z.lazy(() => IntNullableFilterSchema),z.number() ]).optional().nullable(),
+  ext_expires_in: z.union([ z.lazy(() => IntNullableFilterSchema),z.number() ]).optional().nullable(),
+  token_type: z.union([ z.lazy(() => StringNullableFilterSchema),z.string() ]).optional().nullable(),
+  scope: z.union([ z.lazy(() => StringNullableFilterSchema),z.string() ]).optional().nullable(),
+  id_token: z.union([ z.lazy(() => StringNullableFilterSchema),z.string() ]).optional().nullable(),
+  session_state: z.union([ z.lazy(() => StringNullableFilterSchema),z.string() ]).optional().nullable(),
+  oauth_token_secret: z.union([ z.lazy(() => StringNullableFilterSchema),z.string() ]).optional().nullable(),
+  oauth_token: z.union([ z.lazy(() => StringNullableFilterSchema),z.string() ]).optional().nullable(),
+}).strict();
+
+export const SessionUpsertWithWhereUniqueWithoutUserInputSchema: z.ZodType<Prisma.SessionUpsertWithWhereUniqueWithoutUserInput> = z.object({
+  where: z.lazy(() => SessionWhereUniqueInputSchema),
+  update: z.union([ z.lazy(() => SessionUpdateWithoutUserInputSchema),z.lazy(() => SessionUncheckedUpdateWithoutUserInputSchema) ]),
+  create: z.union([ z.lazy(() => SessionCreateWithoutUserInputSchema),z.lazy(() => SessionUncheckedCreateWithoutUserInputSchema) ]),
+}).strict();
+
+export const SessionUpdateWithWhereUniqueWithoutUserInputSchema: z.ZodType<Prisma.SessionUpdateWithWhereUniqueWithoutUserInput> = z.object({
+  where: z.lazy(() => SessionWhereUniqueInputSchema),
+  data: z.union([ z.lazy(() => SessionUpdateWithoutUserInputSchema),z.lazy(() => SessionUncheckedUpdateWithoutUserInputSchema) ]),
+}).strict();
+
+export const SessionUpdateManyWithWhereWithoutUserInputSchema: z.ZodType<Prisma.SessionUpdateManyWithWhereWithoutUserInput> = z.object({
+  where: z.lazy(() => SessionScalarWhereInputSchema),
+  data: z.union([ z.lazy(() => SessionUpdateManyMutationInputSchema),z.lazy(() => SessionUncheckedUpdateManyWithoutSessionsInputSchema) ]),
+}).strict();
+
+export const SessionScalarWhereInputSchema: z.ZodType<Prisma.SessionScalarWhereInput> = z.object({
+  AND: z.union([ z.lazy(() => SessionScalarWhereInputSchema),z.lazy(() => SessionScalarWhereInputSchema).array() ]).optional(),
+  OR: z.lazy(() => SessionScalarWhereInputSchema).array().optional(),
+  NOT: z.union([ z.lazy(() => SessionScalarWhereInputSchema),z.lazy(() => SessionScalarWhereInputSchema).array() ]).optional(),
+  id: z.union([ z.lazy(() => StringFilterSchema),z.string() ]).optional(),
+  sessionToken: z.union([ z.lazy(() => StringFilterSchema),z.string() ]).optional(),
+  userId: z.union([ z.lazy(() => StringFilterSchema),z.string() ]).optional(),
+  expires: z.union([ z.lazy(() => DateTimeFilterSchema),z.coerce.date() ]).optional(),
+}).strict();
+
+export const GamepinCreateWithoutGameInputSchema: z.ZodType<Prisma.GamepinCreateWithoutGameInput> = z.object({
+  id: z.string().optional(),
+  createdAt: z.coerce.date().optional(),
+  pin: z.string()
+}).strict();
+
+export const GamepinUncheckedCreateWithoutGameInputSchema: z.ZodType<Prisma.GamepinUncheckedCreateWithoutGameInput> = z.object({
+  id: z.string().optional(),
+  createdAt: z.coerce.date().optional(),
+  pin: z.string()
+}).strict();
+
+export const GamepinCreateOrConnectWithoutGameInputSchema: z.ZodType<Prisma.GamepinCreateOrConnectWithoutGameInput> = z.object({
+  where: z.lazy(() => GamepinWhereUniqueInputSchema),
+  create: z.union([ z.lazy(() => GamepinCreateWithoutGameInputSchema),z.lazy(() => GamepinUncheckedCreateWithoutGameInputSchema) ]),
+}).strict();
+
+export const User_GameCreateWithoutGameInputSchema: z.ZodType<Prisma.User_GameCreateWithoutGameInput> = z.object({
+  id: z.string().optional(),
+  createdAt: z.coerce.date().optional(),
+  isOwner: z.boolean(),
+  moves: z.lazy(() => MoveCreateNestedManyWithoutUser_gameInputSchema).optional(),
+  chats: z.lazy(() => ChatCreateNestedManyWithoutUser_gameInputSchema).optional(),
+  user: z.lazy(() => UserCreateNestedOneWithoutGamesInputSchema)
+}).strict();
+
+export const User_GameUncheckedCreateWithoutGameInputSchema: z.ZodType<Prisma.User_GameUncheckedCreateWithoutGameInput> = z.object({
+  id: z.string().optional(),
+  createdAt: z.coerce.date().optional(),
+  userId: z.string(),
+  isOwner: z.boolean(),
+  moves: z.lazy(() => MoveUncheckedCreateNestedManyWithoutUser_gameInputSchema).optional(),
+  chats: z.lazy(() => ChatUncheckedCreateNestedManyWithoutUser_gameInputSchema).optional()
+}).strict();
+
+export const User_GameCreateOrConnectWithoutGameInputSchema: z.ZodType<Prisma.User_GameCreateOrConnectWithoutGameInput> = z.object({
+  where: z.lazy(() => User_GameWhereUniqueInputSchema),
+  create: z.union([ z.lazy(() => User_GameCreateWithoutGameInputSchema),z.lazy(() => User_GameUncheckedCreateWithoutGameInputSchema) ]),
+}).strict();
+
+export const User_GameCreateManyGameInputEnvelopeSchema: z.ZodType<Prisma.User_GameCreateManyGameInputEnvelope> = z.object({
+  data: z.union([ z.lazy(() => User_GameCreateManyGameInputSchema),z.lazy(() => User_GameCreateManyGameInputSchema).array() ]),
+  skipDuplicates: z.boolean().optional()
+}).strict();
+
+export const GamepinUpsertWithoutGameInputSchema: z.ZodType<Prisma.GamepinUpsertWithoutGameInput> = z.object({
+  update: z.union([ z.lazy(() => GamepinUpdateWithoutGameInputSchema),z.lazy(() => GamepinUncheckedUpdateWithoutGameInputSchema) ]),
+  create: z.union([ z.lazy(() => GamepinCreateWithoutGameInputSchema),z.lazy(() => GamepinUncheckedCreateWithoutGameInputSchema) ]),
+}).strict();
+
+export const GamepinUpdateWithoutGameInputSchema: z.ZodType<Prisma.GamepinUpdateWithoutGameInput> = z.object({
+  id: z.union([ z.string(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  createdAt: z.union([ z.coerce.date(),z.lazy(() => DateTimeFieldUpdateOperationsInputSchema) ]).optional(),
+  pin: z.union([ z.string(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+}).strict();
+
+export const GamepinUncheckedUpdateWithoutGameInputSchema: z.ZodType<Prisma.GamepinUncheckedUpdateWithoutGameInput> = z.object({
+  id: z.union([ z.string(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  createdAt: z.union([ z.coerce.date(),z.lazy(() => DateTimeFieldUpdateOperationsInputSchema) ]).optional(),
+  pin: z.union([ z.string(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+}).strict();
+
+export const User_GameUpsertWithWhereUniqueWithoutGameInputSchema: z.ZodType<Prisma.User_GameUpsertWithWhereUniqueWithoutGameInput> = z.object({
+  where: z.lazy(() => User_GameWhereUniqueInputSchema),
+  update: z.union([ z.lazy(() => User_GameUpdateWithoutGameInputSchema),z.lazy(() => User_GameUncheckedUpdateWithoutGameInputSchema) ]),
+  create: z.union([ z.lazy(() => User_GameCreateWithoutGameInputSchema),z.lazy(() => User_GameUncheckedCreateWithoutGameInputSchema) ]),
+}).strict();
+
+export const User_GameUpdateWithWhereUniqueWithoutGameInputSchema: z.ZodType<Prisma.User_GameUpdateWithWhereUniqueWithoutGameInput> = z.object({
+  where: z.lazy(() => User_GameWhereUniqueInputSchema),
+  data: z.union([ z.lazy(() => User_GameUpdateWithoutGameInputSchema),z.lazy(() => User_GameUncheckedUpdateWithoutGameInputSchema) ]),
+}).strict();
+
+export const User_GameUpdateManyWithWhereWithoutGameInputSchema: z.ZodType<Prisma.User_GameUpdateManyWithWhereWithoutGameInput> = z.object({
+  where: z.lazy(() => User_GameScalarWhereInputSchema),
+  data: z.union([ z.lazy(() => User_GameUpdateManyMutationInputSchema),z.lazy(() => User_GameUncheckedUpdateManyWithoutUsersInputSchema) ]),
+}).strict();
+
+export const GameCreateWithoutGamePinInputSchema: z.ZodType<Prisma.GameCreateWithoutGamePinInput> = z.object({
+  id: z.string().optional(),
+  createdAt: z.coerce.date().optional(),
+  updatedAt: z.coerce.date().optional(),
+  state: z.lazy(() => GameStateSchema).optional(),
+  users: z.lazy(() => User_GameCreateNestedManyWithoutGameInputSchema).optional()
+}).strict();
+
+export const GameUncheckedCreateWithoutGamePinInputSchema: z.ZodType<Prisma.GameUncheckedCreateWithoutGamePinInput> = z.object({
+  id: z.string().optional(),
+  createdAt: z.coerce.date().optional(),
+  updatedAt: z.coerce.date().optional(),
+  state: z.lazy(() => GameStateSchema).optional(),
+  users: z.lazy(() => User_GameUncheckedCreateNestedManyWithoutGameInputSchema).optional()
+}).strict();
+
+export const GameCreateOrConnectWithoutGamePinInputSchema: z.ZodType<Prisma.GameCreateOrConnectWithoutGamePinInput> = z.object({
+  where: z.lazy(() => GameWhereUniqueInputSchema),
+  create: z.union([ z.lazy(() => GameCreateWithoutGamePinInputSchema),z.lazy(() => GameUncheckedCreateWithoutGamePinInputSchema) ]),
+}).strict();
+
+export const GameUpsertWithoutGamePinInputSchema: z.ZodType<Prisma.GameUpsertWithoutGamePinInput> = z.object({
+  update: z.union([ z.lazy(() => GameUpdateWithoutGamePinInputSchema),z.lazy(() => GameUncheckedUpdateWithoutGamePinInputSchema) ]),
+  create: z.union([ z.lazy(() => GameCreateWithoutGamePinInputSchema),z.lazy(() => GameUncheckedCreateWithoutGamePinInputSchema) ]),
+}).strict();
+
+export const GameUpdateWithoutGamePinInputSchema: z.ZodType<Prisma.GameUpdateWithoutGamePinInput> = z.object({
+  id: z.union([ z.string(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  createdAt: z.union([ z.coerce.date(),z.lazy(() => DateTimeFieldUpdateOperationsInputSchema) ]).optional(),
+  updatedAt: z.union([ z.coerce.date(),z.lazy(() => DateTimeFieldUpdateOperationsInputSchema) ]).optional(),
+  state: z.union([ z.lazy(() => GameStateSchema),z.lazy(() => EnumGameStateFieldUpdateOperationsInputSchema) ]).optional(),
+  users: z.lazy(() => User_GameUpdateManyWithoutGameNestedInputSchema).optional()
+}).strict();
+
+export const GameUncheckedUpdateWithoutGamePinInputSchema: z.ZodType<Prisma.GameUncheckedUpdateWithoutGamePinInput> = z.object({
+  id: z.union([ z.string(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  createdAt: z.union([ z.coerce.date(),z.lazy(() => DateTimeFieldUpdateOperationsInputSchema) ]).optional(),
+  updatedAt: z.union([ z.coerce.date(),z.lazy(() => DateTimeFieldUpdateOperationsInputSchema) ]).optional(),
+  state: z.union([ z.lazy(() => GameStateSchema),z.lazy(() => EnumGameStateFieldUpdateOperationsInputSchema) ]).optional(),
+  users: z.lazy(() => User_GameUncheckedUpdateManyWithoutGameNestedInputSchema).optional()
+}).strict();
+
+export const MoveCreateWithoutUser_gameInputSchema: z.ZodType<Prisma.MoveCreateWithoutUser_gameInput> = z.object({
+  id: z.string().optional(),
+  createdAt: z.coerce.date().optional(),
+  index: z.number()
+}).strict();
+
+export const MoveUncheckedCreateWithoutUser_gameInputSchema: z.ZodType<Prisma.MoveUncheckedCreateWithoutUser_gameInput> = z.object({
+  id: z.string().optional(),
+  createdAt: z.coerce.date().optional(),
+  index: z.number()
+}).strict();
+
+export const MoveCreateOrConnectWithoutUser_gameInputSchema: z.ZodType<Prisma.MoveCreateOrConnectWithoutUser_gameInput> = z.object({
+  where: z.lazy(() => MoveWhereUniqueInputSchema),
+  create: z.union([ z.lazy(() => MoveCreateWithoutUser_gameInputSchema),z.lazy(() => MoveUncheckedCreateWithoutUser_gameInputSchema) ]),
+}).strict();
+
+export const MoveCreateManyUser_gameInputEnvelopeSchema: z.ZodType<Prisma.MoveCreateManyUser_gameInputEnvelope> = z.object({
+  data: z.union([ z.lazy(() => MoveCreateManyUser_gameInputSchema),z.lazy(() => MoveCreateManyUser_gameInputSchema).array() ]),
+  skipDuplicates: z.boolean().optional()
+}).strict();
+
+export const ChatCreateWithoutUser_gameInputSchema: z.ZodType<Prisma.ChatCreateWithoutUser_gameInput> = z.object({
+  id: z.string().optional(),
+  createdAt: z.coerce.date().optional(),
+  message: z.string().optional().nullable(),
+  event: z.string().optional().nullable()
+}).strict();
+
+export const ChatUncheckedCreateWithoutUser_gameInputSchema: z.ZodType<Prisma.ChatUncheckedCreateWithoutUser_gameInput> = z.object({
+  id: z.string().optional(),
+  createdAt: z.coerce.date().optional(),
+  message: z.string().optional().nullable(),
+  event: z.string().optional().nullable()
+}).strict();
+
+export const ChatCreateOrConnectWithoutUser_gameInputSchema: z.ZodType<Prisma.ChatCreateOrConnectWithoutUser_gameInput> = z.object({
+  where: z.lazy(() => ChatWhereUniqueInputSchema),
+  create: z.union([ z.lazy(() => ChatCreateWithoutUser_gameInputSchema),z.lazy(() => ChatUncheckedCreateWithoutUser_gameInputSchema) ]),
+}).strict();
+
+export const ChatCreateManyUser_gameInputEnvelopeSchema: z.ZodType<Prisma.ChatCreateManyUser_gameInputEnvelope> = z.object({
+  data: z.union([ z.lazy(() => ChatCreateManyUser_gameInputSchema),z.lazy(() => ChatCreateManyUser_gameInputSchema).array() ]),
+  skipDuplicates: z.boolean().optional()
+}).strict();
+
+export const GameCreateWithoutUsersInputSchema: z.ZodType<Prisma.GameCreateWithoutUsersInput> = z.object({
+  id: z.string().optional(),
+  createdAt: z.coerce.date().optional(),
+  updatedAt: z.coerce.date().optional(),
+  state: z.lazy(() => GameStateSchema).optional(),
+  gamePin: z.lazy(() => GamepinCreateNestedOneWithoutGameInputSchema).optional()
+}).strict();
+
+export const GameUncheckedCreateWithoutUsersInputSchema: z.ZodType<Prisma.GameUncheckedCreateWithoutUsersInput> = z.object({
+  id: z.string().optional(),
+  createdAt: z.coerce.date().optional(),
+  updatedAt: z.coerce.date().optional(),
+  state: z.lazy(() => GameStateSchema).optional(),
+  gamePin: z.lazy(() => GamepinUncheckedCreateNestedOneWithoutGameInputSchema).optional()
+}).strict();
+
+export const GameCreateOrConnectWithoutUsersInputSchema: z.ZodType<Prisma.GameCreateOrConnectWithoutUsersInput> = z.object({
+  where: z.lazy(() => GameWhereUniqueInputSchema),
+  create: z.union([ z.lazy(() => GameCreateWithoutUsersInputSchema),z.lazy(() => GameUncheckedCreateWithoutUsersInputSchema) ]),
+}).strict();
+
+export const UserCreateWithoutGamesInputSchema: z.ZodType<Prisma.UserCreateWithoutGamesInput> = z.object({
+  id: z.string().optional(),
+  name: z.string().optional().nullable(),
+  email: z.string().optional().nullable(),
+  emailVerified: z.coerce.date().optional().nullable(),
+  image: z.string().optional().nullable(),
+  createdAt: z.coerce.date().optional(),
+  updatedAt: z.coerce.date().optional(),
+  accounts: z.lazy(() => AccountCreateNestedManyWithoutUserInputSchema).optional(),
+  sessions: z.lazy(() => SessionCreateNestedManyWithoutUserInputSchema).optional()
+}).strict();
+
+export const UserUncheckedCreateWithoutGamesInputSchema: z.ZodType<Prisma.UserUncheckedCreateWithoutGamesInput> = z.object({
+  id: z.string().optional(),
+  name: z.string().optional().nullable(),
+  email: z.string().optional().nullable(),
+  emailVerified: z.coerce.date().optional().nullable(),
+  image: z.string().optional().nullable(),
+  createdAt: z.coerce.date().optional(),
+  updatedAt: z.coerce.date().optional(),
+  accounts: z.lazy(() => AccountUncheckedCreateNestedManyWithoutUserInputSchema).optional(),
+  sessions: z.lazy(() => SessionUncheckedCreateNestedManyWithoutUserInputSchema).optional()
+}).strict();
+
+export const UserCreateOrConnectWithoutGamesInputSchema: z.ZodType<Prisma.UserCreateOrConnectWithoutGamesInput> = z.object({
+  where: z.lazy(() => UserWhereUniqueInputSchema),
+  create: z.union([ z.lazy(() => UserCreateWithoutGamesInputSchema),z.lazy(() => UserUncheckedCreateWithoutGamesInputSchema) ]),
+}).strict();
+
+export const MoveUpsertWithWhereUniqueWithoutUser_gameInputSchema: z.ZodType<Prisma.MoveUpsertWithWhereUniqueWithoutUser_gameInput> = z.object({
+  where: z.lazy(() => MoveWhereUniqueInputSchema),
+  update: z.union([ z.lazy(() => MoveUpdateWithoutUser_gameInputSchema),z.lazy(() => MoveUncheckedUpdateWithoutUser_gameInputSchema) ]),
+  create: z.union([ z.lazy(() => MoveCreateWithoutUser_gameInputSchema),z.lazy(() => MoveUncheckedCreateWithoutUser_gameInputSchema) ]),
+}).strict();
+
+export const MoveUpdateWithWhereUniqueWithoutUser_gameInputSchema: z.ZodType<Prisma.MoveUpdateWithWhereUniqueWithoutUser_gameInput> = z.object({
+  where: z.lazy(() => MoveWhereUniqueInputSchema),
+  data: z.union([ z.lazy(() => MoveUpdateWithoutUser_gameInputSchema),z.lazy(() => MoveUncheckedUpdateWithoutUser_gameInputSchema) ]),
+}).strict();
+
+export const MoveUpdateManyWithWhereWithoutUser_gameInputSchema: z.ZodType<Prisma.MoveUpdateManyWithWhereWithoutUser_gameInput> = z.object({
+  where: z.lazy(() => MoveScalarWhereInputSchema),
+  data: z.union([ z.lazy(() => MoveUpdateManyMutationInputSchema),z.lazy(() => MoveUncheckedUpdateManyWithoutMovesInputSchema) ]),
+}).strict();
+
+export const MoveScalarWhereInputSchema: z.ZodType<Prisma.MoveScalarWhereInput> = z.object({
+  AND: z.union([ z.lazy(() => MoveScalarWhereInputSchema),z.lazy(() => MoveScalarWhereInputSchema).array() ]).optional(),
+  OR: z.lazy(() => MoveScalarWhereInputSchema).array().optional(),
+  NOT: z.union([ z.lazy(() => MoveScalarWhereInputSchema),z.lazy(() => MoveScalarWhereInputSchema).array() ]).optional(),
+  id: z.union([ z.lazy(() => StringFilterSchema),z.string() ]).optional(),
+  createdAt: z.union([ z.lazy(() => DateTimeFilterSchema),z.coerce.date() ]).optional(),
+  index: z.union([ z.lazy(() => IntFilterSchema),z.number() ]).optional(),
+  user_game_id: z.union([ z.lazy(() => StringFilterSchema),z.string() ]).optional(),
+}).strict();
+
+export const ChatUpsertWithWhereUniqueWithoutUser_gameInputSchema: z.ZodType<Prisma.ChatUpsertWithWhereUniqueWithoutUser_gameInput> = z.object({
+  where: z.lazy(() => ChatWhereUniqueInputSchema),
+  update: z.union([ z.lazy(() => ChatUpdateWithoutUser_gameInputSchema),z.lazy(() => ChatUncheckedUpdateWithoutUser_gameInputSchema) ]),
+  create: z.union([ z.lazy(() => ChatCreateWithoutUser_gameInputSchema),z.lazy(() => ChatUncheckedCreateWithoutUser_gameInputSchema) ]),
+}).strict();
+
+export const ChatUpdateWithWhereUniqueWithoutUser_gameInputSchema: z.ZodType<Prisma.ChatUpdateWithWhereUniqueWithoutUser_gameInput> = z.object({
+  where: z.lazy(() => ChatWhereUniqueInputSchema),
+  data: z.union([ z.lazy(() => ChatUpdateWithoutUser_gameInputSchema),z.lazy(() => ChatUncheckedUpdateWithoutUser_gameInputSchema) ]),
+}).strict();
+
+export const ChatUpdateManyWithWhereWithoutUser_gameInputSchema: z.ZodType<Prisma.ChatUpdateManyWithWhereWithoutUser_gameInput> = z.object({
+  where: z.lazy(() => ChatScalarWhereInputSchema),
+  data: z.union([ z.lazy(() => ChatUpdateManyMutationInputSchema),z.lazy(() => ChatUncheckedUpdateManyWithoutChatsInputSchema) ]),
+}).strict();
+
+export const ChatScalarWhereInputSchema: z.ZodType<Prisma.ChatScalarWhereInput> = z.object({
+  AND: z.union([ z.lazy(() => ChatScalarWhereInputSchema),z.lazy(() => ChatScalarWhereInputSchema).array() ]).optional(),
+  OR: z.lazy(() => ChatScalarWhereInputSchema).array().optional(),
+  NOT: z.union([ z.lazy(() => ChatScalarWhereInputSchema),z.lazy(() => ChatScalarWhereInputSchema).array() ]).optional(),
+  id: z.union([ z.lazy(() => StringFilterSchema),z.string() ]).optional(),
+  createdAt: z.union([ z.lazy(() => DateTimeFilterSchema),z.coerce.date() ]).optional(),
+  message: z.union([ z.lazy(() => StringNullableFilterSchema),z.string() ]).optional().nullable(),
+  event: z.union([ z.lazy(() => StringNullableFilterSchema),z.string() ]).optional().nullable(),
+  user_game_id: z.union([ z.lazy(() => StringFilterSchema),z.string() ]).optional(),
+}).strict();
+
+export const GameUpsertWithoutUsersInputSchema: z.ZodType<Prisma.GameUpsertWithoutUsersInput> = z.object({
+  update: z.union([ z.lazy(() => GameUpdateWithoutUsersInputSchema),z.lazy(() => GameUncheckedUpdateWithoutUsersInputSchema) ]),
+  create: z.union([ z.lazy(() => GameCreateWithoutUsersInputSchema),z.lazy(() => GameUncheckedCreateWithoutUsersInputSchema) ]),
+}).strict();
+
+export const GameUpdateWithoutUsersInputSchema: z.ZodType<Prisma.GameUpdateWithoutUsersInput> = z.object({
+  id: z.union([ z.string(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  createdAt: z.union([ z.coerce.date(),z.lazy(() => DateTimeFieldUpdateOperationsInputSchema) ]).optional(),
+  updatedAt: z.union([ z.coerce.date(),z.lazy(() => DateTimeFieldUpdateOperationsInputSchema) ]).optional(),
+  state: z.union([ z.lazy(() => GameStateSchema),z.lazy(() => EnumGameStateFieldUpdateOperationsInputSchema) ]).optional(),
+  gamePin: z.lazy(() => GamepinUpdateOneWithoutGameNestedInputSchema).optional()
+}).strict();
+
+export const GameUncheckedUpdateWithoutUsersInputSchema: z.ZodType<Prisma.GameUncheckedUpdateWithoutUsersInput> = z.object({
+  id: z.union([ z.string(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  createdAt: z.union([ z.coerce.date(),z.lazy(() => DateTimeFieldUpdateOperationsInputSchema) ]).optional(),
+  updatedAt: z.union([ z.coerce.date(),z.lazy(() => DateTimeFieldUpdateOperationsInputSchema) ]).optional(),
+  state: z.union([ z.lazy(() => GameStateSchema),z.lazy(() => EnumGameStateFieldUpdateOperationsInputSchema) ]).optional(),
+  gamePin: z.lazy(() => GamepinUncheckedUpdateOneWithoutGameNestedInputSchema).optional()
+}).strict();
+
+export const UserUpsertWithoutGamesInputSchema: z.ZodType<Prisma.UserUpsertWithoutGamesInput> = z.object({
+  update: z.union([ z.lazy(() => UserUpdateWithoutGamesInputSchema),z.lazy(() => UserUncheckedUpdateWithoutGamesInputSchema) ]),
+  create: z.union([ z.lazy(() => UserCreateWithoutGamesInputSchema),z.lazy(() => UserUncheckedCreateWithoutGamesInputSchema) ]),
+}).strict();
+
+export const UserUpdateWithoutGamesInputSchema: z.ZodType<Prisma.UserUpdateWithoutGamesInput> = z.object({
+  id: z.union([ z.string(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  name: z.union([ z.string(),z.lazy(() => NullableStringFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  email: z.union([ z.string(),z.lazy(() => NullableStringFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  emailVerified: z.union([ z.coerce.date(),z.lazy(() => NullableDateTimeFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  image: z.union([ z.string(),z.lazy(() => NullableStringFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  createdAt: z.union([ z.coerce.date(),z.lazy(() => DateTimeFieldUpdateOperationsInputSchema) ]).optional(),
+  updatedAt: z.union([ z.coerce.date(),z.lazy(() => DateTimeFieldUpdateOperationsInputSchema) ]).optional(),
+  accounts: z.lazy(() => AccountUpdateManyWithoutUserNestedInputSchema).optional(),
+  sessions: z.lazy(() => SessionUpdateManyWithoutUserNestedInputSchema).optional()
+}).strict();
+
+export const UserUncheckedUpdateWithoutGamesInputSchema: z.ZodType<Prisma.UserUncheckedUpdateWithoutGamesInput> = z.object({
+  id: z.union([ z.string(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  name: z.union([ z.string(),z.lazy(() => NullableStringFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  email: z.union([ z.string(),z.lazy(() => NullableStringFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  emailVerified: z.union([ z.coerce.date(),z.lazy(() => NullableDateTimeFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  image: z.union([ z.string(),z.lazy(() => NullableStringFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  createdAt: z.union([ z.coerce.date(),z.lazy(() => DateTimeFieldUpdateOperationsInputSchema) ]).optional(),
+  updatedAt: z.union([ z.coerce.date(),z.lazy(() => DateTimeFieldUpdateOperationsInputSchema) ]).optional(),
+  accounts: z.lazy(() => AccountUncheckedUpdateManyWithoutUserNestedInputSchema).optional(),
+  sessions: z.lazy(() => SessionUncheckedUpdateManyWithoutUserNestedInputSchema).optional()
+}).strict();
+
+export const User_GameCreateWithoutMovesInputSchema: z.ZodType<Prisma.User_GameCreateWithoutMovesInput> = z.object({
+  id: z.string().optional(),
+  createdAt: z.coerce.date().optional(),
+  isOwner: z.boolean(),
+  chats: z.lazy(() => ChatCreateNestedManyWithoutUser_gameInputSchema).optional(),
+  game: z.lazy(() => GameCreateNestedOneWithoutUsersInputSchema),
+  user: z.lazy(() => UserCreateNestedOneWithoutGamesInputSchema)
+}).strict();
+
+export const User_GameUncheckedCreateWithoutMovesInputSchema: z.ZodType<Prisma.User_GameUncheckedCreateWithoutMovesInput> = z.object({
+  id: z.string().optional(),
+  createdAt: z.coerce.date().optional(),
+  gameId: z.string(),
+  userId: z.string(),
+  isOwner: z.boolean(),
+  chats: z.lazy(() => ChatUncheckedCreateNestedManyWithoutUser_gameInputSchema).optional()
+}).strict();
+
+export const User_GameCreateOrConnectWithoutMovesInputSchema: z.ZodType<Prisma.User_GameCreateOrConnectWithoutMovesInput> = z.object({
+  where: z.lazy(() => User_GameWhereUniqueInputSchema),
+  create: z.union([ z.lazy(() => User_GameCreateWithoutMovesInputSchema),z.lazy(() => User_GameUncheckedCreateWithoutMovesInputSchema) ]),
+}).strict();
+
+export const User_GameUpsertWithoutMovesInputSchema: z.ZodType<Prisma.User_GameUpsertWithoutMovesInput> = z.object({
+  update: z.union([ z.lazy(() => User_GameUpdateWithoutMovesInputSchema),z.lazy(() => User_GameUncheckedUpdateWithoutMovesInputSchema) ]),
+  create: z.union([ z.lazy(() => User_GameCreateWithoutMovesInputSchema),z.lazy(() => User_GameUncheckedCreateWithoutMovesInputSchema) ]),
+}).strict();
+
+export const User_GameUpdateWithoutMovesInputSchema: z.ZodType<Prisma.User_GameUpdateWithoutMovesInput> = z.object({
+  id: z.union([ z.string(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  createdAt: z.union([ z.coerce.date(),z.lazy(() => DateTimeFieldUpdateOperationsInputSchema) ]).optional(),
+  isOwner: z.union([ z.boolean(),z.lazy(() => BoolFieldUpdateOperationsInputSchema) ]).optional(),
+  chats: z.lazy(() => ChatUpdateManyWithoutUser_gameNestedInputSchema).optional(),
+  game: z.lazy(() => GameUpdateOneRequiredWithoutUsersNestedInputSchema).optional(),
+  user: z.lazy(() => UserUpdateOneRequiredWithoutGamesNestedInputSchema).optional()
+}).strict();
+
+export const User_GameUncheckedUpdateWithoutMovesInputSchema: z.ZodType<Prisma.User_GameUncheckedUpdateWithoutMovesInput> = z.object({
+  id: z.union([ z.string(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  createdAt: z.union([ z.coerce.date(),z.lazy(() => DateTimeFieldUpdateOperationsInputSchema) ]).optional(),
+  gameId: z.union([ z.string(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  userId: z.union([ z.string(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  isOwner: z.union([ z.boolean(),z.lazy(() => BoolFieldUpdateOperationsInputSchema) ]).optional(),
+  chats: z.lazy(() => ChatUncheckedUpdateManyWithoutUser_gameNestedInputSchema).optional()
+}).strict();
+
+export const User_GameCreateWithoutChatsInputSchema: z.ZodType<Prisma.User_GameCreateWithoutChatsInput> = z.object({
+  id: z.string().optional(),
+  createdAt: z.coerce.date().optional(),
+  isOwner: z.boolean(),
+  moves: z.lazy(() => MoveCreateNestedManyWithoutUser_gameInputSchema).optional(),
+  game: z.lazy(() => GameCreateNestedOneWithoutUsersInputSchema),
+  user: z.lazy(() => UserCreateNestedOneWithoutGamesInputSchema)
+}).strict();
+
+export const User_GameUncheckedCreateWithoutChatsInputSchema: z.ZodType<Prisma.User_GameUncheckedCreateWithoutChatsInput> = z.object({
+  id: z.string().optional(),
+  createdAt: z.coerce.date().optional(),
+  gameId: z.string(),
+  userId: z.string(),
+  isOwner: z.boolean(),
+  moves: z.lazy(() => MoveUncheckedCreateNestedManyWithoutUser_gameInputSchema).optional()
+}).strict();
+
+export const User_GameCreateOrConnectWithoutChatsInputSchema: z.ZodType<Prisma.User_GameCreateOrConnectWithoutChatsInput> = z.object({
+  where: z.lazy(() => User_GameWhereUniqueInputSchema),
+  create: z.union([ z.lazy(() => User_GameCreateWithoutChatsInputSchema),z.lazy(() => User_GameUncheckedCreateWithoutChatsInputSchema) ]),
+}).strict();
+
+export const User_GameUpsertWithoutChatsInputSchema: z.ZodType<Prisma.User_GameUpsertWithoutChatsInput> = z.object({
+  update: z.union([ z.lazy(() => User_GameUpdateWithoutChatsInputSchema),z.lazy(() => User_GameUncheckedUpdateWithoutChatsInputSchema) ]),
+  create: z.union([ z.lazy(() => User_GameCreateWithoutChatsInputSchema),z.lazy(() => User_GameUncheckedCreateWithoutChatsInputSchema) ]),
+}).strict();
+
+export const User_GameUpdateWithoutChatsInputSchema: z.ZodType<Prisma.User_GameUpdateWithoutChatsInput> = z.object({
+  id: z.union([ z.string(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  createdAt: z.union([ z.coerce.date(),z.lazy(() => DateTimeFieldUpdateOperationsInputSchema) ]).optional(),
+  isOwner: z.union([ z.boolean(),z.lazy(() => BoolFieldUpdateOperationsInputSchema) ]).optional(),
+  moves: z.lazy(() => MoveUpdateManyWithoutUser_gameNestedInputSchema).optional(),
+  game: z.lazy(() => GameUpdateOneRequiredWithoutUsersNestedInputSchema).optional(),
+  user: z.lazy(() => UserUpdateOneRequiredWithoutGamesNestedInputSchema).optional()
+}).strict();
+
+export const User_GameUncheckedUpdateWithoutChatsInputSchema: z.ZodType<Prisma.User_GameUncheckedUpdateWithoutChatsInput> = z.object({
+  id: z.union([ z.string(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  createdAt: z.union([ z.coerce.date(),z.lazy(() => DateTimeFieldUpdateOperationsInputSchema) ]).optional(),
+  gameId: z.union([ z.string(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  userId: z.union([ z.string(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  isOwner: z.union([ z.boolean(),z.lazy(() => BoolFieldUpdateOperationsInputSchema) ]).optional(),
+  moves: z.lazy(() => MoveUncheckedUpdateManyWithoutUser_gameNestedInputSchema).optional()
+}).strict();
+
+export const User_GameCreateManyUserInputSchema: z.ZodType<Prisma.User_GameCreateManyUserInput> = z.object({
+  id: z.string().cuid().optional(),
+  createdAt: z.coerce.date().optional(),
+  gameId: z.string(),
+  isOwner: z.boolean()
+}).strict();
+
+export const AccountCreateManyUserInputSchema: z.ZodType<Prisma.AccountCreateManyUserInput> = z.object({
+  id: z.string().cuid().optional(),
+  type: z.string(),
+  provider: z.string(),
+  providerAccountId: z.string(),
+  refresh_token: z.string().optional().nullable(),
+  access_token: z.string().optional().nullable(),
+  expires_at: z.number().int().optional().nullable(),
+  ext_expires_in: z.number().int().optional().nullable(),
+  token_type: z.string().optional().nullable(),
+  scope: z.string().optional().nullable(),
+  id_token: z.string().optional().nullable(),
+  session_state: z.string().optional().nullable(),
+  oauth_token_secret: z.string().optional().nullable(),
+  oauth_token: z.string().optional().nullable()
+}).strict();
+
+export const SessionCreateManyUserInputSchema: z.ZodType<Prisma.SessionCreateManyUserInput> = z.object({
+  id: z.string().cuid().optional(),
+  sessionToken: z.string(),
+  expires: z.coerce.date()
+}).strict();
+
+export const User_GameUpdateWithoutUserInputSchema: z.ZodType<Prisma.User_GameUpdateWithoutUserInput> = z.object({
+  id: z.union([ z.string(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  createdAt: z.union([ z.coerce.date(),z.lazy(() => DateTimeFieldUpdateOperationsInputSchema) ]).optional(),
+  isOwner: z.union([ z.boolean(),z.lazy(() => BoolFieldUpdateOperationsInputSchema) ]).optional(),
+  moves: z.lazy(() => MoveUpdateManyWithoutUser_gameNestedInputSchema).optional(),
+  chats: z.lazy(() => ChatUpdateManyWithoutUser_gameNestedInputSchema).optional(),
+  game: z.lazy(() => GameUpdateOneRequiredWithoutUsersNestedInputSchema).optional()
+}).strict();
+
+export const User_GameUncheckedUpdateWithoutUserInputSchema: z.ZodType<Prisma.User_GameUncheckedUpdateWithoutUserInput> = z.object({
+  id: z.union([ z.string(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  createdAt: z.union([ z.coerce.date(),z.lazy(() => DateTimeFieldUpdateOperationsInputSchema) ]).optional(),
+  gameId: z.union([ z.string(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  isOwner: z.union([ z.boolean(),z.lazy(() => BoolFieldUpdateOperationsInputSchema) ]).optional(),
+  moves: z.lazy(() => MoveUncheckedUpdateManyWithoutUser_gameNestedInputSchema).optional(),
+  chats: z.lazy(() => ChatUncheckedUpdateManyWithoutUser_gameNestedInputSchema).optional()
+}).strict();
+
+export const User_GameUncheckedUpdateManyWithoutGamesInputSchema: z.ZodType<Prisma.User_GameUncheckedUpdateManyWithoutGamesInput> = z.object({
+  id: z.union([ z.string().cuid(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  createdAt: z.union([ z.coerce.date(),z.lazy(() => DateTimeFieldUpdateOperationsInputSchema) ]).optional(),
+  gameId: z.union([ z.string(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  isOwner: z.union([ z.boolean(),z.lazy(() => BoolFieldUpdateOperationsInputSchema) ]).optional(),
+}).strict();
+
+export const AccountUpdateWithoutUserInputSchema: z.ZodType<Prisma.AccountUpdateWithoutUserInput> = z.object({
+  id: z.union([ z.string(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  type: z.union([ z.string(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  provider: z.union([ z.string(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  providerAccountId: z.union([ z.string(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  refresh_token: z.union([ z.string(),z.lazy(() => NullableStringFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  access_token: z.union([ z.string(),z.lazy(() => NullableStringFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  expires_at: z.union([ z.number(),z.lazy(() => NullableIntFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  ext_expires_in: z.union([ z.number(),z.lazy(() => NullableIntFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  token_type: z.union([ z.string(),z.lazy(() => NullableStringFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  scope: z.union([ z.string(),z.lazy(() => NullableStringFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  id_token: z.union([ z.string(),z.lazy(() => NullableStringFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  session_state: z.union([ z.string(),z.lazy(() => NullableStringFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  oauth_token_secret: z.union([ z.string(),z.lazy(() => NullableStringFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  oauth_token: z.union([ z.string(),z.lazy(() => NullableStringFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+}).strict();
+
+export const AccountUncheckedUpdateWithoutUserInputSchema: z.ZodType<Prisma.AccountUncheckedUpdateWithoutUserInput> = z.object({
+  id: z.union([ z.string(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  type: z.union([ z.string(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  provider: z.union([ z.string(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  providerAccountId: z.union([ z.string(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  refresh_token: z.union([ z.string(),z.lazy(() => NullableStringFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  access_token: z.union([ z.string(),z.lazy(() => NullableStringFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  expires_at: z.union([ z.number(),z.lazy(() => NullableIntFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  ext_expires_in: z.union([ z.number(),z.lazy(() => NullableIntFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  token_type: z.union([ z.string(),z.lazy(() => NullableStringFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  scope: z.union([ z.string(),z.lazy(() => NullableStringFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  id_token: z.union([ z.string(),z.lazy(() => NullableStringFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  session_state: z.union([ z.string(),z.lazy(() => NullableStringFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  oauth_token_secret: z.union([ z.string(),z.lazy(() => NullableStringFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  oauth_token: z.union([ z.string(),z.lazy(() => NullableStringFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+}).strict();
+
+export const AccountUncheckedUpdateManyWithoutAccountsInputSchema: z.ZodType<Prisma.AccountUncheckedUpdateManyWithoutAccountsInput> = z.object({
+  id: z.union([ z.string().cuid(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  type: z.union([ z.string(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  provider: z.union([ z.string(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  providerAccountId: z.union([ z.string(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  refresh_token: z.union([ z.string(),z.lazy(() => NullableStringFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  access_token: z.union([ z.string(),z.lazy(() => NullableStringFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  expires_at: z.union([ z.number().int(),z.lazy(() => NullableIntFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  ext_expires_in: z.union([ z.number().int(),z.lazy(() => NullableIntFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  token_type: z.union([ z.string(),z.lazy(() => NullableStringFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  scope: z.union([ z.string(),z.lazy(() => NullableStringFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  id_token: z.union([ z.string(),z.lazy(() => NullableStringFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  session_state: z.union([ z.string(),z.lazy(() => NullableStringFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  oauth_token_secret: z.union([ z.string(),z.lazy(() => NullableStringFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  oauth_token: z.union([ z.string(),z.lazy(() => NullableStringFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+}).strict();
+
+export const SessionUpdateWithoutUserInputSchema: z.ZodType<Prisma.SessionUpdateWithoutUserInput> = z.object({
+  id: z.union([ z.string(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  sessionToken: z.union([ z.string(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  expires: z.union([ z.coerce.date(),z.lazy(() => DateTimeFieldUpdateOperationsInputSchema) ]).optional(),
+}).strict();
+
+export const SessionUncheckedUpdateWithoutUserInputSchema: z.ZodType<Prisma.SessionUncheckedUpdateWithoutUserInput> = z.object({
+  id: z.union([ z.string(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  sessionToken: z.union([ z.string(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  expires: z.union([ z.coerce.date(),z.lazy(() => DateTimeFieldUpdateOperationsInputSchema) ]).optional(),
+}).strict();
+
+export const SessionUncheckedUpdateManyWithoutSessionsInputSchema: z.ZodType<Prisma.SessionUncheckedUpdateManyWithoutSessionsInput> = z.object({
+  id: z.union([ z.string().cuid(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  sessionToken: z.union([ z.string(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  expires: z.union([ z.coerce.date(),z.lazy(() => DateTimeFieldUpdateOperationsInputSchema) ]).optional(),
+}).strict();
+
+export const User_GameCreateManyGameInputSchema: z.ZodType<Prisma.User_GameCreateManyGameInput> = z.object({
+  id: z.string().cuid().optional(),
+  createdAt: z.coerce.date().optional(),
+  userId: z.string(),
+  isOwner: z.boolean()
+}).strict();
+
+export const User_GameUpdateWithoutGameInputSchema: z.ZodType<Prisma.User_GameUpdateWithoutGameInput> = z.object({
+  id: z.union([ z.string(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  createdAt: z.union([ z.coerce.date(),z.lazy(() => DateTimeFieldUpdateOperationsInputSchema) ]).optional(),
+  isOwner: z.union([ z.boolean(),z.lazy(() => BoolFieldUpdateOperationsInputSchema) ]).optional(),
+  moves: z.lazy(() => MoveUpdateManyWithoutUser_gameNestedInputSchema).optional(),
+  chats: z.lazy(() => ChatUpdateManyWithoutUser_gameNestedInputSchema).optional(),
+  user: z.lazy(() => UserUpdateOneRequiredWithoutGamesNestedInputSchema).optional()
+}).strict();
+
+export const User_GameUncheckedUpdateWithoutGameInputSchema: z.ZodType<Prisma.User_GameUncheckedUpdateWithoutGameInput> = z.object({
+  id: z.union([ z.string(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  createdAt: z.union([ z.coerce.date(),z.lazy(() => DateTimeFieldUpdateOperationsInputSchema) ]).optional(),
+  userId: z.union([ z.string(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  isOwner: z.union([ z.boolean(),z.lazy(() => BoolFieldUpdateOperationsInputSchema) ]).optional(),
+  moves: z.lazy(() => MoveUncheckedUpdateManyWithoutUser_gameNestedInputSchema).optional(),
+  chats: z.lazy(() => ChatUncheckedUpdateManyWithoutUser_gameNestedInputSchema).optional()
+}).strict();
+
+export const User_GameUncheckedUpdateManyWithoutUsersInputSchema: z.ZodType<Prisma.User_GameUncheckedUpdateManyWithoutUsersInput> = z.object({
+  id: z.union([ z.string().cuid(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  createdAt: z.union([ z.coerce.date(),z.lazy(() => DateTimeFieldUpdateOperationsInputSchema) ]).optional(),
+  userId: z.union([ z.string(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  isOwner: z.union([ z.boolean(),z.lazy(() => BoolFieldUpdateOperationsInputSchema) ]).optional(),
+}).strict();
+
+export const MoveCreateManyUser_gameInputSchema: z.ZodType<Prisma.MoveCreateManyUser_gameInput> = z.object({
+  id: z.string().cuid().optional(),
+  createdAt: z.coerce.date().optional(),
+  index: z.number().int()
+}).strict();
+
+export const ChatCreateManyUser_gameInputSchema: z.ZodType<Prisma.ChatCreateManyUser_gameInput> = z.object({
+  id: z.string().cuid().optional(),
+  createdAt: z.coerce.date().optional(),
+  message: z.string().optional().nullable(),
+  event: z.string().optional().nullable()
+}).strict();
+
+export const MoveUpdateWithoutUser_gameInputSchema: z.ZodType<Prisma.MoveUpdateWithoutUser_gameInput> = z.object({
+  id: z.union([ z.string(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  createdAt: z.union([ z.coerce.date(),z.lazy(() => DateTimeFieldUpdateOperationsInputSchema) ]).optional(),
+  index: z.union([ z.number(),z.lazy(() => IntFieldUpdateOperationsInputSchema) ]).optional(),
+}).strict();
+
+export const MoveUncheckedUpdateWithoutUser_gameInputSchema: z.ZodType<Prisma.MoveUncheckedUpdateWithoutUser_gameInput> = z.object({
+  id: z.union([ z.string(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  createdAt: z.union([ z.coerce.date(),z.lazy(() => DateTimeFieldUpdateOperationsInputSchema) ]).optional(),
+  index: z.union([ z.number(),z.lazy(() => IntFieldUpdateOperationsInputSchema) ]).optional(),
+}).strict();
+
+export const MoveUncheckedUpdateManyWithoutMovesInputSchema: z.ZodType<Prisma.MoveUncheckedUpdateManyWithoutMovesInput> = z.object({
+  id: z.union([ z.string().cuid(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  createdAt: z.union([ z.coerce.date(),z.lazy(() => DateTimeFieldUpdateOperationsInputSchema) ]).optional(),
+  index: z.union([ z.number().int(),z.lazy(() => IntFieldUpdateOperationsInputSchema) ]).optional(),
+}).strict();
+
+export const ChatUpdateWithoutUser_gameInputSchema: z.ZodType<Prisma.ChatUpdateWithoutUser_gameInput> = z.object({
+  id: z.union([ z.string(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  createdAt: z.union([ z.coerce.date(),z.lazy(() => DateTimeFieldUpdateOperationsInputSchema) ]).optional(),
+  message: z.union([ z.string(),z.lazy(() => NullableStringFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  event: z.union([ z.string(),z.lazy(() => NullableStringFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+}).strict();
+
+export const ChatUncheckedUpdateWithoutUser_gameInputSchema: z.ZodType<Prisma.ChatUncheckedUpdateWithoutUser_gameInput> = z.object({
+  id: z.union([ z.string(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  createdAt: z.union([ z.coerce.date(),z.lazy(() => DateTimeFieldUpdateOperationsInputSchema) ]).optional(),
+  message: z.union([ z.string(),z.lazy(() => NullableStringFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  event: z.union([ z.string(),z.lazy(() => NullableStringFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+}).strict();
+
+export const ChatUncheckedUpdateManyWithoutChatsInputSchema: z.ZodType<Prisma.ChatUncheckedUpdateManyWithoutChatsInput> = z.object({
+  id: z.union([ z.string().cuid(),z.lazy(() => StringFieldUpdateOperationsInputSchema) ]).optional(),
+  createdAt: z.union([ z.coerce.date(),z.lazy(() => DateTimeFieldUpdateOperationsInputSchema) ]).optional(),
+  message: z.union([ z.string(),z.lazy(() => NullableStringFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+  event: z.union([ z.string(),z.lazy(() => NullableStringFieldUpdateOperationsInputSchema) ]).optional().nullable(),
+}).strict();
+
+/////////////////////////////////////////
+// ARGS
+/////////////////////////////////////////
+
+export const AccountFindFirstArgsSchema: z.ZodType<Prisma.AccountFindFirstArgs> = z.object({
+  select: AccountSelectSchema.optional(),
+  include: AccountIncludeSchema.optional(),
+  where: AccountWhereInputSchema.optional(),
+  orderBy: z.union([ AccountOrderByWithRelationInputSchema.array(),AccountOrderByWithRelationInputSchema ]).optional(),
+  cursor: AccountWhereUniqueInputSchema.optional(),
+  take: z.number().optional(),
+  skip: z.number().optional(),
+  distinct: AccountScalarFieldEnumSchema.array().optional(),
+}).strict()
+
+export const AccountFindFirstOrThrowArgsSchema: z.ZodType<Prisma.AccountFindFirstOrThrowArgs> = z.object({
+  select: AccountSelectSchema.optional(),
+  include: AccountIncludeSchema.optional(),
+  where: AccountWhereInputSchema.optional(),
+  orderBy: z.union([ AccountOrderByWithRelationInputSchema.array(),AccountOrderByWithRelationInputSchema ]).optional(),
+  cursor: AccountWhereUniqueInputSchema.optional(),
+  take: z.number().optional(),
+  skip: z.number().optional(),
+  distinct: AccountScalarFieldEnumSchema.array().optional(),
+}).strict()
+
+export const AccountFindManyArgsSchema: z.ZodType<Prisma.AccountFindManyArgs> = z.object({
+  select: AccountSelectSchema.optional(),
+  include: AccountIncludeSchema.optional(),
+  where: AccountWhereInputSchema.optional(),
+  orderBy: z.union([ AccountOrderByWithRelationInputSchema.array(),AccountOrderByWithRelationInputSchema ]).optional(),
+  cursor: AccountWhereUniqueInputSchema.optional(),
+  take: z.number().optional(),
+  skip: z.number().optional(),
+  distinct: AccountScalarFieldEnumSchema.array().optional(),
+}).strict()
+
+export const AccountAggregateArgsSchema: z.ZodType<Prisma.AccountAggregateArgs> = z.object({
+  where: AccountWhereInputSchema.optional(),
+  orderBy: z.union([ AccountOrderByWithRelationInputSchema.array(),AccountOrderByWithRelationInputSchema ]).optional(),
+  cursor: AccountWhereUniqueInputSchema.optional(),
+  take: z.number().optional(),
+  skip: z.number().optional(),
+}).strict()
+
+export const AccountGroupByArgsSchema: z.ZodType<Prisma.AccountGroupByArgs> = z.object({
+  where: AccountWhereInputSchema.optional(),
+  orderBy: z.union([ AccountOrderByWithAggregationInputSchema.array(),AccountOrderByWithAggregationInputSchema ]).optional(),
+  by: AccountScalarFieldEnumSchema.array(),
+  having: AccountScalarWhereWithAggregatesInputSchema.optional(),
+  take: z.number().optional(),
+  skip: z.number().optional(),
+}).strict()
+
+export const AccountFindUniqueArgsSchema: z.ZodType<Prisma.AccountFindUniqueArgs> = z.object({
+  select: AccountSelectSchema.optional(),
+  include: AccountIncludeSchema.optional(),
+  where: AccountWhereUniqueInputSchema,
+}).strict()
+
+export const AccountFindUniqueOrThrowArgsSchema: z.ZodType<Prisma.AccountFindUniqueOrThrowArgs> = z.object({
+  select: AccountSelectSchema.optional(),
+  include: AccountIncludeSchema.optional(),
+  where: AccountWhereUniqueInputSchema,
+}).strict()
+
+export const SessionFindFirstArgsSchema: z.ZodType<Prisma.SessionFindFirstArgs> = z.object({
+  select: SessionSelectSchema.optional(),
+  include: SessionIncludeSchema.optional(),
+  where: SessionWhereInputSchema.optional(),
+  orderBy: z.union([ SessionOrderByWithRelationInputSchema.array(),SessionOrderByWithRelationInputSchema ]).optional(),
+  cursor: SessionWhereUniqueInputSchema.optional(),
+  take: z.number().optional(),
+  skip: z.number().optional(),
+  distinct: SessionScalarFieldEnumSchema.array().optional(),
+}).strict()
+
+export const SessionFindFirstOrThrowArgsSchema: z.ZodType<Prisma.SessionFindFirstOrThrowArgs> = z.object({
+  select: SessionSelectSchema.optional(),
+  include: SessionIncludeSchema.optional(),
+  where: SessionWhereInputSchema.optional(),
+  orderBy: z.union([ SessionOrderByWithRelationInputSchema.array(),SessionOrderByWithRelationInputSchema ]).optional(),
+  cursor: SessionWhereUniqueInputSchema.optional(),
+  take: z.number().optional(),
+  skip: z.number().optional(),
+  distinct: SessionScalarFieldEnumSchema.array().optional(),
+}).strict()
+
+export const SessionFindManyArgsSchema: z.ZodType<Prisma.SessionFindManyArgs> = z.object({
+  select: SessionSelectSchema.optional(),
+  include: SessionIncludeSchema.optional(),
+  where: SessionWhereInputSchema.optional(),
+  orderBy: z.union([ SessionOrderByWithRelationInputSchema.array(),SessionOrderByWithRelationInputSchema ]).optional(),
+  cursor: SessionWhereUniqueInputSchema.optional(),
+  take: z.number().optional(),
+  skip: z.number().optional(),
+  distinct: SessionScalarFieldEnumSchema.array().optional(),
+}).strict()
+
+export const SessionAggregateArgsSchema: z.ZodType<Prisma.SessionAggregateArgs> = z.object({
+  where: SessionWhereInputSchema.optional(),
+  orderBy: z.union([ SessionOrderByWithRelationInputSchema.array(),SessionOrderByWithRelationInputSchema ]).optional(),
+  cursor: SessionWhereUniqueInputSchema.optional(),
+  take: z.number().optional(),
+  skip: z.number().optional(),
+}).strict()
+
+export const SessionGroupByArgsSchema: z.ZodType<Prisma.SessionGroupByArgs> = z.object({
+  where: SessionWhereInputSchema.optional(),
+  orderBy: z.union([ SessionOrderByWithAggregationInputSchema.array(),SessionOrderByWithAggregationInputSchema ]).optional(),
+  by: SessionScalarFieldEnumSchema.array(),
+  having: SessionScalarWhereWithAggregatesInputSchema.optional(),
+  take: z.number().optional(),
+  skip: z.number().optional(),
+}).strict()
+
+export const SessionFindUniqueArgsSchema: z.ZodType<Prisma.SessionFindUniqueArgs> = z.object({
+  select: SessionSelectSchema.optional(),
+  include: SessionIncludeSchema.optional(),
+  where: SessionWhereUniqueInputSchema,
+}).strict()
+
+export const SessionFindUniqueOrThrowArgsSchema: z.ZodType<Prisma.SessionFindUniqueOrThrowArgs> = z.object({
+  select: SessionSelectSchema.optional(),
+  include: SessionIncludeSchema.optional(),
+  where: SessionWhereUniqueInputSchema,
+}).strict()
+
+export const UserFindFirstArgsSchema: z.ZodType<Prisma.UserFindFirstArgs> = z.object({
+  select: UserSelectSchema.optional(),
+  include: UserIncludeSchema.optional(),
+  where: UserWhereInputSchema.optional(),
+  orderBy: z.union([ UserOrderByWithRelationInputSchema.array(),UserOrderByWithRelationInputSchema ]).optional(),
+  cursor: UserWhereUniqueInputSchema.optional(),
+  take: z.number().optional(),
+  skip: z.number().optional(),
+  distinct: UserScalarFieldEnumSchema.array().optional(),
+}).strict()
+
+export const UserFindFirstOrThrowArgsSchema: z.ZodType<Prisma.UserFindFirstOrThrowArgs> = z.object({
+  select: UserSelectSchema.optional(),
+  include: UserIncludeSchema.optional(),
+  where: UserWhereInputSchema.optional(),
+  orderBy: z.union([ UserOrderByWithRelationInputSchema.array(),UserOrderByWithRelationInputSchema ]).optional(),
+  cursor: UserWhereUniqueInputSchema.optional(),
+  take: z.number().optional(),
+  skip: z.number().optional(),
+  distinct: UserScalarFieldEnumSchema.array().optional(),
+}).strict()
+
+export const UserFindManyArgsSchema: z.ZodType<Prisma.UserFindManyArgs> = z.object({
+  select: UserSelectSchema.optional(),
+  include: UserIncludeSchema.optional(),
+  where: UserWhereInputSchema.optional(),
+  orderBy: z.union([ UserOrderByWithRelationInputSchema.array(),UserOrderByWithRelationInputSchema ]).optional(),
+  cursor: UserWhereUniqueInputSchema.optional(),
+  take: z.number().optional(),
+  skip: z.number().optional(),
+  distinct: UserScalarFieldEnumSchema.array().optional(),
+}).strict()
+
+export const UserAggregateArgsSchema: z.ZodType<Prisma.UserAggregateArgs> = z.object({
+  where: UserWhereInputSchema.optional(),
+  orderBy: z.union([ UserOrderByWithRelationInputSchema.array(),UserOrderByWithRelationInputSchema ]).optional(),
+  cursor: UserWhereUniqueInputSchema.optional(),
+  take: z.number().optional(),
+  skip: z.number().optional(),
+}).strict()
+
+export const UserGroupByArgsSchema: z.ZodType<Prisma.UserGroupByArgs> = z.object({
+  where: UserWhereInputSchema.optional(),
+  orderBy: z.union([ UserOrderByWithAggregationInputSchema.array(),UserOrderByWithAggregationInputSchema ]).optional(),
+  by: UserScalarFieldEnumSchema.array(),
+  having: UserScalarWhereWithAggregatesInputSchema.optional(),
+  take: z.number().optional(),
+  skip: z.number().optional(),
+}).strict()
+
+export const UserFindUniqueArgsSchema: z.ZodType<Prisma.UserFindUniqueArgs> = z.object({
+  select: UserSelectSchema.optional(),
+  include: UserIncludeSchema.optional(),
+  where: UserWhereUniqueInputSchema,
+}).strict()
+
+export const UserFindUniqueOrThrowArgsSchema: z.ZodType<Prisma.UserFindUniqueOrThrowArgs> = z.object({
+  select: UserSelectSchema.optional(),
+  include: UserIncludeSchema.optional(),
+  where: UserWhereUniqueInputSchema,
+}).strict()
+
+export const VerificationTokenFindFirstArgsSchema: z.ZodType<Prisma.VerificationTokenFindFirstArgs> = z.object({
+  select: VerificationTokenSelectSchema.optional(),
+  where: VerificationTokenWhereInputSchema.optional(),
+  orderBy: z.union([ VerificationTokenOrderByWithRelationInputSchema.array(),VerificationTokenOrderByWithRelationInputSchema ]).optional(),
+  cursor: VerificationTokenWhereUniqueInputSchema.optional(),
+  take: z.number().optional(),
+  skip: z.number().optional(),
+  distinct: VerificationTokenScalarFieldEnumSchema.array().optional(),
+}).strict()
+
+export const VerificationTokenFindFirstOrThrowArgsSchema: z.ZodType<Prisma.VerificationTokenFindFirstOrThrowArgs> = z.object({
+  select: VerificationTokenSelectSchema.optional(),
+  where: VerificationTokenWhereInputSchema.optional(),
+  orderBy: z.union([ VerificationTokenOrderByWithRelationInputSchema.array(),VerificationTokenOrderByWithRelationInputSchema ]).optional(),
+  cursor: VerificationTokenWhereUniqueInputSchema.optional(),
+  take: z.number().optional(),
+  skip: z.number().optional(),
+  distinct: VerificationTokenScalarFieldEnumSchema.array().optional(),
+}).strict()
+
+export const VerificationTokenFindManyArgsSchema: z.ZodType<Prisma.VerificationTokenFindManyArgs> = z.object({
+  select: VerificationTokenSelectSchema.optional(),
+  where: VerificationTokenWhereInputSchema.optional(),
+  orderBy: z.union([ VerificationTokenOrderByWithRelationInputSchema.array(),VerificationTokenOrderByWithRelationInputSchema ]).optional(),
+  cursor: VerificationTokenWhereUniqueInputSchema.optional(),
+  take: z.number().optional(),
+  skip: z.number().optional(),
+  distinct: VerificationTokenScalarFieldEnumSchema.array().optional(),
+}).strict()
+
+export const VerificationTokenAggregateArgsSchema: z.ZodType<Prisma.VerificationTokenAggregateArgs> = z.object({
+  where: VerificationTokenWhereInputSchema.optional(),
+  orderBy: z.union([ VerificationTokenOrderByWithRelationInputSchema.array(),VerificationTokenOrderByWithRelationInputSchema ]).optional(),
+  cursor: VerificationTokenWhereUniqueInputSchema.optional(),
+  take: z.number().optional(),
+  skip: z.number().optional(),
+}).strict()
+
+export const VerificationTokenGroupByArgsSchema: z.ZodType<Prisma.VerificationTokenGroupByArgs> = z.object({
+  where: VerificationTokenWhereInputSchema.optional(),
+  orderBy: z.union([ VerificationTokenOrderByWithAggregationInputSchema.array(),VerificationTokenOrderByWithAggregationInputSchema ]).optional(),
+  by: VerificationTokenScalarFieldEnumSchema.array(),
+  having: VerificationTokenScalarWhereWithAggregatesInputSchema.optional(),
+  take: z.number().optional(),
+  skip: z.number().optional(),
+}).strict()
+
+export const VerificationTokenFindUniqueArgsSchema: z.ZodType<Prisma.VerificationTokenFindUniqueArgs> = z.object({
+  select: VerificationTokenSelectSchema.optional(),
+  where: VerificationTokenWhereUniqueInputSchema,
+}).strict()
+
+export const VerificationTokenFindUniqueOrThrowArgsSchema: z.ZodType<Prisma.VerificationTokenFindUniqueOrThrowArgs> = z.object({
+  select: VerificationTokenSelectSchema.optional(),
+  where: VerificationTokenWhereUniqueInputSchema,
+}).strict()
+
+export const GameFindFirstArgsSchema: z.ZodType<Prisma.GameFindFirstArgs> = z.object({
+  select: GameSelectSchema.optional(),
+  include: GameIncludeSchema.optional(),
+  where: GameWhereInputSchema.optional(),
+  orderBy: z.union([ GameOrderByWithRelationInputSchema.array(),GameOrderByWithRelationInputSchema ]).optional(),
+  cursor: GameWhereUniqueInputSchema.optional(),
+  take: z.number().optional(),
+  skip: z.number().optional(),
+  distinct: GameScalarFieldEnumSchema.array().optional(),
+}).strict()
+
+export const GameFindFirstOrThrowArgsSchema: z.ZodType<Prisma.GameFindFirstOrThrowArgs> = z.object({
+  select: GameSelectSchema.optional(),
+  include: GameIncludeSchema.optional(),
+  where: GameWhereInputSchema.optional(),
+  orderBy: z.union([ GameOrderByWithRelationInputSchema.array(),GameOrderByWithRelationInputSchema ]).optional(),
+  cursor: GameWhereUniqueInputSchema.optional(),
+  take: z.number().optional(),
+  skip: z.number().optional(),
+  distinct: GameScalarFieldEnumSchema.array().optional(),
+}).strict()
+
+export const GameFindManyArgsSchema: z.ZodType<Prisma.GameFindManyArgs> = z.object({
+  select: GameSelectSchema.optional(),
+  include: GameIncludeSchema.optional(),
+  where: GameWhereInputSchema.optional(),
+  orderBy: z.union([ GameOrderByWithRelationInputSchema.array(),GameOrderByWithRelationInputSchema ]).optional(),
+  cursor: GameWhereUniqueInputSchema.optional(),
+  take: z.number().optional(),
+  skip: z.number().optional(),
+  distinct: GameScalarFieldEnumSchema.array().optional(),
+}).strict()
+
+export const GameAggregateArgsSchema: z.ZodType<Prisma.GameAggregateArgs> = z.object({
+  where: GameWhereInputSchema.optional(),
+  orderBy: z.union([ GameOrderByWithRelationInputSchema.array(),GameOrderByWithRelationInputSchema ]).optional(),
+  cursor: GameWhereUniqueInputSchema.optional(),
+  take: z.number().optional(),
+  skip: z.number().optional(),
+}).strict()
+
+export const GameGroupByArgsSchema: z.ZodType<Prisma.GameGroupByArgs> = z.object({
+  where: GameWhereInputSchema.optional(),
+  orderBy: z.union([ GameOrderByWithAggregationInputSchema.array(),GameOrderByWithAggregationInputSchema ]).optional(),
+  by: GameScalarFieldEnumSchema.array(),
+  having: GameScalarWhereWithAggregatesInputSchema.optional(),
+  take: z.number().optional(),
+  skip: z.number().optional(),
+}).strict()
+
+export const GameFindUniqueArgsSchema: z.ZodType<Prisma.GameFindUniqueArgs> = z.object({
+  select: GameSelectSchema.optional(),
+  include: GameIncludeSchema.optional(),
+  where: GameWhereUniqueInputSchema,
+}).strict()
+
+export const GameFindUniqueOrThrowArgsSchema: z.ZodType<Prisma.GameFindUniqueOrThrowArgs> = z.object({
+  select: GameSelectSchema.optional(),
+  include: GameIncludeSchema.optional(),
+  where: GameWhereUniqueInputSchema,
+}).strict()
+
+export const GamepinFindFirstArgsSchema: z.ZodType<Prisma.GamepinFindFirstArgs> = z.object({
+  select: GamepinSelectSchema.optional(),
+  include: GamepinIncludeSchema.optional(),
+  where: GamepinWhereInputSchema.optional(),
+  orderBy: z.union([ GamepinOrderByWithRelationInputSchema.array(),GamepinOrderByWithRelationInputSchema ]).optional(),
+  cursor: GamepinWhereUniqueInputSchema.optional(),
+  take: z.number().optional(),
+  skip: z.number().optional(),
+  distinct: GamepinScalarFieldEnumSchema.array().optional(),
+}).strict()
+
+export const GamepinFindFirstOrThrowArgsSchema: z.ZodType<Prisma.GamepinFindFirstOrThrowArgs> = z.object({
+  select: GamepinSelectSchema.optional(),
+  include: GamepinIncludeSchema.optional(),
+  where: GamepinWhereInputSchema.optional(),
+  orderBy: z.union([ GamepinOrderByWithRelationInputSchema.array(),GamepinOrderByWithRelationInputSchema ]).optional(),
+  cursor: GamepinWhereUniqueInputSchema.optional(),
+  take: z.number().optional(),
+  skip: z.number().optional(),
+  distinct: GamepinScalarFieldEnumSchema.array().optional(),
+}).strict()
+
+export const GamepinFindManyArgsSchema: z.ZodType<Prisma.GamepinFindManyArgs> = z.object({
+  select: GamepinSelectSchema.optional(),
+  include: GamepinIncludeSchema.optional(),
+  where: GamepinWhereInputSchema.optional(),
+  orderBy: z.union([ GamepinOrderByWithRelationInputSchema.array(),GamepinOrderByWithRelationInputSchema ]).optional(),
+  cursor: GamepinWhereUniqueInputSchema.optional(),
+  take: z.number().optional(),
+  skip: z.number().optional(),
+  distinct: GamepinScalarFieldEnumSchema.array().optional(),
+}).strict()
+
+export const GamepinAggregateArgsSchema: z.ZodType<Prisma.GamepinAggregateArgs> = z.object({
+  where: GamepinWhereInputSchema.optional(),
+  orderBy: z.union([ GamepinOrderByWithRelationInputSchema.array(),GamepinOrderByWithRelationInputSchema ]).optional(),
+  cursor: GamepinWhereUniqueInputSchema.optional(),
+  take: z.number().optional(),
+  skip: z.number().optional(),
+}).strict()
+
+export const GamepinGroupByArgsSchema: z.ZodType<Prisma.GamepinGroupByArgs> = z.object({
+  where: GamepinWhereInputSchema.optional(),
+  orderBy: z.union([ GamepinOrderByWithAggregationInputSchema.array(),GamepinOrderByWithAggregationInputSchema ]).optional(),
+  by: GamepinScalarFieldEnumSchema.array(),
+  having: GamepinScalarWhereWithAggregatesInputSchema.optional(),
+  take: z.number().optional(),
+  skip: z.number().optional(),
+}).strict()
+
+export const GamepinFindUniqueArgsSchema: z.ZodType<Prisma.GamepinFindUniqueArgs> = z.object({
+  select: GamepinSelectSchema.optional(),
+  include: GamepinIncludeSchema.optional(),
+  where: GamepinWhereUniqueInputSchema,
+}).strict()
+
+export const GamepinFindUniqueOrThrowArgsSchema: z.ZodType<Prisma.GamepinFindUniqueOrThrowArgs> = z.object({
+  select: GamepinSelectSchema.optional(),
+  include: GamepinIncludeSchema.optional(),
+  where: GamepinWhereUniqueInputSchema,
+}).strict()
+
+export const User_GameFindFirstArgsSchema: z.ZodType<Prisma.User_GameFindFirstArgs> = z.object({
+  select: User_GameSelectSchema.optional(),
+  include: User_GameIncludeSchema.optional(),
+  where: User_GameWhereInputSchema.optional(),
+  orderBy: z.union([ User_GameOrderByWithRelationInputSchema.array(),User_GameOrderByWithRelationInputSchema ]).optional(),
+  cursor: User_GameWhereUniqueInputSchema.optional(),
+  take: z.number().optional(),
+  skip: z.number().optional(),
+  distinct: User_GameScalarFieldEnumSchema.array().optional(),
+}).strict()
+
+export const User_GameFindFirstOrThrowArgsSchema: z.ZodType<Prisma.User_GameFindFirstOrThrowArgs> = z.object({
+  select: User_GameSelectSchema.optional(),
+  include: User_GameIncludeSchema.optional(),
+  where: User_GameWhereInputSchema.optional(),
+  orderBy: z.union([ User_GameOrderByWithRelationInputSchema.array(),User_GameOrderByWithRelationInputSchema ]).optional(),
+  cursor: User_GameWhereUniqueInputSchema.optional(),
+  take: z.number().optional(),
+  skip: z.number().optional(),
+  distinct: User_GameScalarFieldEnumSchema.array().optional(),
+}).strict()
+
+export const User_GameFindManyArgsSchema: z.ZodType<Prisma.User_GameFindManyArgs> = z.object({
+  select: User_GameSelectSchema.optional(),
+  include: User_GameIncludeSchema.optional(),
+  where: User_GameWhereInputSchema.optional(),
+  orderBy: z.union([ User_GameOrderByWithRelationInputSchema.array(),User_GameOrderByWithRelationInputSchema ]).optional(),
+  cursor: User_GameWhereUniqueInputSchema.optional(),
+  take: z.number().optional(),
+  skip: z.number().optional(),
+  distinct: User_GameScalarFieldEnumSchema.array().optional(),
+}).strict()
+
+export const User_GameAggregateArgsSchema: z.ZodType<Prisma.User_GameAggregateArgs> = z.object({
+  where: User_GameWhereInputSchema.optional(),
+  orderBy: z.union([ User_GameOrderByWithRelationInputSchema.array(),User_GameOrderByWithRelationInputSchema ]).optional(),
+  cursor: User_GameWhereUniqueInputSchema.optional(),
+  take: z.number().optional(),
+  skip: z.number().optional(),
+}).strict()
+
+export const User_GameGroupByArgsSchema: z.ZodType<Prisma.User_GameGroupByArgs> = z.object({
+  where: User_GameWhereInputSchema.optional(),
+  orderBy: z.union([ User_GameOrderByWithAggregationInputSchema.array(),User_GameOrderByWithAggregationInputSchema ]).optional(),
+  by: User_GameScalarFieldEnumSchema.array(),
+  having: User_GameScalarWhereWithAggregatesInputSchema.optional(),
+  take: z.number().optional(),
+  skip: z.number().optional(),
+}).strict()
+
+export const User_GameFindUniqueArgsSchema: z.ZodType<Prisma.User_GameFindUniqueArgs> = z.object({
+  select: User_GameSelectSchema.optional(),
+  include: User_GameIncludeSchema.optional(),
+  where: User_GameWhereUniqueInputSchema,
+}).strict()
+
+export const User_GameFindUniqueOrThrowArgsSchema: z.ZodType<Prisma.User_GameFindUniqueOrThrowArgs> = z.object({
+  select: User_GameSelectSchema.optional(),
+  include: User_GameIncludeSchema.optional(),
+  where: User_GameWhereUniqueInputSchema,
+}).strict()
+
+export const MoveFindFirstArgsSchema: z.ZodType<Prisma.MoveFindFirstArgs> = z.object({
+  select: MoveSelectSchema.optional(),
+  include: MoveIncludeSchema.optional(),
+  where: MoveWhereInputSchema.optional(),
+  orderBy: z.union([ MoveOrderByWithRelationInputSchema.array(),MoveOrderByWithRelationInputSchema ]).optional(),
+  cursor: MoveWhereUniqueInputSchema.optional(),
+  take: z.number().optional(),
+  skip: z.number().optional(),
+  distinct: MoveScalarFieldEnumSchema.array().optional(),
+}).strict()
+
+export const MoveFindFirstOrThrowArgsSchema: z.ZodType<Prisma.MoveFindFirstOrThrowArgs> = z.object({
+  select: MoveSelectSchema.optional(),
+  include: MoveIncludeSchema.optional(),
+  where: MoveWhereInputSchema.optional(),
+  orderBy: z.union([ MoveOrderByWithRelationInputSchema.array(),MoveOrderByWithRelationInputSchema ]).optional(),
+  cursor: MoveWhereUniqueInputSchema.optional(),
+  take: z.number().optional(),
+  skip: z.number().optional(),
+  distinct: MoveScalarFieldEnumSchema.array().optional(),
+}).strict()
+
+export const MoveFindManyArgsSchema: z.ZodType<Prisma.MoveFindManyArgs> = z.object({
+  select: MoveSelectSchema.optional(),
+  include: MoveIncludeSchema.optional(),
+  where: MoveWhereInputSchema.optional(),
+  orderBy: z.union([ MoveOrderByWithRelationInputSchema.array(),MoveOrderByWithRelationInputSchema ]).optional(),
+  cursor: MoveWhereUniqueInputSchema.optional(),
+  take: z.number().optional(),
+  skip: z.number().optional(),
+  distinct: MoveScalarFieldEnumSchema.array().optional(),
+}).strict()
+
+export const MoveAggregateArgsSchema: z.ZodType<Prisma.MoveAggregateArgs> = z.object({
+  where: MoveWhereInputSchema.optional(),
+  orderBy: z.union([ MoveOrderByWithRelationInputSchema.array(),MoveOrderByWithRelationInputSchema ]).optional(),
+  cursor: MoveWhereUniqueInputSchema.optional(),
+  take: z.number().optional(),
+  skip: z.number().optional(),
+}).strict()
+
+export const MoveGroupByArgsSchema: z.ZodType<Prisma.MoveGroupByArgs> = z.object({
+  where: MoveWhereInputSchema.optional(),
+  orderBy: z.union([ MoveOrderByWithAggregationInputSchema.array(),MoveOrderByWithAggregationInputSchema ]).optional(),
+  by: MoveScalarFieldEnumSchema.array(),
+  having: MoveScalarWhereWithAggregatesInputSchema.optional(),
+  take: z.number().optional(),
+  skip: z.number().optional(),
+}).strict()
+
+export const MoveFindUniqueArgsSchema: z.ZodType<Prisma.MoveFindUniqueArgs> = z.object({
+  select: MoveSelectSchema.optional(),
+  include: MoveIncludeSchema.optional(),
+  where: MoveWhereUniqueInputSchema,
+}).strict()
+
+export const MoveFindUniqueOrThrowArgsSchema: z.ZodType<Prisma.MoveFindUniqueOrThrowArgs> = z.object({
+  select: MoveSelectSchema.optional(),
+  include: MoveIncludeSchema.optional(),
+  where: MoveWhereUniqueInputSchema,
+}).strict()
+
+export const ChatFindFirstArgsSchema: z.ZodType<Prisma.ChatFindFirstArgs> = z.object({
+  select: ChatSelectSchema.optional(),
+  include: ChatIncludeSchema.optional(),
+  where: ChatWhereInputSchema.optional(),
+  orderBy: z.union([ ChatOrderByWithRelationInputSchema.array(),ChatOrderByWithRelationInputSchema ]).optional(),
+  cursor: ChatWhereUniqueInputSchema.optional(),
+  take: z.number().optional(),
+  skip: z.number().optional(),
+  distinct: ChatScalarFieldEnumSchema.array().optional(),
+}).strict()
+
+export const ChatFindFirstOrThrowArgsSchema: z.ZodType<Prisma.ChatFindFirstOrThrowArgs> = z.object({
+  select: ChatSelectSchema.optional(),
+  include: ChatIncludeSchema.optional(),
+  where: ChatWhereInputSchema.optional(),
+  orderBy: z.union([ ChatOrderByWithRelationInputSchema.array(),ChatOrderByWithRelationInputSchema ]).optional(),
+  cursor: ChatWhereUniqueInputSchema.optional(),
+  take: z.number().optional(),
+  skip: z.number().optional(),
+  distinct: ChatScalarFieldEnumSchema.array().optional(),
+}).strict()
+
+export const ChatFindManyArgsSchema: z.ZodType<Prisma.ChatFindManyArgs> = z.object({
+  select: ChatSelectSchema.optional(),
+  include: ChatIncludeSchema.optional(),
+  where: ChatWhereInputSchema.optional(),
+  orderBy: z.union([ ChatOrderByWithRelationInputSchema.array(),ChatOrderByWithRelationInputSchema ]).optional(),
+  cursor: ChatWhereUniqueInputSchema.optional(),
+  take: z.number().optional(),
+  skip: z.number().optional(),
+  distinct: ChatScalarFieldEnumSchema.array().optional(),
+}).strict()
+
+export const ChatAggregateArgsSchema: z.ZodType<Prisma.ChatAggregateArgs> = z.object({
+  where: ChatWhereInputSchema.optional(),
+  orderBy: z.union([ ChatOrderByWithRelationInputSchema.array(),ChatOrderByWithRelationInputSchema ]).optional(),
+  cursor: ChatWhereUniqueInputSchema.optional(),
+  take: z.number().optional(),
+  skip: z.number().optional(),
+}).strict()
+
+export const ChatGroupByArgsSchema: z.ZodType<Prisma.ChatGroupByArgs> = z.object({
+  where: ChatWhereInputSchema.optional(),
+  orderBy: z.union([ ChatOrderByWithAggregationInputSchema.array(),ChatOrderByWithAggregationInputSchema ]).optional(),
+  by: ChatScalarFieldEnumSchema.array(),
+  having: ChatScalarWhereWithAggregatesInputSchema.optional(),
+  take: z.number().optional(),
+  skip: z.number().optional(),
+}).strict()
+
+export const ChatFindUniqueArgsSchema: z.ZodType<Prisma.ChatFindUniqueArgs> = z.object({
+  select: ChatSelectSchema.optional(),
+  include: ChatIncludeSchema.optional(),
+  where: ChatWhereUniqueInputSchema,
+}).strict()
+
+export const ChatFindUniqueOrThrowArgsSchema: z.ZodType<Prisma.ChatFindUniqueOrThrowArgs> = z.object({
+  select: ChatSelectSchema.optional(),
+  include: ChatIncludeSchema.optional(),
+  where: ChatWhereUniqueInputSchema,
+}).strict()
+
+export const AccountCreateArgsSchema: z.ZodType<Prisma.AccountCreateArgs> = z.object({
+  select: AccountSelectSchema.optional(),
+  include: AccountIncludeSchema.optional(),
+  data: z.union([ AccountCreateInputSchema,AccountUncheckedCreateInputSchema ]),
+}).strict()
+
+export const AccountUpsertArgsSchema: z.ZodType<Prisma.AccountUpsertArgs> = z.object({
+  select: AccountSelectSchema.optional(),
+  include: AccountIncludeSchema.optional(),
+  where: AccountWhereUniqueInputSchema,
+  create: z.union([ AccountCreateInputSchema,AccountUncheckedCreateInputSchema ]),
+  update: z.union([ AccountUpdateInputSchema,AccountUncheckedUpdateInputSchema ]),
+}).strict()
+
+export const AccountCreateManyArgsSchema: z.ZodType<Prisma.AccountCreateManyArgs> = z.object({
+  data: z.union([ AccountCreateManyInputSchema,AccountCreateManyInputSchema.array() ]),
+  skipDuplicates: z.boolean().optional(),
+}).strict()
+
+export const AccountDeleteArgsSchema: z.ZodType<Prisma.AccountDeleteArgs> = z.object({
+  select: AccountSelectSchema.optional(),
+  include: AccountIncludeSchema.optional(),
+  where: AccountWhereUniqueInputSchema,
+}).strict()
+
+export const AccountUpdateArgsSchema: z.ZodType<Prisma.AccountUpdateArgs> = z.object({
+  select: AccountSelectSchema.optional(),
+  include: AccountIncludeSchema.optional(),
+  data: z.union([ AccountUpdateInputSchema,AccountUncheckedUpdateInputSchema ]),
+  where: AccountWhereUniqueInputSchema,
+}).strict()
+
+export const AccountUpdateManyArgsSchema: z.ZodType<Prisma.AccountUpdateManyArgs> = z.object({
+  data: z.union([ AccountUpdateManyMutationInputSchema,AccountUncheckedUpdateManyInputSchema ]),
+  where: AccountWhereInputSchema.optional(),
+}).strict()
+
+export const AccountDeleteManyArgsSchema: z.ZodType<Prisma.AccountDeleteManyArgs> = z.object({
+  where: AccountWhereInputSchema.optional(),
+}).strict()
+
+export const SessionCreateArgsSchema: z.ZodType<Prisma.SessionCreateArgs> = z.object({
+  select: SessionSelectSchema.optional(),
+  include: SessionIncludeSchema.optional(),
+  data: z.union([ SessionCreateInputSchema,SessionUncheckedCreateInputSchema ]),
+}).strict()
+
+export const SessionUpsertArgsSchema: z.ZodType<Prisma.SessionUpsertArgs> = z.object({
+  select: SessionSelectSchema.optional(),
+  include: SessionIncludeSchema.optional(),
+  where: SessionWhereUniqueInputSchema,
+  create: z.union([ SessionCreateInputSchema,SessionUncheckedCreateInputSchema ]),
+  update: z.union([ SessionUpdateInputSchema,SessionUncheckedUpdateInputSchema ]),
+}).strict()
+
+export const SessionCreateManyArgsSchema: z.ZodType<Prisma.SessionCreateManyArgs> = z.object({
+  data: z.union([ SessionCreateManyInputSchema,SessionCreateManyInputSchema.array() ]),
+  skipDuplicates: z.boolean().optional(),
+}).strict()
+
+export const SessionDeleteArgsSchema: z.ZodType<Prisma.SessionDeleteArgs> = z.object({
+  select: SessionSelectSchema.optional(),
+  include: SessionIncludeSchema.optional(),
+  where: SessionWhereUniqueInputSchema,
+}).strict()
+
+export const SessionUpdateArgsSchema: z.ZodType<Prisma.SessionUpdateArgs> = z.object({
+  select: SessionSelectSchema.optional(),
+  include: SessionIncludeSchema.optional(),
+  data: z.union([ SessionUpdateInputSchema,SessionUncheckedUpdateInputSchema ]),
+  where: SessionWhereUniqueInputSchema,
+}).strict()
+
+export const SessionUpdateManyArgsSchema: z.ZodType<Prisma.SessionUpdateManyArgs> = z.object({
+  data: z.union([ SessionUpdateManyMutationInputSchema,SessionUncheckedUpdateManyInputSchema ]),
+  where: SessionWhereInputSchema.optional(),
+}).strict()
+
+export const SessionDeleteManyArgsSchema: z.ZodType<Prisma.SessionDeleteManyArgs> = z.object({
+  where: SessionWhereInputSchema.optional(),
+}).strict()
+
+export const UserCreateArgsSchema: z.ZodType<Prisma.UserCreateArgs> = z.object({
+  select: UserSelectSchema.optional(),
+  include: UserIncludeSchema.optional(),
+  data: z.union([ UserCreateInputSchema,UserUncheckedCreateInputSchema ]),
+}).strict()
+
+export const UserUpsertArgsSchema: z.ZodType<Prisma.UserUpsertArgs> = z.object({
+  select: UserSelectSchema.optional(),
+  include: UserIncludeSchema.optional(),
+  where: UserWhereUniqueInputSchema,
+  create: z.union([ UserCreateInputSchema,UserUncheckedCreateInputSchema ]),
+  update: z.union([ UserUpdateInputSchema,UserUncheckedUpdateInputSchema ]),
+}).strict()
+
+export const UserCreateManyArgsSchema: z.ZodType<Prisma.UserCreateManyArgs> = z.object({
+  data: z.union([ UserCreateManyInputSchema,UserCreateManyInputSchema.array() ]),
+  skipDuplicates: z.boolean().optional(),
+}).strict()
+
+export const UserDeleteArgsSchema: z.ZodType<Prisma.UserDeleteArgs> = z.object({
+  select: UserSelectSchema.optional(),
+  include: UserIncludeSchema.optional(),
+  where: UserWhereUniqueInputSchema,
+}).strict()
+
+export const UserUpdateArgsSchema: z.ZodType<Prisma.UserUpdateArgs> = z.object({
+  select: UserSelectSchema.optional(),
+  include: UserIncludeSchema.optional(),
+  data: z.union([ UserUpdateInputSchema,UserUncheckedUpdateInputSchema ]),
+  where: UserWhereUniqueInputSchema,
+}).strict()
+
+export const UserUpdateManyArgsSchema: z.ZodType<Prisma.UserUpdateManyArgs> = z.object({
+  data: z.union([ UserUpdateManyMutationInputSchema,UserUncheckedUpdateManyInputSchema ]),
+  where: UserWhereInputSchema.optional(),
+}).strict()
+
+export const UserDeleteManyArgsSchema: z.ZodType<Prisma.UserDeleteManyArgs> = z.object({
+  where: UserWhereInputSchema.optional(),
+}).strict()
+
+export const VerificationTokenCreateArgsSchema: z.ZodType<Prisma.VerificationTokenCreateArgs> = z.object({
+  select: VerificationTokenSelectSchema.optional(),
+  data: z.union([ VerificationTokenCreateInputSchema,VerificationTokenUncheckedCreateInputSchema ]),
+}).strict()
+
+export const VerificationTokenUpsertArgsSchema: z.ZodType<Prisma.VerificationTokenUpsertArgs> = z.object({
+  select: VerificationTokenSelectSchema.optional(),
+  where: VerificationTokenWhereUniqueInputSchema,
+  create: z.union([ VerificationTokenCreateInputSchema,VerificationTokenUncheckedCreateInputSchema ]),
+  update: z.union([ VerificationTokenUpdateInputSchema,VerificationTokenUncheckedUpdateInputSchema ]),
+}).strict()
+
+export const VerificationTokenCreateManyArgsSchema: z.ZodType<Prisma.VerificationTokenCreateManyArgs> = z.object({
+  data: z.union([ VerificationTokenCreateManyInputSchema,VerificationTokenCreateManyInputSchema.array() ]),
+  skipDuplicates: z.boolean().optional(),
+}).strict()
+
+export const VerificationTokenDeleteArgsSchema: z.ZodType<Prisma.VerificationTokenDeleteArgs> = z.object({
+  select: VerificationTokenSelectSchema.optional(),
+  where: VerificationTokenWhereUniqueInputSchema,
+}).strict()
+
+export const VerificationTokenUpdateArgsSchema: z.ZodType<Prisma.VerificationTokenUpdateArgs> = z.object({
+  select: VerificationTokenSelectSchema.optional(),
+  data: z.union([ VerificationTokenUpdateInputSchema,VerificationTokenUncheckedUpdateInputSchema ]),
+  where: VerificationTokenWhereUniqueInputSchema,
+}).strict()
+
+export const VerificationTokenUpdateManyArgsSchema: z.ZodType<Prisma.VerificationTokenUpdateManyArgs> = z.object({
+  data: z.union([ VerificationTokenUpdateManyMutationInputSchema,VerificationTokenUncheckedUpdateManyInputSchema ]),
+  where: VerificationTokenWhereInputSchema.optional(),
+}).strict()
+
+export const VerificationTokenDeleteManyArgsSchema: z.ZodType<Prisma.VerificationTokenDeleteManyArgs> = z.object({
+  where: VerificationTokenWhereInputSchema.optional(),
+}).strict()
+
+export const GameCreateArgsSchema: z.ZodType<Prisma.GameCreateArgs> = z.object({
+  select: GameSelectSchema.optional(),
+  include: GameIncludeSchema.optional(),
+  data: z.union([ GameCreateInputSchema,GameUncheckedCreateInputSchema ]),
+}).strict()
+
+export const GameUpsertArgsSchema: z.ZodType<Prisma.GameUpsertArgs> = z.object({
+  select: GameSelectSchema.optional(),
+  include: GameIncludeSchema.optional(),
+  where: GameWhereUniqueInputSchema,
+  create: z.union([ GameCreateInputSchema,GameUncheckedCreateInputSchema ]),
+  update: z.union([ GameUpdateInputSchema,GameUncheckedUpdateInputSchema ]),
+}).strict()
+
+export const GameCreateManyArgsSchema: z.ZodType<Prisma.GameCreateManyArgs> = z.object({
+  data: z.union([ GameCreateManyInputSchema,GameCreateManyInputSchema.array() ]),
+  skipDuplicates: z.boolean().optional(),
+}).strict()
+
+export const GameDeleteArgsSchema: z.ZodType<Prisma.GameDeleteArgs> = z.object({
+  select: GameSelectSchema.optional(),
+  include: GameIncludeSchema.optional(),
+  where: GameWhereUniqueInputSchema,
+}).strict()
+
+export const GameUpdateArgsSchema: z.ZodType<Prisma.GameUpdateArgs> = z.object({
+  select: GameSelectSchema.optional(),
+  include: GameIncludeSchema.optional(),
+  data: z.union([ GameUpdateInputSchema,GameUncheckedUpdateInputSchema ]),
+  where: GameWhereUniqueInputSchema,
+}).strict()
+
+export const GameUpdateManyArgsSchema: z.ZodType<Prisma.GameUpdateManyArgs> = z.object({
+  data: z.union([ GameUpdateManyMutationInputSchema,GameUncheckedUpdateManyInputSchema ]),
+  where: GameWhereInputSchema.optional(),
+}).strict()
+
+export const GameDeleteManyArgsSchema: z.ZodType<Prisma.GameDeleteManyArgs> = z.object({
+  where: GameWhereInputSchema.optional(),
+}).strict()
+
+export const GamepinCreateArgsSchema: z.ZodType<Prisma.GamepinCreateArgs> = z.object({
+  select: GamepinSelectSchema.optional(),
+  include: GamepinIncludeSchema.optional(),
+  data: z.union([ GamepinCreateInputSchema,GamepinUncheckedCreateInputSchema ]),
+}).strict()
+
+export const GamepinUpsertArgsSchema: z.ZodType<Prisma.GamepinUpsertArgs> = z.object({
+  select: GamepinSelectSchema.optional(),
+  include: GamepinIncludeSchema.optional(),
+  where: GamepinWhereUniqueInputSchema,
+  create: z.union([ GamepinCreateInputSchema,GamepinUncheckedCreateInputSchema ]),
+  update: z.union([ GamepinUpdateInputSchema,GamepinUncheckedUpdateInputSchema ]),
+}).strict()
+
+export const GamepinCreateManyArgsSchema: z.ZodType<Prisma.GamepinCreateManyArgs> = z.object({
+  data: z.union([ GamepinCreateManyInputSchema,GamepinCreateManyInputSchema.array() ]),
+  skipDuplicates: z.boolean().optional(),
+}).strict()
+
+export const GamepinDeleteArgsSchema: z.ZodType<Prisma.GamepinDeleteArgs> = z.object({
+  select: GamepinSelectSchema.optional(),
+  include: GamepinIncludeSchema.optional(),
+  where: GamepinWhereUniqueInputSchema,
+}).strict()
+
+export const GamepinUpdateArgsSchema: z.ZodType<Prisma.GamepinUpdateArgs> = z.object({
+  select: GamepinSelectSchema.optional(),
+  include: GamepinIncludeSchema.optional(),
+  data: z.union([ GamepinUpdateInputSchema,GamepinUncheckedUpdateInputSchema ]),
+  where: GamepinWhereUniqueInputSchema,
+}).strict()
+
+export const GamepinUpdateManyArgsSchema: z.ZodType<Prisma.GamepinUpdateManyArgs> = z.object({
+  data: z.union([ GamepinUpdateManyMutationInputSchema,GamepinUncheckedUpdateManyInputSchema ]),
+  where: GamepinWhereInputSchema.optional(),
+}).strict()
+
+export const GamepinDeleteManyArgsSchema: z.ZodType<Prisma.GamepinDeleteManyArgs> = z.object({
+  where: GamepinWhereInputSchema.optional(),
+}).strict()
+
+export const User_GameCreateArgsSchema: z.ZodType<Prisma.User_GameCreateArgs> = z.object({
+  select: User_GameSelectSchema.optional(),
+  include: User_GameIncludeSchema.optional(),
+  data: z.union([ User_GameCreateInputSchema,User_GameUncheckedCreateInputSchema ]),
+}).strict()
+
+export const User_GameUpsertArgsSchema: z.ZodType<Prisma.User_GameUpsertArgs> = z.object({
+  select: User_GameSelectSchema.optional(),
+  include: User_GameIncludeSchema.optional(),
+  where: User_GameWhereUniqueInputSchema,
+  create: z.union([ User_GameCreateInputSchema,User_GameUncheckedCreateInputSchema ]),
+  update: z.union([ User_GameUpdateInputSchema,User_GameUncheckedUpdateInputSchema ]),
+}).strict()
+
+export const User_GameCreateManyArgsSchema: z.ZodType<Prisma.User_GameCreateManyArgs> = z.object({
+  data: z.union([ User_GameCreateManyInputSchema,User_GameCreateManyInputSchema.array() ]),
+  skipDuplicates: z.boolean().optional(),
+}).strict()
+
+export const User_GameDeleteArgsSchema: z.ZodType<Prisma.User_GameDeleteArgs> = z.object({
+  select: User_GameSelectSchema.optional(),
+  include: User_GameIncludeSchema.optional(),
+  where: User_GameWhereUniqueInputSchema,
+}).strict()
+
+export const User_GameUpdateArgsSchema: z.ZodType<Prisma.User_GameUpdateArgs> = z.object({
+  select: User_GameSelectSchema.optional(),
+  include: User_GameIncludeSchema.optional(),
+  data: z.union([ User_GameUpdateInputSchema,User_GameUncheckedUpdateInputSchema ]),
+  where: User_GameWhereUniqueInputSchema,
+}).strict()
+
+export const User_GameUpdateManyArgsSchema: z.ZodType<Prisma.User_GameUpdateManyArgs> = z.object({
+  data: z.union([ User_GameUpdateManyMutationInputSchema,User_GameUncheckedUpdateManyInputSchema ]),
+  where: User_GameWhereInputSchema.optional(),
+}).strict()
+
+export const User_GameDeleteManyArgsSchema: z.ZodType<Prisma.User_GameDeleteManyArgs> = z.object({
+  where: User_GameWhereInputSchema.optional(),
+}).strict()
+
+export const MoveCreateArgsSchema: z.ZodType<Prisma.MoveCreateArgs> = z.object({
+  select: MoveSelectSchema.optional(),
+  include: MoveIncludeSchema.optional(),
+  data: z.union([ MoveCreateInputSchema,MoveUncheckedCreateInputSchema ]),
+}).strict()
+
+export const MoveUpsertArgsSchema: z.ZodType<Prisma.MoveUpsertArgs> = z.object({
+  select: MoveSelectSchema.optional(),
+  include: MoveIncludeSchema.optional(),
+  where: MoveWhereUniqueInputSchema,
+  create: z.union([ MoveCreateInputSchema,MoveUncheckedCreateInputSchema ]),
+  update: z.union([ MoveUpdateInputSchema,MoveUncheckedUpdateInputSchema ]),
+}).strict()
+
+export const MoveCreateManyArgsSchema: z.ZodType<Prisma.MoveCreateManyArgs> = z.object({
+  data: z.union([ MoveCreateManyInputSchema,MoveCreateManyInputSchema.array() ]),
+  skipDuplicates: z.boolean().optional(),
+}).strict()
+
+export const MoveDeleteArgsSchema: z.ZodType<Prisma.MoveDeleteArgs> = z.object({
+  select: MoveSelectSchema.optional(),
+  include: MoveIncludeSchema.optional(),
+  where: MoveWhereUniqueInputSchema,
+}).strict()
+
+export const MoveUpdateArgsSchema: z.ZodType<Prisma.MoveUpdateArgs> = z.object({
+  select: MoveSelectSchema.optional(),
+  include: MoveIncludeSchema.optional(),
+  data: z.union([ MoveUpdateInputSchema,MoveUncheckedUpdateInputSchema ]),
+  where: MoveWhereUniqueInputSchema,
+}).strict()
+
+export const MoveUpdateManyArgsSchema: z.ZodType<Prisma.MoveUpdateManyArgs> = z.object({
+  data: z.union([ MoveUpdateManyMutationInputSchema,MoveUncheckedUpdateManyInputSchema ]),
+  where: MoveWhereInputSchema.optional(),
+}).strict()
+
+export const MoveDeleteManyArgsSchema: z.ZodType<Prisma.MoveDeleteManyArgs> = z.object({
+  where: MoveWhereInputSchema.optional(),
+}).strict()
+
+export const ChatCreateArgsSchema: z.ZodType<Prisma.ChatCreateArgs> = z.object({
+  select: ChatSelectSchema.optional(),
+  include: ChatIncludeSchema.optional(),
+  data: z.union([ ChatCreateInputSchema,ChatUncheckedCreateInputSchema ]),
+}).strict()
+
+export const ChatUpsertArgsSchema: z.ZodType<Prisma.ChatUpsertArgs> = z.object({
+  select: ChatSelectSchema.optional(),
+  include: ChatIncludeSchema.optional(),
+  where: ChatWhereUniqueInputSchema,
+  create: z.union([ ChatCreateInputSchema,ChatUncheckedCreateInputSchema ]),
+  update: z.union([ ChatUpdateInputSchema,ChatUncheckedUpdateInputSchema ]),
+}).strict()
+
+export const ChatCreateManyArgsSchema: z.ZodType<Prisma.ChatCreateManyArgs> = z.object({
+  data: z.union([ ChatCreateManyInputSchema,ChatCreateManyInputSchema.array() ]),
+  skipDuplicates: z.boolean().optional(),
+}).strict()
+
+export const ChatDeleteArgsSchema: z.ZodType<Prisma.ChatDeleteArgs> = z.object({
+  select: ChatSelectSchema.optional(),
+  include: ChatIncludeSchema.optional(),
+  where: ChatWhereUniqueInputSchema,
+}).strict()
+
+export const ChatUpdateArgsSchema: z.ZodType<Prisma.ChatUpdateArgs> = z.object({
+  select: ChatSelectSchema.optional(),
+  include: ChatIncludeSchema.optional(),
+  data: z.union([ ChatUpdateInputSchema,ChatUncheckedUpdateInputSchema ]),
+  where: ChatWhereUniqueInputSchema,
+}).strict()
+
+export const ChatUpdateManyArgsSchema: z.ZodType<Prisma.ChatUpdateManyArgs> = z.object({
+  data: z.union([ ChatUpdateManyMutationInputSchema,ChatUncheckedUpdateManyInputSchema ]),
+  where: ChatWhereInputSchema.optional(),
+}).strict()
+
+export const ChatDeleteManyArgsSchema: z.ZodType<Prisma.ChatDeleteManyArgs> = z.object({
+  where: ChatWhereInputSchema.optional(),
+}).strict()
\ No newline at end of file
diff --git a/leaky-ships/prisma/schema.prisma b/leaky-ships/prisma/schema.prisma
index 53b81ff..f2a9214 100644
--- a/leaky-ships/prisma/schema.prisma
+++ b/leaky-ships/prisma/schema.prisma
@@ -1,3 +1,7 @@
+generator zod {
+  provider = "zod-prisma-types"
+}
+
 generator client {
   provider = "prisma-client-js"
 }