@levrbet/shared 0.1.36 → 0.1.37

package/dist/core/prisma/oracle/generated/client/index.d.ts

@@ -63,6 +63,11 @@ export type Odds = $Result.DefaultSelection<Prisma.$OddsPayload>
  * 
  */
 export type Market = $Result.DefaultSelection<Prisma.$MarketPayload>
+/**
+ * Model User
+ * 
+ */
+export type User = $Result.DefaultSelection<Prisma.$UserPayload>
 
 /**
  * Enums
@@ -121,6 +126,15 @@ export const SportGroup: {
 
 export type SportGroup = (typeof SportGroup)[keyof typeof SportGroup]
 
+
+export const UserOddsPreference: {
+  American: 'American',
+  Decimal: 'Decimal',
+  European: 'European'
+};
+
+export type UserOddsPreference = (typeof UserOddsPreference)[keyof typeof UserOddsPreference]
+
 }
 
 export type GamePhase = $Enums.GamePhase
@@ -147,6 +161,10 @@ export type SportGroup = $Enums.SportGroup
 
 export const SportGroup: typeof $Enums.SportGroup
 
+export type UserOddsPreference = $Enums.UserOddsPreference
+
+export const UserOddsPreference: typeof $Enums.UserOddsPreference
+
 /**
  * ##  Prisma Client ʲˢ
  *
@@ -331,6 +349,16 @@ export class PrismaClient<
     * ```
     */
   get market(): Prisma.MarketDelegate<ExtArgs, ClientOptions>;
+
+  /**
+   * `prisma.user`: Exposes CRUD operations for the **User** model.
+    * Example usage:
+    * ```ts
+    * // Fetch zero or more Users
+    * const users = await prisma.user.findMany()
+    * ```
+    */
+  get user(): Prisma.UserDelegate<ExtArgs, ClientOptions>;
 }
 
 export namespace Prisma {
@@ -780,7 +808,8 @@ export namespace Prisma {
     Scores: 'Scores',
     LevrGame: 'LevrGame',
     Odds: 'Odds',
-    Market: 'Market'
+    Market: 'Market',
+    User: 'User'
   };
 
   export type ModelName = (typeof ModelName)[keyof typeof ModelName]
@@ -799,7 +828,7 @@ export namespace Prisma {
       omit: GlobalOmitOptions
     }
     meta: {
-      modelProps: "provider" | "tournament" | "sport" | "league" | "teamData" | "fixture" | "scores" | "levrGame" | "odds" | "market"
+      modelProps: "provider" | "tournament" | "sport" | "league" | "teamData" | "fixture" | "scores" | "levrGame" | "odds" | "market" | "user"
       txIsolationLevel: never
     }
     model: {
@@ -1543,6 +1572,80 @@ export namespace Prisma {
           }
         }
       }
+      User: {
+        payload: Prisma.$UserPayload<ExtArgs>
+        fields: Prisma.UserFieldRefs
+        operations: {
+          findUnique: {
+            args: Prisma.UserFindUniqueArgs<ExtArgs>
+            result: $Utils.PayloadToResult<Prisma.$UserPayload> | null
+          }
+          findUniqueOrThrow: {
+            args: Prisma.UserFindUniqueOrThrowArgs<ExtArgs>
+            result: $Utils.PayloadToResult<Prisma.$UserPayload>
+          }
+          findFirst: {
+            args: Prisma.UserFindFirstArgs<ExtArgs>
+            result: $Utils.PayloadToResult<Prisma.$UserPayload> | null
+          }
+          findFirstOrThrow: {
+            args: Prisma.UserFindFirstOrThrowArgs<ExtArgs>
+            result: $Utils.PayloadToResult<Prisma.$UserPayload>
+          }
+          findMany: {
+            args: Prisma.UserFindManyArgs<ExtArgs>
+            result: $Utils.PayloadToResult<Prisma.$UserPayload>[]
+          }
+          create: {
+            args: Prisma.UserCreateArgs<ExtArgs>
+            result: $Utils.PayloadToResult<Prisma.$UserPayload>
+          }
+          createMany: {
+            args: Prisma.UserCreateManyArgs<ExtArgs>
+            result: BatchPayload
+          }
+          delete: {
+            args: Prisma.UserDeleteArgs<ExtArgs>
+            result: $Utils.PayloadToResult<Prisma.$UserPayload>
+          }
+          update: {
+            args: Prisma.UserUpdateArgs<ExtArgs>
+            result: $Utils.PayloadToResult<Prisma.$UserPayload>
+          }
+          deleteMany: {
+            args: Prisma.UserDeleteManyArgs<ExtArgs>
+            result: BatchPayload
+          }
+          updateMany: {
+            args: Prisma.UserUpdateManyArgs<ExtArgs>
+            result: BatchPayload
+          }
+          upsert: {
+            args: Prisma.UserUpsertArgs<ExtArgs>
+            result: $Utils.PayloadToResult<Prisma.$UserPayload>
+          }
+          aggregate: {
+            args: Prisma.UserAggregateArgs<ExtArgs>
+            result: $Utils.Optional<AggregateUser>
+          }
+          groupBy: {
+            args: Prisma.UserGroupByArgs<ExtArgs>
+            result: $Utils.Optional<UserGroupByOutputType>[]
+          }
+          findRaw: {
+            args: Prisma.UserFindRawArgs<ExtArgs>
+            result: JsonObject
+          }
+          aggregateRaw: {
+            args: Prisma.UserAggregateRawArgs<ExtArgs>
+            result: JsonObject
+          }
+          count: {
+            args: Prisma.UserCountArgs<ExtArgs>
+            result: $Utils.Optional<UserCountAggregateOutputType> | number
+          }
+        }
+      }
     }
   } & {
     other: {
@@ -1632,6 +1735,7 @@ export namespace Prisma {
     levrGame?: LevrGameOmit
     odds?: OddsOmit
     market?: MarketOmit
+    user?: UserOmit
   }
 
   /* Types for Logging */
@@ -13156,141 +13260,1117 @@ export namespace Prisma {
 
 
   /**
-   * Enums
+   * Model User
    */
 
-  export const ProviderScalarFieldEnum: {
-    objectId: 'objectId',
-    name: 'name',
-    providerUrl: 'providerUrl',
-    createdAt: 'createdAt',
-    updatedAt: 'updatedAt'
-  };
+  export type AggregateUser = {
+    _count: UserCountAggregateOutputType | null
+    _min: UserMinAggregateOutputType | null
+    _max: UserMaxAggregateOutputType | null
+  }
 
-  export type ProviderScalarFieldEnum = (typeof ProviderScalarFieldEnum)[keyof typeof ProviderScalarFieldEnum]
+  export type UserMinAggregateOutputType = {
+    objectId: string | null
+    walletAddress: string | null
+    userName: string | null
+    timeZone: Date | null
+    preferredTimeZone: Date | null
+    userOddsPreference: $Enums.UserOddsPreference | null
+    profileImageUrl: string | null
+    createdAt: Date | null
+    updatedAt: Date | null
+  }
 
+  export type UserMaxAggregateOutputType = {
+    objectId: string | null
+    walletAddress: string | null
+    userName: string | null
+    timeZone: Date | null
+    preferredTimeZone: Date | null
+    userOddsPreference: $Enums.UserOddsPreference | null
+    profileImageUrl: string | null
+    createdAt: Date | null
+    updatedAt: Date | null
+  }
 
-  export const TournamentScalarFieldEnum: {
-    objectId: 'objectId',
-    levrTournamentId: 'levrTournamentId',
-    chainId: 'chainId',
-    name: 'name',
-    description: 'description',
-    bannerUrl: 'bannerUrl',
-    startDate: 'startDate',
-    endDate: 'endDate',
-    createdAt: 'createdAt',
-    updatedAt: 'updatedAt'
-  };
+  export type UserCountAggregateOutputType = {
+    objectId: number
+    walletAddress: number
+    userName: number
+    timeZone: number
+    preferredTimeZone: number
+    userOddsPreference: number
+    profileImageUrl: number
+    createdAt: number
+    updatedAt: number
+    _all: number
+  }
 
-  export type TournamentScalarFieldEnum = (typeof TournamentScalarFieldEnum)[keyof typeof TournamentScalarFieldEnum]
 
+  export type UserMinAggregateInputType = {
+    objectId?: true
+    walletAddress?: true
+    userName?: true
+    timeZone?: true
+    preferredTimeZone?: true
+    userOddsPreference?: true
+    profileImageUrl?: true
+    createdAt?: true
+    updatedAt?: true
+  }
 
-  export const SportScalarFieldEnum: {
-    objectId: 'objectId',
-    levrSportId: 'levrSportId',
-    name: 'name',
-    periodType: 'periodType',
-    scoringType: 'scoringType',
-    standardDurationMs: 'standardDurationMs',
-    standardPeriods: 'standardPeriods',
-    periodDuration: 'periodDuration',
-    hasDrawMarket: 'hasDrawMarket',
-    sportGroup: 'sportGroup',
-    createdAt: 'createdAt',
-    updatedAt: 'updatedAt'
-  };
+  export type UserMaxAggregateInputType = {
+    objectId?: true
+    walletAddress?: true
+    userName?: true
+    timeZone?: true
+    preferredTimeZone?: true
+    userOddsPreference?: true
+    profileImageUrl?: true
+    createdAt?: true
+    updatedAt?: true
+  }
 
-  export type SportScalarFieldEnum = (typeof SportScalarFieldEnum)[keyof typeof SportScalarFieldEnum]
+  export type UserCountAggregateInputType = {
+    objectId?: true
+    walletAddress?: true
+    userName?: true
+    timeZone?: true
+    preferredTimeZone?: true
+    userOddsPreference?: true
+    profileImageUrl?: true
+    createdAt?: true
+    updatedAt?: true
+    _all?: true
+  }
 
+  export type UserAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Filter which User to aggregate.
+     */
+    where?: UserWhereInput
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+     * 
+     * Determine the order of Users to fetch.
+     */
+    orderBy?: UserOrderByWithRelationInput | UserOrderByWithRelationInput[]
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+     * 
+     * Sets the start position
+     */
+    cursor?: UserWhereUniqueInput
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+     * 
+     * Take `±n` Users from the position of the cursor.
+     */
+    take?: number
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+     * 
+     * Skip the first `n` Users.
+     */
+    skip?: number
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+     * 
+     * Count returned Users
+    **/
+    _count?: true | UserCountAggregateInputType
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+     * 
+     * Select which fields to find the minimum value
+    **/
+    _min?: UserMinAggregateInputType
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+     * 
+     * Select which fields to find the maximum value
+    **/
+    _max?: UserMaxAggregateInputType
+  }
 
-  export const LeagueScalarFieldEnum: {
-    objectId: 'objectId',
-    name: 'name',
-    abbreviation: 'abbreviation',
-    country: 'country',
-    levrLeagueId: 'levrLeagueId',
-    opticOddsLeagueId: 'opticOddsLeagueId',
-    lsportsLeagueId: 'lsportsLeagueId',
-    tournamentObjectId: 'tournamentObjectId',
-    sportObjectId: 'sportObjectId',
-    levrSportId: 'levrSportId',
-    createdAt: 'createdAt',
-    updatedAt: 'updatedAt'
-  };
+  export type GetUserAggregateType<T extends UserAggregateArgs> = {
+        [P in keyof T & keyof AggregateUser]: P extends '_count' | 'count'
+      ? T[P] extends true
+        ? number
+        : GetScalarType<T[P], AggregateUser[P]>
+      : GetScalarType<T[P], AggregateUser[P]>
+  }
 
-  export type LeagueScalarFieldEnum = (typeof LeagueScalarFieldEnum)[keyof typeof LeagueScalarFieldEnum]
 
 
-  export const TeamDataScalarFieldEnum: {
-    objectId: 'objectId',
-    levrTeamName: 'levrTeamName',
-    levrTeamOfficialAbbreviation: 'levrTeamOfficialAbbreviation',
-    lsportsTeamName: 'lsportsTeamName',
-    opticOddsTeamName: 'opticOddsTeamName',
-    lsportsTeamId: 'lsportsTeamId',
-    opticOddsTeamId: 'opticOddsTeamId',
-    levrTeamId: 'levrTeamId',
-    opticOddsTeamLogoUrl: 'opticOddsTeamLogoUrl',
-    levrTeamLogoUrl: 'levrTeamLogoUrl',
-    leagueObjectId: 'leagueObjectId',
-    levrleagueId: 'levrleagueId'
-  };
 
-  export type TeamDataScalarFieldEnum = (typeof TeamDataScalarFieldEnum)[keyof typeof TeamDataScalarFieldEnum]
+  export type UserGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    where?: UserWhereInput
+    orderBy?: UserOrderByWithAggregationInput | UserOrderByWithAggregationInput[]
+    by: UserScalarFieldEnum[] | UserScalarFieldEnum
+    having?: UserScalarWhereWithAggregatesInput
+    take?: number
+    skip?: number
+    _count?: UserCountAggregateInputType | true
+    _min?: UserMinAggregateInputType
+    _max?: UserMaxAggregateInputType
+  }
 
+  export type UserGroupByOutputType = {
+    objectId: string
+    walletAddress: string
+    userName: string
+    timeZone: Date
+    preferredTimeZone: Date
+    userOddsPreference: $Enums.UserOddsPreference
+    profileImageUrl: string
+    createdAt: Date
+    updatedAt: Date
+    _count: UserCountAggregateOutputType | null
+    _min: UserMinAggregateOutputType | null
+    _max: UserMaxAggregateOutputType | null
+  }
 
-  export const FixtureScalarFieldEnum: {
-    objectId: 'objectId',
-    levrFixtureId: 'levrFixtureId',
-    opticOddsFixtureId: 'opticOddsFixtureId',
-    lsportsFixtureId: 'lsportsFixtureId',
-    seasonType: 'seasonType',
-    venue: 'venue',
-    eventName: 'eventName',
-    location: 'location',
-    venueLocation: 'venueLocation',
-    fixtureDate: 'fixtureDate',
-    lastUpdated: 'lastUpdated',
-    homeTeam: 'homeTeam',
-    awayTeam: 'awayTeam',
-    fixtureStatus: 'fixtureStatus',
-    leagueObjectId: 'leagueObjectId',
-    createdAt: 'createdAt',
-    updatedAt: 'updatedAt'
-  };
+  type GetUserGroupByPayload<T extends UserGroupByArgs> = Prisma.PrismaPromise<
+    Array<
+      PickEnumerable<UserGroupByOutputType, T['by']> &
+        {
+          [P in ((keyof T) & (keyof UserGroupByOutputType))]: P extends '_count'
+            ? T[P] extends boolean
+              ? number
+              : GetScalarType<T[P], UserGroupByOutputType[P]>
+            : GetScalarType<T[P], UserGroupByOutputType[P]>
+        }
+      >
+    >
 
-  export type FixtureScalarFieldEnum = (typeof FixtureScalarFieldEnum)[keyof typeof FixtureScalarFieldEnum]
 
+  export type UserSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
+    objectId?: boolean
+    walletAddress?: boolean
+    userName?: boolean
+    timeZone?: boolean
+    preferredTimeZone?: boolean
+    userOddsPreference?: boolean
+    profileImageUrl?: boolean
+    createdAt?: boolean
+    updatedAt?: boolean
+  }, ExtArgs["result"]["user"]>
 
-  export const ScoresScalarFieldEnum: {
-    objectId: 'objectId',
-    scoresByPeriodHome: 'scoresByPeriodHome',
-    scoresByPeriodAway: 'scoresByPeriodAway',
-    totalScoresHome: 'totalScoresHome',
-    totalScoresAway: 'totalScoresAway',
-    fixtureObjectId: 'fixtureObjectId',
-    createdAt: 'createdAt',
-    updatedAt: 'updatedAt'
-  };
 
-  export type ScoresScalarFieldEnum = (typeof ScoresScalarFieldEnum)[keyof typeof ScoresScalarFieldEnum]
 
+  export type UserSelectScalar = {
+    objectId?: boolean
+    walletAddress?: boolean
+    userName?: boolean
+    timeZone?: boolean
+    preferredTimeZone?: boolean
+    userOddsPreference?: boolean
+    profileImageUrl?: boolean
+    createdAt?: boolean
+    updatedAt?: boolean
+  }
 
-  export const LevrGameScalarFieldEnum: {
-    objectId: 'objectId',
-    gameId: 'gameId',
-    txHash: 'txHash',
-    chainId: 'chainId',
-    seasonType: 'seasonType',
-    venue: 'venue',
-    eventName: 'eventName',
-    location: 'location',
-    venueLocation: 'venueLocation',
-    gameClock: 'gameClock',
-    paused: 'paused',
-    fixtureDate: 'fixtureDate',
-    wentLiveAt: 'wentLiveAt',
+  export type UserOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"objectId" | "walletAddress" | "userName" | "timeZone" | "preferredTimeZone" | "userOddsPreference" | "profileImageUrl" | "createdAt" | "updatedAt", ExtArgs["result"]["user"]>
+
+  export type $UserPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    name: "User"
+    objects: {}
+    scalars: $Extensions.GetPayloadResult<{
+      objectId: string
+      walletAddress: string
+      userName: string
+      timeZone: Date
+      preferredTimeZone: Date
+      userOddsPreference: $Enums.UserOddsPreference
+      profileImageUrl: string
+      createdAt: Date
+      updatedAt: Date
+    }, ExtArgs["result"]["user"]>
+    composites: {}
+  }
+
+  type UserGetPayload<S extends boolean | null | undefined | UserDefaultArgs> = $Result.GetResult<Prisma.$UserPayload, S>
+
+  type UserCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
+    Omit<UserFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
+      select?: UserCountAggregateInputType | true
+    }
+
+  export interface UserDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> {
+    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['User'], meta: { name: 'User' } }
+    /**
+     * Find zero or one User that matches the filter.
+     * @param {UserFindUniqueArgs} args - Arguments to find a User
+     * @example
+     * // Get one User
+     * const user = await prisma.user.findUnique({
+     *   where: {
+     *     // ... provide filter here
+     *   }
+     * })
+     */
+    findUnique<T extends UserFindUniqueArgs>(args: SelectSubset<T, UserFindUniqueArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
+
+    /**
+     * Find one User that matches the filter or throw an error with `error.code='P2025'`
+     * if no matches were found.
+     * @param {UserFindUniqueOrThrowArgs} args - Arguments to find a User
+     * @example
+     * // Get one User
+     * const user = await prisma.user.findUniqueOrThrow({
+     *   where: {
+     *     // ... provide filter here
+     *   }
+     * })
+     */
+    findUniqueOrThrow<T extends UserFindUniqueOrThrowArgs>(args: SelectSubset<T, UserFindUniqueOrThrowArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+    /**
+     * Find the first User that matches the filter.
+     * Note, that providing `undefined` is treated as the value not being there.
+     * Read more here: https://pris.ly/d/null-undefined
+     * @param {UserFindFirstArgs} args - Arguments to find a User
+     * @example
+     * // Get one User
+     * const user = await prisma.user.findFirst({
+     *   where: {
+     *     // ... provide filter here
+     *   }
+     * })
+     */
+    findFirst<T extends UserFindFirstArgs>(args?: SelectSubset<T, UserFindFirstArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
+
+    /**
+     * Find the first User that matches the filter or
+     * throw `PrismaKnownClientError` with `P2025` code if no matches were found.
+     * Note, that providing `undefined` is treated as the value not being there.
+     * Read more here: https://pris.ly/d/null-undefined
+     * @param {UserFindFirstOrThrowArgs} args - Arguments to find a User
+     * @example
+     * // Get one User
+     * const user = await prisma.user.findFirstOrThrow({
+     *   where: {
+     *     // ... provide filter here
+     *   }
+     * })
+     */
+    findFirstOrThrow<T extends UserFindFirstOrThrowArgs>(args?: SelectSubset<T, UserFindFirstOrThrowArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+    /**
+     * Find zero or more Users that matches the filter.
+     * Note, that providing `undefined` is treated as the value not being there.
+     * Read more here: https://pris.ly/d/null-undefined
+     * @param {UserFindManyArgs} args - Arguments to filter and select certain fields only.
+     * @example
+     * // Get all Users
+     * const users = await prisma.user.findMany()
+     * 
+     * // Get first 10 Users
+     * const users = await prisma.user.findMany({ take: 10 })
+     * 
+     * // Only select the `objectId`
+     * const userWithObjectIdOnly = await prisma.user.findMany({ select: { objectId: true } })
+     * 
+     */
+    findMany<T extends UserFindManyArgs>(args?: SelectSubset<T, UserFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>
+
+    /**
+     * Create a User.
+     * @param {UserCreateArgs} args - Arguments to create a User.
+     * @example
+     * // Create one User
+     * const User = await prisma.user.create({
+     *   data: {
+     *     // ... data to create a User
+     *   }
+     * })
+     * 
+     */
+    create<T extends UserCreateArgs>(args: SelectSubset<T, UserCreateArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+    /**
+     * Create many Users.
+     * @param {UserCreateManyArgs} args - Arguments to create many Users.
+     * @example
+     * // Create many Users
+     * const user = await prisma.user.createMany({
+     *   data: [
+     *     // ... provide data here
+     *   ]
+     * })
+     *     
+     */
+    createMany<T extends UserCreateManyArgs>(args?: SelectSubset<T, UserCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
+
+    /**
+     * Delete a User.
+     * @param {UserDeleteArgs} args - Arguments to delete one User.
+     * @example
+     * // Delete one User
+     * const User = await prisma.user.delete({
+     *   where: {
+     *     // ... filter to delete one User
+     *   }
+     * })
+     * 
+     */
+    delete<T extends UserDeleteArgs>(args: SelectSubset<T, UserDeleteArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+    /**
+     * Update one User.
+     * @param {UserUpdateArgs} args - Arguments to update one User.
+     * @example
+     * // Update one User
+     * const user = await prisma.user.update({
+     *   where: {
+     *     // ... provide filter here
+     *   },
+     *   data: {
+     *     // ... provide data here
+     *   }
+     * })
+     * 
+     */
+    update<T extends UserUpdateArgs>(args: SelectSubset<T, UserUpdateArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+    /**
+     * Delete zero or more Users.
+     * @param {UserDeleteManyArgs} args - Arguments to filter Users to delete.
+     * @example
+     * // Delete a few Users
+     * const { count } = await prisma.user.deleteMany({
+     *   where: {
+     *     // ... provide filter here
+     *   }
+     * })
+     * 
+     */
+    deleteMany<T extends UserDeleteManyArgs>(args?: SelectSubset<T, UserDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
+
+    /**
+     * Update zero or more Users.
+     * Note, that providing `undefined` is treated as the value not being there.
+     * Read more here: https://pris.ly/d/null-undefined
+     * @param {UserUpdateManyArgs} args - Arguments to update one or more rows.
+     * @example
+     * // Update many Users
+     * const user = await prisma.user.updateMany({
+     *   where: {
+     *     // ... provide filter here
+     *   },
+     *   data: {
+     *     // ... provide data here
+     *   }
+     * })
+     * 
+     */
+    updateMany<T extends UserUpdateManyArgs>(args: SelectSubset<T, UserUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
+
+    /**
+     * Create or update one User.
+     * @param {UserUpsertArgs} args - Arguments to update or create a User.
+     * @example
+     * // Update or create a User
+     * const user = await prisma.user.upsert({
+     *   create: {
+     *     // ... data to create a User
+     *   },
+     *   update: {
+     *     // ... in case it already exists, update
+     *   },
+     *   where: {
+     *     // ... the filter for the User we want to update
+     *   }
+     * })
+     */
+    upsert<T extends UserUpsertArgs>(args: SelectSubset<T, UserUpsertArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+    /**
+     * Find zero or more Users that matches the filter.
+     * @param {UserFindRawArgs} args - Select which filters you would like to apply.
+     * @example
+     * const user = await prisma.user.findRaw({
+     *   filter: { age: { $gt: 25 } }
+     * })
+     */
+    findRaw(args?: UserFindRawArgs): Prisma.PrismaPromise<JsonObject>
+
+    /**
+     * Perform aggregation operations on a User.
+     * @param {UserAggregateRawArgs} args - Select which aggregations you would like to apply.
+     * @example
+     * const user = await prisma.user.aggregateRaw({
+     *   pipeline: [
+     *     { $match: { status: "registered" } },
+     *     { $group: { _id: "$country", total: { $sum: 1 } } }
+     *   ]
+     * })
+     */
+    aggregateRaw(args?: UserAggregateRawArgs): Prisma.PrismaPromise<JsonObject>
+
+
+    /**
+     * Count the number of Users.
+     * Note, that providing `undefined` is treated as the value not being there.
+     * Read more here: https://pris.ly/d/null-undefined
+     * @param {UserCountArgs} args - Arguments to filter Users to count.
+     * @example
+     * // Count the number of Users
+     * const count = await prisma.user.count({
+     *   where: {
+     *     // ... the filter for the Users we want to count
+     *   }
+     * })
+    **/
+    count<T extends UserCountArgs>(
+      args?: Subset<T, UserCountArgs>,
+    ): Prisma.PrismaPromise<
+      T extends $Utils.Record<'select', any>
+        ? T['select'] extends true
+          ? number
+          : GetScalarType<T['select'], UserCountAggregateOutputType>
+        : number
+    >
+
+    /**
+     * Allows you to perform aggregations operations on a User.
+     * Note, that providing `undefined` is treated as the value not being there.
+     * Read more here: https://pris.ly/d/null-undefined
+     * @param {UserAggregateArgs} args - Select which aggregations you would like to apply and on what fields.
+     * @example
+     * // Ordered by age ascending
+     * // Where email contains prisma.io
+     * // Limited to the 10 users
+     * const aggregations = await prisma.user.aggregate({
+     *   _avg: {
+     *     age: true,
+     *   },
+     *   where: {
+     *     email: {
+     *       contains: "prisma.io",
+     *     },
+     *   },
+     *   orderBy: {
+     *     age: "asc",
+     *   },
+     *   take: 10,
+     * })
+    **/
+    aggregate<T extends UserAggregateArgs>(args: Subset<T, UserAggregateArgs>): Prisma.PrismaPromise<GetUserAggregateType<T>>
+
+    /**
+     * Group by User.
+     * Note, that providing `undefined` is treated as the value not being there.
+     * Read more here: https://pris.ly/d/null-undefined
+     * @param {UserGroupByArgs} args - Group by arguments.
+     * @example
+     * // Group by city, order by createdAt, get count
+     * const result = await prisma.user.groupBy({
+     *   by: ['city', 'createdAt'],
+     *   orderBy: {
+     *     createdAt: true
+     *   },
+     *   _count: {
+     *     _all: true
+     *   },
+     * })
+     * 
+    **/
+    groupBy<
+      T extends UserGroupByArgs,
+      HasSelectOrTake extends Or<
+        Extends<'skip', Keys<T>>,
+        Extends<'take', Keys<T>>
+      >,
+      OrderByArg extends True extends HasSelectOrTake
+        ? { orderBy: UserGroupByArgs['orderBy'] }
+        : { orderBy?: UserGroupByArgs['orderBy'] },
+      OrderFields extends ExcludeUnderscoreKeys<Keys<MaybeTupleToUnion<T['orderBy']>>>,
+      ByFields extends MaybeTupleToUnion<T['by']>,
+      ByValid extends Has<ByFields, OrderFields>,
+      HavingFields extends GetHavingFields<T['having']>,
+      HavingValid extends Has<ByFields, HavingFields>,
+      ByEmpty extends T['by'] extends never[] ? True : False,
+      InputErrors extends ByEmpty extends True
+      ? `Error: "by" must not be empty.`
+      : HavingValid extends False
+      ? {
+          [P in HavingFields]: P extends ByFields
+            ? never
+            : P extends string
+            ? `Error: Field "${P}" used in "having" needs to be provided in "by".`
+            : [
+                Error,
+                'Field ',
+                P,
+                ` in "having" needs to be provided in "by"`,
+              ]
+        }[HavingFields]
+      : 'take' extends Keys<T>
+      ? 'orderBy' extends Keys<T>
+        ? ByValid extends True
+          ? {}
+          : {
+              [P in OrderFields]: P extends ByFields
+                ? never
+                : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
+            }[OrderFields]
+        : 'Error: If you provide "take", you also need to provide "orderBy"'
+      : 'skip' extends Keys<T>
+      ? 'orderBy' extends Keys<T>
+        ? ByValid extends True
+          ? {}
+          : {
+              [P in OrderFields]: P extends ByFields
+                ? never
+                : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
+            }[OrderFields]
+        : 'Error: If you provide "skip", you also need to provide "orderBy"'
+      : ByValid extends True
+      ? {}
+      : {
+          [P in OrderFields]: P extends ByFields
+            ? never
+            : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
+        }[OrderFields]
+    >(args: SubsetIntersection<T, UserGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetUserGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
+  /**
+   * Fields of the User model
+   */
+  readonly fields: UserFieldRefs;
+  }
+
+  /**
+   * The delegate class that acts as a "Promise-like" for User.
+   * Why is this prefixed with `Prisma__`?
+   * Because we want to prevent naming conflicts as mentioned in
+   * https://github.com/prisma/prisma-client-js/issues/707
+   */
+  export interface Prisma__UserClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
+    readonly [Symbol.toStringTag]: "PrismaPromise"
+    /**
+     * Attaches callbacks for the resolution and/or rejection of the Promise.
+     * @param onfulfilled The callback to execute when the Promise is resolved.
+     * @param onrejected The callback to execute when the Promise is rejected.
+     * @returns A Promise for the completion of which ever callback is executed.
+     */
+    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
+    /**
+     * Attaches a callback for only the rejection of the Promise.
+     * @param onrejected The callback to execute when the Promise is rejected.
+     * @returns A Promise for the completion of the callback.
+     */
+    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
+    /**
+     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
+     * resolved value cannot be modified from the callback.
+     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
+     * @returns A Promise for the completion of the callback.
+     */
+    finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
+  }
+
+
+
+
+  /**
+   * Fields of the User model
+   */
+  interface UserFieldRefs {
+    readonly objectId: FieldRef<"User", 'String'>
+    readonly walletAddress: FieldRef<"User", 'String'>
+    readonly userName: FieldRef<"User", 'String'>
+    readonly timeZone: FieldRef<"User", 'DateTime'>
+    readonly preferredTimeZone: FieldRef<"User", 'DateTime'>
+    readonly userOddsPreference: FieldRef<"User", 'UserOddsPreference'>
+    readonly profileImageUrl: FieldRef<"User", 'String'>
+    readonly createdAt: FieldRef<"User", 'DateTime'>
+    readonly updatedAt: FieldRef<"User", 'DateTime'>
+  }
+    
+
+  // Custom InputTypes
+  /**
+   * User findUnique
+   */
+  export type UserFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the User
+     */
+    select?: UserSelect<ExtArgs> | null
+    /**
+     * Omit specific fields from the User
+     */
+    omit?: UserOmit<ExtArgs> | null
+    /**
+     * Filter, which User to fetch.
+     */
+    where: UserWhereUniqueInput
+  }
+
+  /**
+   * User findUniqueOrThrow
+   */
+  export type UserFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the User
+     */
+    select?: UserSelect<ExtArgs> | null
+    /**
+     * Omit specific fields from the User
+     */
+    omit?: UserOmit<ExtArgs> | null
+    /**
+     * Filter, which User to fetch.
+     */
+    where: UserWhereUniqueInput
+  }
+
+  /**
+   * User findFirst
+   */
+  export type UserFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the User
+     */
+    select?: UserSelect<ExtArgs> | null
+    /**
+     * Omit specific fields from the User
+     */
+    omit?: UserOmit<ExtArgs> | null
+    /**
+     * Filter, which User to fetch.
+     */
+    where?: UserWhereInput
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+     * 
+     * Determine the order of Users to fetch.
+     */
+    orderBy?: UserOrderByWithRelationInput | UserOrderByWithRelationInput[]
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+     * 
+     * Sets the position for searching for Users.
+     */
+    cursor?: UserWhereUniqueInput
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+     * 
+     * Take `±n` Users from the position of the cursor.
+     */
+    take?: number
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+     * 
+     * Skip the first `n` Users.
+     */
+    skip?: number
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
+     * 
+     * Filter by unique combinations of Users.
+     */
+    distinct?: UserScalarFieldEnum | UserScalarFieldEnum[]
+  }
+
+  /**
+   * User findFirstOrThrow
+   */
+  export type UserFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the User
+     */
+    select?: UserSelect<ExtArgs> | null
+    /**
+     * Omit specific fields from the User
+     */
+    omit?: UserOmit<ExtArgs> | null
+    /**
+     * Filter, which User to fetch.
+     */
+    where?: UserWhereInput
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+     * 
+     * Determine the order of Users to fetch.
+     */
+    orderBy?: UserOrderByWithRelationInput | UserOrderByWithRelationInput[]
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+     * 
+     * Sets the position for searching for Users.
+     */
+    cursor?: UserWhereUniqueInput
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+     * 
+     * Take `±n` Users from the position of the cursor.
+     */
+    take?: number
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+     * 
+     * Skip the first `n` Users.
+     */
+    skip?: number
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
+     * 
+     * Filter by unique combinations of Users.
+     */
+    distinct?: UserScalarFieldEnum | UserScalarFieldEnum[]
+  }
+
+  /**
+   * User findMany
+   */
+  export type UserFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the User
+     */
+    select?: UserSelect<ExtArgs> | null
+    /**
+     * Omit specific fields from the User
+     */
+    omit?: UserOmit<ExtArgs> | null
+    /**
+     * Filter, which Users to fetch.
+     */
+    where?: UserWhereInput
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+     * 
+     * Determine the order of Users to fetch.
+     */
+    orderBy?: UserOrderByWithRelationInput | UserOrderByWithRelationInput[]
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+     * 
+     * Sets the position for listing Users.
+     */
+    cursor?: UserWhereUniqueInput
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+     * 
+     * Take `±n` Users from the position of the cursor.
+     */
+    take?: number
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+     * 
+     * Skip the first `n` Users.
+     */
+    skip?: number
+    distinct?: UserScalarFieldEnum | UserScalarFieldEnum[]
+  }
+
+  /**
+   * User create
+   */
+  export type UserCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the User
+     */
+    select?: UserSelect<ExtArgs> | null
+    /**
+     * Omit specific fields from the User
+     */
+    omit?: UserOmit<ExtArgs> | null
+    /**
+     * The data needed to create a User.
+     */
+    data: XOR<UserCreateInput, UserUncheckedCreateInput>
+  }
+
+  /**
+   * User createMany
+   */
+  export type UserCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * The data used to create many Users.
+     */
+    data: UserCreateManyInput | UserCreateManyInput[]
+  }
+
+  /**
+   * User update
+   */
+  export type UserUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the User
+     */
+    select?: UserSelect<ExtArgs> | null
+    /**
+     * Omit specific fields from the User
+     */
+    omit?: UserOmit<ExtArgs> | null
+    /**
+     * The data needed to update a User.
+     */
+    data: XOR<UserUpdateInput, UserUncheckedUpdateInput>
+    /**
+     * Choose, which User to update.
+     */
+    where: UserWhereUniqueInput
+  }
+
+  /**
+   * User updateMany
+   */
+  export type UserUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * The data used to update Users.
+     */
+    data: XOR<UserUpdateManyMutationInput, UserUncheckedUpdateManyInput>
+    /**
+     * Filter which Users to update
+     */
+    where?: UserWhereInput
+    /**
+     * Limit how many Users to update.
+     */
+    limit?: number
+  }
+
+  /**
+   * User upsert
+   */
+  export type UserUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the User
+     */
+    select?: UserSelect<ExtArgs> | null
+    /**
+     * Omit specific fields from the User
+     */
+    omit?: UserOmit<ExtArgs> | null
+    /**
+     * The filter to search for the User to update in case it exists.
+     */
+    where: UserWhereUniqueInput
+    /**
+     * In case the User found by the `where` argument doesn't exist, create a new User with this data.
+     */
+    create: XOR<UserCreateInput, UserUncheckedCreateInput>
+    /**
+     * In case the User was found with the provided `where` argument, update it with this data.
+     */
+    update: XOR<UserUpdateInput, UserUncheckedUpdateInput>
+  }
+
+  /**
+   * User delete
+   */
+  export type UserDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the User
+     */
+    select?: UserSelect<ExtArgs> | null
+    /**
+     * Omit specific fields from the User
+     */
+    omit?: UserOmit<ExtArgs> | null
+    /**
+     * Filter which User to delete.
+     */
+    where: UserWhereUniqueInput
+  }
+
+  /**
+   * User deleteMany
+   */
+  export type UserDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Filter which Users to delete
+     */
+    where?: UserWhereInput
+    /**
+     * Limit how many Users to delete.
+     */
+    limit?: number
+  }
+
+  /**
+   * User findRaw
+   */
+  export type UserFindRawArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * The query predicate filter. If unspecified, then all documents in the collection will match the predicate. ${@link https://docs.mongodb.com/manual/reference/operator/query MongoDB Docs}.
+     */
+    filter?: InputJsonValue
+    /**
+     * Additional options to pass to the `find` command ${@link https://docs.mongodb.com/manual/reference/command/find/#command-fields MongoDB Docs}.
+     */
+    options?: InputJsonValue
+  }
+
+  /**
+   * User aggregateRaw
+   */
+  export type UserAggregateRawArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * An array of aggregation stages to process and transform the document stream via the aggregation pipeline. ${@link https://docs.mongodb.com/manual/reference/operator/aggregation-pipeline MongoDB Docs}.
+     */
+    pipeline?: InputJsonValue[]
+    /**
+     * Additional options to pass to the `aggregate` command ${@link https://docs.mongodb.com/manual/reference/command/aggregate/#command-fields MongoDB Docs}.
+     */
+    options?: InputJsonValue
+  }
+
+  /**
+   * User without action
+   */
+  export type UserDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the User
+     */
+    select?: UserSelect<ExtArgs> | null
+    /**
+     * Omit specific fields from the User
+     */
+    omit?: UserOmit<ExtArgs> | null
+  }
+
+
+  /**
+   * Enums
+   */
+
+  export const ProviderScalarFieldEnum: {
+    objectId: 'objectId',
+    name: 'name',
+    providerUrl: 'providerUrl',
+    createdAt: 'createdAt',
+    updatedAt: 'updatedAt'
+  };
+
+  export type ProviderScalarFieldEnum = (typeof ProviderScalarFieldEnum)[keyof typeof ProviderScalarFieldEnum]
+
+
+  export const TournamentScalarFieldEnum: {
+    objectId: 'objectId',
+    levrTournamentId: 'levrTournamentId',
+    chainId: 'chainId',
+    name: 'name',
+    description: 'description',
+    bannerUrl: 'bannerUrl',
+    startDate: 'startDate',
+    endDate: 'endDate',
+    createdAt: 'createdAt',
+    updatedAt: 'updatedAt'
+  };
+
+  export type TournamentScalarFieldEnum = (typeof TournamentScalarFieldEnum)[keyof typeof TournamentScalarFieldEnum]
+
+
+  export const SportScalarFieldEnum: {
+    objectId: 'objectId',
+    levrSportId: 'levrSportId',
+    name: 'name',
+    periodType: 'periodType',
+    scoringType: 'scoringType',
+    standardDurationMs: 'standardDurationMs',
+    standardPeriods: 'standardPeriods',
+    periodDuration: 'periodDuration',
+    hasDrawMarket: 'hasDrawMarket',
+    sportGroup: 'sportGroup',
+    createdAt: 'createdAt',
+    updatedAt: 'updatedAt'
+  };
+
+  export type SportScalarFieldEnum = (typeof SportScalarFieldEnum)[keyof typeof SportScalarFieldEnum]
+
+
+  export const LeagueScalarFieldEnum: {
+    objectId: 'objectId',
+    name: 'name',
+    abbreviation: 'abbreviation',
+    country: 'country',
+    levrLeagueId: 'levrLeagueId',
+    opticOddsLeagueId: 'opticOddsLeagueId',
+    lsportsLeagueId: 'lsportsLeagueId',
+    tournamentObjectId: 'tournamentObjectId',
+    sportObjectId: 'sportObjectId',
+    levrSportId: 'levrSportId',
+    createdAt: 'createdAt',
+    updatedAt: 'updatedAt'
+  };
+
+  export type LeagueScalarFieldEnum = (typeof LeagueScalarFieldEnum)[keyof typeof LeagueScalarFieldEnum]
+
+
+  export const TeamDataScalarFieldEnum: {
+    objectId: 'objectId',
+    levrTeamName: 'levrTeamName',
+    levrTeamOfficialAbbreviation: 'levrTeamOfficialAbbreviation',
+    lsportsTeamName: 'lsportsTeamName',
+    opticOddsTeamName: 'opticOddsTeamName',
+    lsportsTeamId: 'lsportsTeamId',
+    opticOddsTeamId: 'opticOddsTeamId',
+    levrTeamId: 'levrTeamId',
+    opticOddsTeamLogoUrl: 'opticOddsTeamLogoUrl',
+    levrTeamLogoUrl: 'levrTeamLogoUrl',
+    leagueObjectId: 'leagueObjectId',
+    levrleagueId: 'levrleagueId'
+  };
+
+  export type TeamDataScalarFieldEnum = (typeof TeamDataScalarFieldEnum)[keyof typeof TeamDataScalarFieldEnum]
+
+
+  export const FixtureScalarFieldEnum: {
+    objectId: 'objectId',
+    levrFixtureId: 'levrFixtureId',
+    opticOddsFixtureId: 'opticOddsFixtureId',
+    lsportsFixtureId: 'lsportsFixtureId',
+    seasonType: 'seasonType',
+    venue: 'venue',
+    eventName: 'eventName',
+    location: 'location',
+    venueLocation: 'venueLocation',
+    fixtureDate: 'fixtureDate',
+    lastUpdated: 'lastUpdated',
+    homeTeam: 'homeTeam',
+    awayTeam: 'awayTeam',
+    fixtureStatus: 'fixtureStatus',
+    leagueObjectId: 'leagueObjectId',
+    createdAt: 'createdAt',
+    updatedAt: 'updatedAt'
+  };
+
+  export type FixtureScalarFieldEnum = (typeof FixtureScalarFieldEnum)[keyof typeof FixtureScalarFieldEnum]
+
+
+  export const ScoresScalarFieldEnum: {
+    objectId: 'objectId',
+    scoresByPeriodHome: 'scoresByPeriodHome',
+    scoresByPeriodAway: 'scoresByPeriodAway',
+    totalScoresHome: 'totalScoresHome',
+    totalScoresAway: 'totalScoresAway',
+    fixtureObjectId: 'fixtureObjectId',
+    createdAt: 'createdAt',
+    updatedAt: 'updatedAt'
+  };
+
+  export type ScoresScalarFieldEnum = (typeof ScoresScalarFieldEnum)[keyof typeof ScoresScalarFieldEnum]
+
+
+  export const LevrGameScalarFieldEnum: {
+    objectId: 'objectId',
+    gameId: 'gameId',
+    txHash: 'txHash',
+    chainId: 'chainId',
+    seasonType: 'seasonType',
+    venue: 'venue',
+    eventName: 'eventName',
+    location: 'location',
+    venueLocation: 'venueLocation',
+    gameClock: 'gameClock',
+    paused: 'paused',
+    fixtureDate: 'fixtureDate',
+    wentLiveAt: 'wentLiveAt',
     homeTeam: 'homeTeam',
     awayTeam: 'awayTeam',
     currentPeriod: 'currentPeriod',
@@ -13360,6 +14440,21 @@ export namespace Prisma {
   export type MarketScalarFieldEnum = (typeof MarketScalarFieldEnum)[keyof typeof MarketScalarFieldEnum]
 
 
+  export const UserScalarFieldEnum: {
+    objectId: 'objectId',
+    walletAddress: 'walletAddress',
+    userName: 'userName',
+    timeZone: 'timeZone',
+    preferredTimeZone: 'preferredTimeZone',
+    userOddsPreference: 'userOddsPreference',
+    profileImageUrl: 'profileImageUrl',
+    createdAt: 'createdAt',
+    updatedAt: 'updatedAt'
+  };
+
+  export type UserScalarFieldEnum = (typeof UserScalarFieldEnum)[keyof typeof UserScalarFieldEnum]
+
+
   export const SortOrder: {
     asc: 'asc',
     desc: 'desc'
@@ -13533,6 +14628,20 @@ export namespace Prisma {
    */
   export type ListEnumMarketStatusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'MarketStatus[]'>
     
+
+
+  /**
+   * Reference to a field of type 'UserOddsPreference'
+   */
+  export type EnumUserOddsPreferenceFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'UserOddsPreference'>
+    
+
+
+  /**
+   * Reference to a field of type 'UserOddsPreference[]'
+   */
+  export type ListEnumUserOddsPreferenceFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'UserOddsPreference[]'>
+    
   /**
    * Deep Input Types
    */
@@ -14589,6 +15698,78 @@ export namespace Prisma {
     updatedAt?: DateTimeWithAggregatesFilter<"Market"> | Date | string
   }
 
+  export type UserWhereInput = {
+    AND?: UserWhereInput | UserWhereInput[]
+    OR?: UserWhereInput[]
+    NOT?: UserWhereInput | UserWhereInput[]
+    objectId?: StringFilter<"User"> | string
+    walletAddress?: StringFilter<"User"> | string
+    userName?: StringFilter<"User"> | string
+    timeZone?: DateTimeFilter<"User"> | Date | string
+    preferredTimeZone?: DateTimeFilter<"User"> | Date | string
+    userOddsPreference?: EnumUserOddsPreferenceFilter<"User"> | $Enums.UserOddsPreference
+    profileImageUrl?: StringFilter<"User"> | string
+    createdAt?: DateTimeFilter<"User"> | Date | string
+    updatedAt?: DateTimeFilter<"User"> | Date | string
+  }
+
+  export type UserOrderByWithRelationInput = {
+    objectId?: SortOrder
+    walletAddress?: SortOrder
+    userName?: SortOrder
+    timeZone?: SortOrder
+    preferredTimeZone?: SortOrder
+    userOddsPreference?: SortOrder
+    profileImageUrl?: SortOrder
+    createdAt?: SortOrder
+    updatedAt?: SortOrder
+  }
+
+  export type UserWhereUniqueInput = Prisma.AtLeast<{
+    objectId?: string
+    walletAddress?: string
+    userName?: string
+    AND?: UserWhereInput | UserWhereInput[]
+    OR?: UserWhereInput[]
+    NOT?: UserWhereInput | UserWhereInput[]
+    timeZone?: DateTimeFilter<"User"> | Date | string
+    preferredTimeZone?: DateTimeFilter<"User"> | Date | string
+    userOddsPreference?: EnumUserOddsPreferenceFilter<"User"> | $Enums.UserOddsPreference
+    profileImageUrl?: StringFilter<"User"> | string
+    createdAt?: DateTimeFilter<"User"> | Date | string
+    updatedAt?: DateTimeFilter<"User"> | Date | string
+  }, "objectId" | "walletAddress" | "userName">
+
+  export type UserOrderByWithAggregationInput = {
+    objectId?: SortOrder
+    walletAddress?: SortOrder
+    userName?: SortOrder
+    timeZone?: SortOrder
+    preferredTimeZone?: SortOrder
+    userOddsPreference?: SortOrder
+    profileImageUrl?: SortOrder
+    createdAt?: SortOrder
+    updatedAt?: SortOrder
+    _count?: UserCountOrderByAggregateInput
+    _max?: UserMaxOrderByAggregateInput
+    _min?: UserMinOrderByAggregateInput
+  }
+
+  export type UserScalarWhereWithAggregatesInput = {
+    AND?: UserScalarWhereWithAggregatesInput | UserScalarWhereWithAggregatesInput[]
+    OR?: UserScalarWhereWithAggregatesInput[]
+    NOT?: UserScalarWhereWithAggregatesInput | UserScalarWhereWithAggregatesInput[]
+    objectId?: StringWithAggregatesFilter<"User"> | string
+    walletAddress?: StringWithAggregatesFilter<"User"> | string
+    userName?: StringWithAggregatesFilter<"User"> | string
+    timeZone?: DateTimeWithAggregatesFilter<"User"> | Date | string
+    preferredTimeZone?: DateTimeWithAggregatesFilter<"User"> | Date | string
+    userOddsPreference?: EnumUserOddsPreferenceWithAggregatesFilter<"User"> | $Enums.UserOddsPreference
+    profileImageUrl?: StringWithAggregatesFilter<"User"> | string
+    createdAt?: DateTimeWithAggregatesFilter<"User"> | Date | string
+    updatedAt?: DateTimeWithAggregatesFilter<"User"> | Date | string
+  }
+
   export type ProviderCreateInput = {
     objectId?: string
     name: string
@@ -15776,6 +16957,86 @@ export namespace Prisma {
     updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
   }
 
+  export type UserCreateInput = {
+    objectId?: string
+    walletAddress: string
+    userName: string
+    timeZone: Date | string
+    preferredTimeZone: Date | string
+    userOddsPreference: $Enums.UserOddsPreference
+    profileImageUrl: string
+    createdAt?: Date | string
+    updatedAt?: Date | string
+  }
+
+  export type UserUncheckedCreateInput = {
+    objectId?: string
+    walletAddress: string
+    userName: string
+    timeZone: Date | string
+    preferredTimeZone: Date | string
+    userOddsPreference: $Enums.UserOddsPreference
+    profileImageUrl: string
+    createdAt?: Date | string
+    updatedAt?: Date | string
+  }
+
+  export type UserUpdateInput = {
+    walletAddress?: StringFieldUpdateOperationsInput | string
+    userName?: StringFieldUpdateOperationsInput | string
+    timeZone?: DateTimeFieldUpdateOperationsInput | Date | string
+    preferredTimeZone?: DateTimeFieldUpdateOperationsInput | Date | string
+    userOddsPreference?: EnumUserOddsPreferenceFieldUpdateOperationsInput | $Enums.UserOddsPreference
+    profileImageUrl?: StringFieldUpdateOperationsInput | string
+    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
+    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
+  }
+
+  export type UserUncheckedUpdateInput = {
+    walletAddress?: StringFieldUpdateOperationsInput | string
+    userName?: StringFieldUpdateOperationsInput | string
+    timeZone?: DateTimeFieldUpdateOperationsInput | Date | string
+    preferredTimeZone?: DateTimeFieldUpdateOperationsInput | Date | string
+    userOddsPreference?: EnumUserOddsPreferenceFieldUpdateOperationsInput | $Enums.UserOddsPreference
+    profileImageUrl?: StringFieldUpdateOperationsInput | string
+    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
+    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
+  }
+
+  export type UserCreateManyInput = {
+    objectId?: string
+    walletAddress: string
+    userName: string
+    timeZone: Date | string
+    preferredTimeZone: Date | string
+    userOddsPreference: $Enums.UserOddsPreference
+    profileImageUrl: string
+    createdAt?: Date | string
+    updatedAt?: Date | string
+  }
+
+  export type UserUpdateManyMutationInput = {
+    walletAddress?: StringFieldUpdateOperationsInput | string
+    userName?: StringFieldUpdateOperationsInput | string
+    timeZone?: DateTimeFieldUpdateOperationsInput | Date | string
+    preferredTimeZone?: DateTimeFieldUpdateOperationsInput | Date | string
+    userOddsPreference?: EnumUserOddsPreferenceFieldUpdateOperationsInput | $Enums.UserOddsPreference
+    profileImageUrl?: StringFieldUpdateOperationsInput | string
+    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
+    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
+  }
+
+  export type UserUncheckedUpdateManyInput = {
+    walletAddress?: StringFieldUpdateOperationsInput | string
+    userName?: StringFieldUpdateOperationsInput | string
+    timeZone?: DateTimeFieldUpdateOperationsInput | Date | string
+    preferredTimeZone?: DateTimeFieldUpdateOperationsInput | Date | string
+    userOddsPreference?: EnumUserOddsPreferenceFieldUpdateOperationsInput | $Enums.UserOddsPreference
+    profileImageUrl?: StringFieldUpdateOperationsInput | string
+    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
+    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
+  }
+
   export type StringFilter<$PrismaModel = never> = {
     equals?: string | StringFieldRefInput<$PrismaModel>
     in?: string[] | ListStringFieldRefInput<$PrismaModel>
@@ -16819,6 +18080,59 @@ export namespace Prisma {
     normalizationFactor?: SortOrder
   }
 
+  export type EnumUserOddsPreferenceFilter<$PrismaModel = never> = {
+    equals?: $Enums.UserOddsPreference | EnumUserOddsPreferenceFieldRefInput<$PrismaModel>
+    in?: $Enums.UserOddsPreference[] | ListEnumUserOddsPreferenceFieldRefInput<$PrismaModel>
+    notIn?: $Enums.UserOddsPreference[] | ListEnumUserOddsPreferenceFieldRefInput<$PrismaModel>
+    not?: NestedEnumUserOddsPreferenceFilter<$PrismaModel> | $Enums.UserOddsPreference
+  }
+
+  export type UserCountOrderByAggregateInput = {
+    objectId?: SortOrder
+    walletAddress?: SortOrder
+    userName?: SortOrder
+    timeZone?: SortOrder
+    preferredTimeZone?: SortOrder
+    userOddsPreference?: SortOrder
+    profileImageUrl?: SortOrder
+    createdAt?: SortOrder
+    updatedAt?: SortOrder
+  }
+
+  export type UserMaxOrderByAggregateInput = {
+    objectId?: SortOrder
+    walletAddress?: SortOrder
+    userName?: SortOrder
+    timeZone?: SortOrder
+    preferredTimeZone?: SortOrder
+    userOddsPreference?: SortOrder
+    profileImageUrl?: SortOrder
+    createdAt?: SortOrder
+    updatedAt?: SortOrder
+  }
+
+  export type UserMinOrderByAggregateInput = {
+    objectId?: SortOrder
+    walletAddress?: SortOrder
+    userName?: SortOrder
+    timeZone?: SortOrder
+    preferredTimeZone?: SortOrder
+    userOddsPreference?: SortOrder
+    profileImageUrl?: SortOrder
+    createdAt?: SortOrder
+    updatedAt?: SortOrder
+  }
+
+  export type EnumUserOddsPreferenceWithAggregatesFilter<$PrismaModel = never> = {
+    equals?: $Enums.UserOddsPreference | EnumUserOddsPreferenceFieldRefInput<$PrismaModel>
+    in?: $Enums.UserOddsPreference[] | ListEnumUserOddsPreferenceFieldRefInput<$PrismaModel>
+    notIn?: $Enums.UserOddsPreference[] | ListEnumUserOddsPreferenceFieldRefInput<$PrismaModel>
+    not?: NestedEnumUserOddsPreferenceWithAggregatesFilter<$PrismaModel> | $Enums.UserOddsPreference
+    _count?: NestedIntFilter<$PrismaModel>
+    _min?: NestedEnumUserOddsPreferenceFilter<$PrismaModel>
+    _max?: NestedEnumUserOddsPreferenceFilter<$PrismaModel>
+  }
+
   export type StringFieldUpdateOperationsInput = {
     set?: string
   }
@@ -17440,6 +18754,10 @@ export namespace Prisma {
     deleteMany?: OddsScalarWhereInput | OddsScalarWhereInput[]
   }
 
+  export type EnumUserOddsPreferenceFieldUpdateOperationsInput = {
+    set?: $Enums.UserOddsPreference
+  }
+
   export type NestedStringFilter<$PrismaModel = never> = {
     equals?: string | StringFieldRefInput<$PrismaModel>
     in?: string[] | ListStringFieldRefInput<$PrismaModel>
@@ -17789,6 +19107,23 @@ export namespace Prisma {
     _max?: NestedEnumMarketStatusFilter<$PrismaModel>
   }
 
+  export type NestedEnumUserOddsPreferenceFilter<$PrismaModel = never> = {
+    equals?: $Enums.UserOddsPreference | EnumUserOddsPreferenceFieldRefInput<$PrismaModel>
+    in?: $Enums.UserOddsPreference[] | ListEnumUserOddsPreferenceFieldRefInput<$PrismaModel>
+    notIn?: $Enums.UserOddsPreference[] | ListEnumUserOddsPreferenceFieldRefInput<$PrismaModel>
+    not?: NestedEnumUserOddsPreferenceFilter<$PrismaModel> | $Enums.UserOddsPreference
+  }
+
+  export type NestedEnumUserOddsPreferenceWithAggregatesFilter<$PrismaModel = never> = {
+    equals?: $Enums.UserOddsPreference | EnumUserOddsPreferenceFieldRefInput<$PrismaModel>
+    in?: $Enums.UserOddsPreference[] | ListEnumUserOddsPreferenceFieldRefInput<$PrismaModel>
+    notIn?: $Enums.UserOddsPreference[] | ListEnumUserOddsPreferenceFieldRefInput<$PrismaModel>
+    not?: NestedEnumUserOddsPreferenceWithAggregatesFilter<$PrismaModel> | $Enums.UserOddsPreference
+    _count?: NestedIntFilter<$PrismaModel>
+    _min?: NestedEnumUserOddsPreferenceFilter<$PrismaModel>
+    _max?: NestedEnumUserOddsPreferenceFilter<$PrismaModel>
+  }
+
   export type LevrGameCreateWithoutTournamentInput = {
     objectId?: string
     gameId: number