football-next/lib/generated/prisma/index.d.ts

/**
 * Client
**/

import * as runtime from './runtime/client.js';
import $Types = runtime.Types // general types
import $Public = runtime.Types.Public
import $Utils = runtime.Types.Utils
import $Extensions = runtime.Types.Extensions
import $Result = runtime.Types.Result

export type PrismaPromise<T> = $Public.PrismaPromise<T>


/**
 * Model Country
 * 
 */
export type Country = $Result.DefaultSelection<Prisma.$CountryPayload>
/**
 * Model Group
 * 
 */
export type Group = $Result.DefaultSelection<Prisma.$GroupPayload>
/**
 * Model Player
 * 
 */
export type Player = $Result.DefaultSelection<Prisma.$PlayerPayload>
/**
 * Model Match
 * 
 */
export type Match = $Result.DefaultSelection<Prisma.$MatchPayload>
/**
 * Model Round
 * 
 */
export type Round = $Result.DefaultSelection<Prisma.$RoundPayload>
/**
 * Model Gameweek
 * 
 */
export type Gameweek = $Result.DefaultSelection<Prisma.$GameweekPayload>
/**
 * Model MatchEvent
 * 
 */
export type MatchEvent = $Result.DefaultSelection<Prisma.$MatchEventPayload>
/**
 * Model MatchLineup
 * 
 */
export type MatchLineup = $Result.DefaultSelection<Prisma.$MatchLineupPayload>
/**
 * Model PlayerMatchStat
 * 
 */
export type PlayerMatchStat = $Result.DefaultSelection<Prisma.$PlayerMatchStatPayload>
/**
 * Model ScoringRule
 * 
 */
export type ScoringRule = $Result.DefaultSelection<Prisma.$ScoringRulePayload>
/**
 * Model User
 * 
 */
export type User = $Result.DefaultSelection<Prisma.$UserPayload>
/**
 * Model LoginOtp
 * 
 */
export type LoginOtp = $Result.DefaultSelection<Prisma.$LoginOtpPayload>
/**
 * Model FantasyNews
 * 
 */
export type FantasyNews = $Result.DefaultSelection<Prisma.$FantasyNewsPayload>
/**
 * Model DailyQuiz
 * 
 */
export type DailyQuiz = $Result.DefaultSelection<Prisma.$DailyQuizPayload>
/**
 * Model QuizQuestion
 * 
 */
export type QuizQuestion = $Result.DefaultSelection<Prisma.$QuizQuestionPayload>
/**
 * Model QuizSubmission
 * 
 */
export type QuizSubmission = $Result.DefaultSelection<Prisma.$QuizSubmissionPayload>
/**
 * Model GoldenCard
 * 
 */
export type GoldenCard = $Result.DefaultSelection<Prisma.$GoldenCardPayload>
/**
 * Model Session
 * 
 */
export type Session = $Result.DefaultSelection<Prisma.$SessionPayload>
/**
 * Model Team
 * 
 */
export type Team = $Result.DefaultSelection<Prisma.$TeamPayload>
/**
 * Model TeamPlayer
 * 
 */
export type TeamPlayer = $Result.DefaultSelection<Prisma.$TeamPlayerPayload>
/**
 * Model Package
 * 
 */
export type Package = $Result.DefaultSelection<Prisma.$PackagePayload>
/**
 * Model Payment
 * 
 */
export type Payment = $Result.DefaultSelection<Prisma.$PaymentPayload>

/**
 * Enums
 */
export namespace $Enums {
  export const Role: {
  USER: 'USER',
  ADMIN: 'ADMIN'
};

export type Role = (typeof Role)[keyof typeof Role]


export const Position: {
  GK: 'GK',
  DEF: 'DEF',
  MID: 'MID',
  FWD: 'FWD'
};

export type Position = (typeof Position)[keyof typeof Position]


export const MatchStage: {
  GROUP: 'GROUP',
  ROUND_OF_16: 'ROUND_OF_16',
  QUARTER_FINAL: 'QUARTER_FINAL',
  SEMI_FINAL: 'SEMI_FINAL',
  THIRD_PLACE: 'THIRD_PLACE',
  FINAL: 'FINAL'
};

export type MatchStage = (typeof MatchStage)[keyof typeof MatchStage]


export const MatchStatus: {
  SCHEDULED: 'SCHEDULED',
  LIVE: 'LIVE',
  FINISHED: 'FINISHED'
};

export type MatchStatus = (typeof MatchStatus)[keyof typeof MatchStatus]


export const TeamStatus: {
  PENDING: 'PENDING',
  APPROVED: 'APPROVED',
  REJECTED: 'REJECTED',
  ACTIVE: 'ACTIVE',
  INACTIVE: 'INACTIVE'
};

export type TeamStatus = (typeof TeamStatus)[keyof typeof TeamStatus]


export const PaymentStatus: {
  PENDING: 'PENDING',
  SUCCESS: 'SUCCESS',
  FAILED: 'FAILED'
};

export type PaymentStatus = (typeof PaymentStatus)[keyof typeof PaymentStatus]


export const CardTier: {
  BRONZE: 'BRONZE',
  SILVER: 'SILVER',
  GOLD: 'GOLD'
};

export type CardTier = (typeof CardTier)[keyof typeof CardTier]


export const EventType: {
  GOAL: 'GOAL',
  ASSIST: 'ASSIST',
  YELLOW_CARD: 'YELLOW_CARD',
  RED_CARD: 'RED_CARD',
  SECOND_YELLOW: 'SECOND_YELLOW',
  SUBSTITUTION_IN: 'SUBSTITUTION_IN',
  SUBSTITUTION_OUT: 'SUBSTITUTION_OUT',
  INJURY_NO_SUB: 'INJURY_NO_SUB',
  CLEAN_SHEET: 'CLEAN_SHEET',
  PENALTY_SAVED: 'PENALTY_SAVED',
  PENALTY_MISSED: 'PENALTY_MISSED',
  OWN_GOAL: 'OWN_GOAL',
  EXTRA_TIME_BONUS: 'EXTRA_TIME_BONUS',
  MOTM: 'MOTM'
};

export type EventType = (typeof EventType)[keyof typeof EventType]


export const GoldenCardStatus: {
  SEALED: 'SEALED',
  OPENED: 'OPENED'
};

export type GoldenCardStatus = (typeof GoldenCardStatus)[keyof typeof GoldenCardStatus]


export const SpecialCardState: {
  IN_INVENTORY: 'IN_INVENTORY',
  IN_TEAM: 'IN_TEAM',
  SOLD: 'SOLD'
};

export type SpecialCardState = (typeof SpecialCardState)[keyof typeof SpecialCardState]

}

export type Role = $Enums.Role

export const Role: typeof $Enums.Role

export type Position = $Enums.Position

export const Position: typeof $Enums.Position

export type MatchStage = $Enums.MatchStage

export const MatchStage: typeof $Enums.MatchStage

export type MatchStatus = $Enums.MatchStatus

export const MatchStatus: typeof $Enums.MatchStatus

export type TeamStatus = $Enums.TeamStatus

export const TeamStatus: typeof $Enums.TeamStatus

export type PaymentStatus = $Enums.PaymentStatus

export const PaymentStatus: typeof $Enums.PaymentStatus

export type CardTier = $Enums.CardTier

export const CardTier: typeof $Enums.CardTier

export type EventType = $Enums.EventType

export const EventType: typeof $Enums.EventType

export type GoldenCardStatus = $Enums.GoldenCardStatus

export const GoldenCardStatus: typeof $Enums.GoldenCardStatus

export type SpecialCardState = $Enums.SpecialCardState

export const SpecialCardState: typeof $Enums.SpecialCardState

/**
 * ##  Prisma Client ʲˢ
 *
 * Type-safe database client for TypeScript & Node.js
 * @example
 * ```
 * const prisma = new PrismaClient()
 * // Fetch zero or more Countries
 * const countries = await prisma.country.findMany()
 * ```
 *
 *
 * Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client).
 */
export class PrismaClient<
  ClientOptions extends Prisma.PrismaClientOptions = Prisma.PrismaClientOptions,
  const U = 'log' extends keyof ClientOptions ? ClientOptions['log'] extends Array<Prisma.LogLevel | Prisma.LogDefinition> ? Prisma.GetEvents<ClientOptions['log']> : never : never,
  ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs
> {
  [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['other'] }

    /**
   * ##  Prisma Client ʲˢ
   *
   * Type-safe database client for TypeScript & Node.js
   * @example
   * ```
   * const prisma = new PrismaClient()
   * // Fetch zero or more Countries
   * const countries = await prisma.country.findMany()
   * ```
   *
   *
   * Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client).
   */

  constructor(optionsArg ?: Prisma.Subset<ClientOptions, Prisma.PrismaClientOptions>);
  $on<V extends U>(eventType: V, callback: (event: V extends 'query' ? Prisma.QueryEvent : Prisma.LogEvent) => void): PrismaClient;

  /**
   * Connect with the database
   */
  $connect(): $Utils.JsPromise<void>;

  /**
   * Disconnect from the database
   */
  $disconnect(): $Utils.JsPromise<void>;

/**
   * Executes a prepared raw query and returns the number of affected rows.
   * @example
   * ```
   * const result = await prisma.$executeRaw`UPDATE User SET cool = ${true} WHERE email = ${'user@email.com'};`
   * ```
   *
   * Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client/raw-database-access).
   */
  $executeRaw<T = unknown>(query: TemplateStringsArray | Prisma.Sql, ...values: any[]): Prisma.PrismaPromise<number>;

  /**
   * Executes a raw query and returns the number of affected rows.
   * Susceptible to SQL injections, see documentation.
   * @example
   * ```
   * const result = await prisma.$executeRawUnsafe('UPDATE User SET cool = $1 WHERE email = $2 ;', true, 'user@email.com')
   * ```
   *
   * Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client/raw-database-access).
   */
  $executeRawUnsafe<T = unknown>(query: string, ...values: any[]): Prisma.PrismaPromise<number>;

  /**
   * Performs a prepared raw query and returns the `SELECT` data.
   * @example
   * ```
   * const result = await prisma.$queryRaw`SELECT * FROM User WHERE id = ${1} OR email = ${'user@email.com'};`
   * ```
   *
   * Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client/raw-database-access).
   */
  $queryRaw<T = unknown>(query: TemplateStringsArray | Prisma.Sql, ...values: any[]): Prisma.PrismaPromise<T>;

  /**
   * Performs a raw query and returns the `SELECT` data.
   * Susceptible to SQL injections, see documentation.
   * @example
   * ```
   * const result = await prisma.$queryRawUnsafe('SELECT * FROM User WHERE id = $1 OR email = $2;', 1, 'user@email.com')
   * ```
   *
   * Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client/raw-database-access).
   */
  $queryRawUnsafe<T = unknown>(query: string, ...values: any[]): Prisma.PrismaPromise<T>;


  /**
   * Allows the running of a sequence of read/write operations that are guaranteed to either succeed or fail as a whole.
   * @example
   * ```
   * const [george, bob, alice] = await prisma.$transaction([
   *   prisma.user.create({ data: { name: 'George' } }),
   *   prisma.user.create({ data: { name: 'Bob' } }),
   *   prisma.user.create({ data: { name: 'Alice' } }),
   * ])
   * ```
   * 
   * Read more in our [docs](https://www.prisma.io/docs/concepts/components/prisma-client/transactions).
   */
  $transaction<P extends Prisma.PrismaPromise<any>[]>(arg: [...P], options?: { isolationLevel?: Prisma.TransactionIsolationLevel }): $Utils.JsPromise<runtime.Types.Utils.UnwrapTuple<P>>

  $transaction<R>(fn: (prisma: Omit<PrismaClient, runtime.ITXClientDenyList>) => $Utils.JsPromise<R>, options?: { maxWait?: number, timeout?: number, isolationLevel?: Prisma.TransactionIsolationLevel }): $Utils.JsPromise<R>


  $extends: $Extensions.ExtendsHook<"extends", Prisma.TypeMapCb<ClientOptions>, ExtArgs, $Utils.Call<Prisma.TypeMapCb<ClientOptions>, {
    extArgs: ExtArgs
  }>>

      /**
   * `prisma.country`: Exposes CRUD operations for the **Country** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Countries
    * const countries = await prisma.country.findMany()
    * ```
    */
  get country(): Prisma.CountryDelegate<ExtArgs, ClientOptions>;

  /**
   * `prisma.group`: Exposes CRUD operations for the **Group** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Groups
    * const groups = await prisma.group.findMany()
    * ```
    */
  get group(): Prisma.GroupDelegate<ExtArgs, ClientOptions>;

  /**
   * `prisma.player`: Exposes CRUD operations for the **Player** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Players
    * const players = await prisma.player.findMany()
    * ```
    */
  get player(): Prisma.PlayerDelegate<ExtArgs, ClientOptions>;

  /**
   * `prisma.match`: Exposes CRUD operations for the **Match** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Matches
    * const matches = await prisma.match.findMany()
    * ```
    */
  get match(): Prisma.MatchDelegate<ExtArgs, ClientOptions>;

  /**
   * `prisma.round`: Exposes CRUD operations for the **Round** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Rounds
    * const rounds = await prisma.round.findMany()
    * ```
    */
  get round(): Prisma.RoundDelegate<ExtArgs, ClientOptions>;

  /**
   * `prisma.gameweek`: Exposes CRUD operations for the **Gameweek** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Gameweeks
    * const gameweeks = await prisma.gameweek.findMany()
    * ```
    */
  get gameweek(): Prisma.GameweekDelegate<ExtArgs, ClientOptions>;

  /**
   * `prisma.matchEvent`: Exposes CRUD operations for the **MatchEvent** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more MatchEvents
    * const matchEvents = await prisma.matchEvent.findMany()
    * ```
    */
  get matchEvent(): Prisma.MatchEventDelegate<ExtArgs, ClientOptions>;

  /**
   * `prisma.matchLineup`: Exposes CRUD operations for the **MatchLineup** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more MatchLineups
    * const matchLineups = await prisma.matchLineup.findMany()
    * ```
    */
  get matchLineup(): Prisma.MatchLineupDelegate<ExtArgs, ClientOptions>;

  /**
   * `prisma.playerMatchStat`: Exposes CRUD operations for the **PlayerMatchStat** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more PlayerMatchStats
    * const playerMatchStats = await prisma.playerMatchStat.findMany()
    * ```
    */
  get playerMatchStat(): Prisma.PlayerMatchStatDelegate<ExtArgs, ClientOptions>;

  /**
   * `prisma.scoringRule`: Exposes CRUD operations for the **ScoringRule** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more ScoringRules
    * const scoringRules = await prisma.scoringRule.findMany()
    * ```
    */
  get scoringRule(): Prisma.ScoringRuleDelegate<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>;

  /**
   * `prisma.loginOtp`: Exposes CRUD operations for the **LoginOtp** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more LoginOtps
    * const loginOtps = await prisma.loginOtp.findMany()
    * ```
    */
  get loginOtp(): Prisma.LoginOtpDelegate<ExtArgs, ClientOptions>;

  /**
   * `prisma.fantasyNews`: Exposes CRUD operations for the **FantasyNews** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more FantasyNews
    * const fantasyNews = await prisma.fantasyNews.findMany()
    * ```
    */
  get fantasyNews(): Prisma.FantasyNewsDelegate<ExtArgs, ClientOptions>;

  /**
   * `prisma.dailyQuiz`: Exposes CRUD operations for the **DailyQuiz** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more DailyQuizs
    * const dailyQuizs = await prisma.dailyQuiz.findMany()
    * ```
    */
  get dailyQuiz(): Prisma.DailyQuizDelegate<ExtArgs, ClientOptions>;

  /**
   * `prisma.quizQuestion`: Exposes CRUD operations for the **QuizQuestion** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more QuizQuestions
    * const quizQuestions = await prisma.quizQuestion.findMany()
    * ```
    */
  get quizQuestion(): Prisma.QuizQuestionDelegate<ExtArgs, ClientOptions>;

  /**
   * `prisma.quizSubmission`: Exposes CRUD operations for the **QuizSubmission** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more QuizSubmissions
    * const quizSubmissions = await prisma.quizSubmission.findMany()
    * ```
    */
  get quizSubmission(): Prisma.QuizSubmissionDelegate<ExtArgs, ClientOptions>;

  /**
   * `prisma.goldenCard`: Exposes CRUD operations for the **GoldenCard** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more GoldenCards
    * const goldenCards = await prisma.goldenCard.findMany()
    * ```
    */
  get goldenCard(): Prisma.GoldenCardDelegate<ExtArgs, ClientOptions>;

  /**
   * `prisma.session`: Exposes CRUD operations for the **Session** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Sessions
    * const sessions = await prisma.session.findMany()
    * ```
    */
  get session(): Prisma.SessionDelegate<ExtArgs, ClientOptions>;

  /**
   * `prisma.team`: Exposes CRUD operations for the **Team** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Teams
    * const teams = await prisma.team.findMany()
    * ```
    */
  get team(): Prisma.TeamDelegate<ExtArgs, ClientOptions>;

  /**
   * `prisma.teamPlayer`: Exposes CRUD operations for the **TeamPlayer** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more TeamPlayers
    * const teamPlayers = await prisma.teamPlayer.findMany()
    * ```
    */
  get teamPlayer(): Prisma.TeamPlayerDelegate<ExtArgs, ClientOptions>;

  /**
   * `prisma.package`: Exposes CRUD operations for the **Package** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Packages
    * const packages = await prisma.package.findMany()
    * ```
    */
  get package(): Prisma.PackageDelegate<ExtArgs, ClientOptions>;

  /**
   * `prisma.payment`: Exposes CRUD operations for the **Payment** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Payments
    * const payments = await prisma.payment.findMany()
    * ```
    */
  get payment(): Prisma.PaymentDelegate<ExtArgs, ClientOptions>;
}

export namespace Prisma {
  export import DMMF = runtime.DMMF

  export type PrismaPromise<T> = $Public.PrismaPromise<T>

  /**
   * Validator
   */
  export import validator = runtime.Public.validator

  /**
   * Prisma Errors
   */
  export import PrismaClientKnownRequestError = runtime.PrismaClientKnownRequestError
  export import PrismaClientUnknownRequestError = runtime.PrismaClientUnknownRequestError
  export import PrismaClientRustPanicError = runtime.PrismaClientRustPanicError
  export import PrismaClientInitializationError = runtime.PrismaClientInitializationError
  export import PrismaClientValidationError = runtime.PrismaClientValidationError

  /**
   * Re-export of sql-template-tag
   */
  export import sql = runtime.sqltag
  export import empty = runtime.empty
  export import join = runtime.join
  export import raw = runtime.raw
  export import Sql = runtime.Sql



  /**
   * Decimal.js
   */
  export import Decimal = runtime.Decimal

  export type DecimalJsLike = runtime.DecimalJsLike

  /**
   * Metrics
   */
  export type Metrics = runtime.Metrics
  export type Metric<T> = runtime.Metric<T>
  export type MetricHistogram = runtime.MetricHistogram
  export type MetricHistogramBucket = runtime.MetricHistogramBucket

  /**
  * Extensions
  */
  export import Extension = $Extensions.UserArgs
  export import getExtensionContext = runtime.Extensions.getExtensionContext
  export import Args = $Public.Args
  export import Payload = $Public.Payload
  export import Result = $Public.Result
  export import Exact = $Public.Exact

  /**
   * Prisma Client JS version: 6.19.3
   * Query Engine version: c2990dca591cba766e3b7ef5d9e8a84796e47ab7
   */
  export type PrismaVersion = {
    client: string
  }

  export const prismaVersion: PrismaVersion

  /**
   * Utility Types
   */


  export import Bytes = runtime.Bytes
  export import JsonObject = runtime.JsonObject
  export import JsonArray = runtime.JsonArray
  export import JsonValue = runtime.JsonValue
  export import InputJsonObject = runtime.InputJsonObject
  export import InputJsonArray = runtime.InputJsonArray
  export import InputJsonValue = runtime.InputJsonValue

  /**
   * Types of the values used to represent different kinds of `null` values when working with JSON fields.
   *
   * @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field
   */
  namespace NullTypes {
    /**
    * Type of `Prisma.DbNull`.
    *
    * You cannot use other instances of this class. Please use the `Prisma.DbNull` value.
    *
    * @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field
    */
    class DbNull {
      private DbNull: never
      private constructor()
    }

    /**
    * Type of `Prisma.JsonNull`.
    *
    * You cannot use other instances of this class. Please use the `Prisma.JsonNull` value.
    *
    * @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field
    */
    class JsonNull {
      private JsonNull: never
      private constructor()
    }

    /**
    * Type of `Prisma.AnyNull`.
    *
    * You cannot use other instances of this class. Please use the `Prisma.AnyNull` value.
    *
    * @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field
    */
    class AnyNull {
      private AnyNull: never
      private constructor()
    }
  }

  /**
   * Helper for filtering JSON entries that have `null` on the database (empty on the db)
   *
   * @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field
   */
  export const DbNull: NullTypes.DbNull

  /**
   * Helper for filtering JSON entries that have JSON `null` values (not empty on the db)
   *
   * @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field
   */
  export const JsonNull: NullTypes.JsonNull

  /**
   * Helper for filtering JSON entries that are `Prisma.DbNull` or `Prisma.JsonNull`
   *
   * @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field
   */
  export const AnyNull: NullTypes.AnyNull

  type SelectAndInclude = {
    select: any
    include: any
  }

  type SelectAndOmit = {
    select: any
    omit: any
  }

  /**
   * Get the type of the value, that the Promise holds.
   */
  export type PromiseType<T extends PromiseLike<any>> = T extends PromiseLike<infer U> ? U : T;

  /**
   * Get the return type of a function which returns a Promise.
   */
  export type PromiseReturnType<T extends (...args: any) => $Utils.JsPromise<any>> = PromiseType<ReturnType<T>>

  /**
   * From T, pick a set of properties whose keys are in the union K
   */
  type Prisma__Pick<T, K extends keyof T> = {
      [P in K]: T[P];
  };


  export type Enumerable<T> = T | Array<T>;

  export type RequiredKeys<T> = {
    [K in keyof T]-?: {} extends Prisma__Pick<T, K> ? never : K
  }[keyof T]

  export type TruthyKeys<T> = keyof {
    [K in keyof T as T[K] extends false | undefined | null ? never : K]: K
  }

  export type TrueKeys<T> = TruthyKeys<Prisma__Pick<T, RequiredKeys<T>>>

  /**
   * Subset
   * @desc From `T` pick properties that exist in `U`. Simple version of Intersection
   */
  export type Subset<T, U> = {
    [key in keyof T]: key extends keyof U ? T[key] : never;
  };

  /**
   * SelectSubset
   * @desc From `T` pick properties that exist in `U`. Simple version of Intersection.
   * Additionally, it validates, if both select and include are present. If the case, it errors.
   */
  export type SelectSubset<T, U> = {
    [key in keyof T]: key extends keyof U ? T[key] : never
  } &
    (T extends SelectAndInclude
      ? 'Please either choose `select` or `include`.'
      : T extends SelectAndOmit
        ? 'Please either choose `select` or `omit`.'
        : {})

  /**
   * Subset + Intersection
   * @desc From `T` pick properties that exist in `U` and intersect `K`
   */
  export type SubsetIntersection<T, U, K> = {
    [key in keyof T]: key extends keyof U ? T[key] : never
  } &
    K

  type Without<T, U> = { [P in Exclude<keyof T, keyof U>]?: never };

  /**
   * XOR is needed to have a real mutually exclusive union type
   * https://stackoverflow.com/questions/42123407/does-typescript-support-mutually-exclusive-types
   */
  type XOR<T, U> =
    T extends object ?
    U extends object ?
      (Without<T, U> & U) | (Without<U, T> & T)
    : U : T


  /**
   * Is T a Record?
   */
  type IsObject<T extends any> = T extends Array<any>
  ? False
  : T extends Date
  ? False
  : T extends Uint8Array
  ? False
  : T extends BigInt
  ? False
  : T extends object
  ? True
  : False


  /**
   * If it's T[], return T
   */
  export type UnEnumerate<T extends unknown> = T extends Array<infer U> ? U : T

  /**
   * From ts-toolbelt
   */

  type __Either<O extends object, K extends Key> = Omit<O, K> &
    {
      // Merge all but K
      [P in K]: Prisma__Pick<O, P & keyof O> // With K possibilities
    }[K]

  type EitherStrict<O extends object, K extends Key> = Strict<__Either<O, K>>

  type EitherLoose<O extends object, K extends Key> = ComputeRaw<__Either<O, K>>

  type _Either<
    O extends object,
    K extends Key,
    strict extends Boolean
  > = {
    1: EitherStrict<O, K>
    0: EitherLoose<O, K>
  }[strict]

  type Either<
    O extends object,
    K extends Key,
    strict extends Boolean = 1
  > = O extends unknown ? _Either<O, K, strict> : never

  export type Union = any

  type PatchUndefined<O extends object, O1 extends object> = {
    [K in keyof O]: O[K] extends undefined ? At<O1, K> : O[K]
  } & {}

  /** Helper Types for "Merge" **/
  export type IntersectOf<U extends Union> = (
    U extends unknown ? (k: U) => void : never
  ) extends (k: infer I) => void
    ? I
    : never

  export type Overwrite<O extends object, O1 extends object> = {
      [K in keyof O]: K extends keyof O1 ? O1[K] : O[K];
  } & {};

  type _Merge<U extends object> = IntersectOf<Overwrite<U, {
      [K in keyof U]-?: At<U, K>;
  }>>;

  type Key = string | number | symbol;
  type AtBasic<O extends object, K extends Key> = K extends keyof O ? O[K] : never;
  type AtStrict<O extends object, K extends Key> = O[K & keyof O];
  type AtLoose<O extends object, K extends Key> = O extends unknown ? AtStrict<O, K> : never;
  export type At<O extends object, K extends Key, strict extends Boolean = 1> = {
      1: AtStrict<O, K>;
      0: AtLoose<O, K>;
  }[strict];

  export type ComputeRaw<A extends any> = A extends Function ? A : {
    [K in keyof A]: A[K];
  } & {};

  export type OptionalFlat<O> = {
    [K in keyof O]?: O[K];
  } & {};

  type _Record<K extends keyof any, T> = {
    [P in K]: T;
  };

  // cause typescript not to expand types and preserve names
  type NoExpand<T> = T extends unknown ? T : never;

  // this type assumes the passed object is entirely optional
  type AtLeast<O extends object, K extends string> = NoExpand<
    O extends unknown
    ? | (K extends keyof O ? { [P in K]: O[P] } & O : O)
      | {[P in keyof O as P extends K ? P : never]-?: O[P]} & O
    : never>;

  type _Strict<U, _U = U> = U extends unknown ? U & OptionalFlat<_Record<Exclude<Keys<_U>, keyof U>, never>> : never;

  export type Strict<U extends object> = ComputeRaw<_Strict<U>>;
  /** End Helper Types for "Merge" **/

  export type Merge<U extends object> = ComputeRaw<_Merge<Strict<U>>>;

  /**
  A [[Boolean]]
  */
  export type Boolean = True | False

  // /**
  // 1
  // */
  export type True = 1

  /**
  0
  */
  export type False = 0

  export type Not<B extends Boolean> = {
    0: 1
    1: 0
  }[B]

  export type Extends<A1 extends any, A2 extends any> = [A1] extends [never]
    ? 0 // anything `never` is false
    : A1 extends A2
    ? 1
    : 0

  export type Has<U extends Union, U1 extends Union> = Not<
    Extends<Exclude<U1, U>, U1>
  >

  export type Or<B1 extends Boolean, B2 extends Boolean> = {
    0: {
      0: 0
      1: 1
    }
    1: {
      0: 1
      1: 1
    }
  }[B1][B2]

  export type Keys<U extends Union> = U extends unknown ? keyof U : never

  type Cast<A, B> = A extends B ? A : B;

  export const type: unique symbol;



  /**
   * Used by group by
   */

  export type GetScalarType<T, O> = O extends object ? {
    [P in keyof T]: P extends keyof O
      ? O[P]
      : never
  } : never

  type FieldPaths<
    T,
    U = Omit<T, '_avg' | '_sum' | '_count' | '_min' | '_max'>
  > = IsObject<T> extends True ? U : T

  type GetHavingFields<T> = {
    [K in keyof T]: Or<
      Or<Extends<'OR', K>, Extends<'AND', K>>,
      Extends<'NOT', K>
    > extends True
      ? // infer is only needed to not hit TS limit
        // based on the brilliant idea of Pierre-Antoine Mills
        // https://github.com/microsoft/TypeScript/issues/30188#issuecomment-478938437
        T[K] extends infer TK
        ? GetHavingFields<UnEnumerate<TK> extends object ? Merge<UnEnumerate<TK>> : never>
        : never
      : {} extends FieldPaths<T[K]>
      ? never
      : K
  }[keyof T]

  /**
   * Convert tuple to union
   */
  type _TupleToUnion<T> = T extends (infer E)[] ? E : never
  type TupleToUnion<K extends readonly any[]> = _TupleToUnion<K>
  type MaybeTupleToUnion<T> = T extends any[] ? TupleToUnion<T> : T

  /**
   * Like `Pick`, but additionally can also accept an array of keys
   */
  type PickEnumerable<T, K extends Enumerable<keyof T> | keyof T> = Prisma__Pick<T, MaybeTupleToUnion<K>>

  /**
   * Exclude all keys with underscores
   */
  type ExcludeUnderscoreKeys<T extends string> = T extends `_${string}` ? never : T


  export type FieldRef<Model, FieldType> = runtime.FieldRef<Model, FieldType>

  type FieldRefInputType<Model, FieldType> = Model extends never ? never : FieldRef<Model, FieldType>


  export const ModelName: {
    Country: 'Country',
    Group: 'Group',
    Player: 'Player',
    Match: 'Match',
    Round: 'Round',
    Gameweek: 'Gameweek',
    MatchEvent: 'MatchEvent',
    MatchLineup: 'MatchLineup',
    PlayerMatchStat: 'PlayerMatchStat',
    ScoringRule: 'ScoringRule',
    User: 'User',
    LoginOtp: 'LoginOtp',
    FantasyNews: 'FantasyNews',
    DailyQuiz: 'DailyQuiz',
    QuizQuestion: 'QuizQuestion',
    QuizSubmission: 'QuizSubmission',
    GoldenCard: 'GoldenCard',
    Session: 'Session',
    Team: 'Team',
    TeamPlayer: 'TeamPlayer',
    Package: 'Package',
    Payment: 'Payment'
  };

  export type ModelName = (typeof ModelName)[keyof typeof ModelName]


  export type Datasources = {
    db?: Datasource
  }

  interface TypeMapCb<ClientOptions = {}> extends $Utils.Fn<{extArgs: $Extensions.InternalArgs }, $Utils.Record<string, any>> {
    returns: Prisma.TypeMap<this['params']['extArgs'], ClientOptions extends { omit: infer OmitOptions } ? OmitOptions : {}>
  }

  export type TypeMap<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> = {
    globalOmitOptions: {
      omit: GlobalOmitOptions
    }
    meta: {
      modelProps: "country" | "group" | "player" | "match" | "round" | "gameweek" | "matchEvent" | "matchLineup" | "playerMatchStat" | "scoringRule" | "user" | "loginOtp" | "fantasyNews" | "dailyQuiz" | "quizQuestion" | "quizSubmission" | "goldenCard" | "session" | "team" | "teamPlayer" | "package" | "payment"
      txIsolationLevel: Prisma.TransactionIsolationLevel
    }
    model: {
      Country: {
        payload: Prisma.$CountryPayload<ExtArgs>
        fields: Prisma.CountryFieldRefs
        operations: {
          findUnique: {
            args: Prisma.CountryFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CountryPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.CountryFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CountryPayload>
          }
          findFirst: {
            args: Prisma.CountryFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CountryPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.CountryFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CountryPayload>
          }
          findMany: {
            args: Prisma.CountryFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CountryPayload>[]
          }
          create: {
            args: Prisma.CountryCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CountryPayload>
          }
          createMany: {
            args: Prisma.CountryCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.CountryCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CountryPayload>[]
          }
          delete: {
            args: Prisma.CountryDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CountryPayload>
          }
          update: {
            args: Prisma.CountryUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CountryPayload>
          }
          deleteMany: {
            args: Prisma.CountryDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.CountryUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.CountryUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CountryPayload>[]
          }
          upsert: {
            args: Prisma.CountryUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CountryPayload>
          }
          aggregate: {
            args: Prisma.CountryAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateCountry>
          }
          groupBy: {
            args: Prisma.CountryGroupByArgs<ExtArgs>
            result: $Utils.Optional<CountryGroupByOutputType>[]
          }
          count: {
            args: Prisma.CountryCountArgs<ExtArgs>
            result: $Utils.Optional<CountryCountAggregateOutputType> | number
          }
        }
      }
      Group: {
        payload: Prisma.$GroupPayload<ExtArgs>
        fields: Prisma.GroupFieldRefs
        operations: {
          findUnique: {
            args: Prisma.GroupFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$GroupPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.GroupFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$GroupPayload>
          }
          findFirst: {
            args: Prisma.GroupFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$GroupPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.GroupFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$GroupPayload>
          }
          findMany: {
            args: Prisma.GroupFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$GroupPayload>[]
          }
          create: {
            args: Prisma.GroupCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$GroupPayload>
          }
          createMany: {
            args: Prisma.GroupCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.GroupCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$GroupPayload>[]
          }
          delete: {
            args: Prisma.GroupDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$GroupPayload>
          }
          update: {
            args: Prisma.GroupUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$GroupPayload>
          }
          deleteMany: {
            args: Prisma.GroupDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.GroupUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.GroupUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$GroupPayload>[]
          }
          upsert: {
            args: Prisma.GroupUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$GroupPayload>
          }
          aggregate: {
            args: Prisma.GroupAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateGroup>
          }
          groupBy: {
            args: Prisma.GroupGroupByArgs<ExtArgs>
            result: $Utils.Optional<GroupGroupByOutputType>[]
          }
          count: {
            args: Prisma.GroupCountArgs<ExtArgs>
            result: $Utils.Optional<GroupCountAggregateOutputType> | number
          }
        }
      }
      Player: {
        payload: Prisma.$PlayerPayload<ExtArgs>
        fields: Prisma.PlayerFieldRefs
        operations: {
          findUnique: {
            args: Prisma.PlayerFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PlayerPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.PlayerFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PlayerPayload>
          }
          findFirst: {
            args: Prisma.PlayerFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PlayerPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.PlayerFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PlayerPayload>
          }
          findMany: {
            args: Prisma.PlayerFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PlayerPayload>[]
          }
          create: {
            args: Prisma.PlayerCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PlayerPayload>
          }
          createMany: {
            args: Prisma.PlayerCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.PlayerCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PlayerPayload>[]
          }
          delete: {
            args: Prisma.PlayerDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PlayerPayload>
          }
          update: {
            args: Prisma.PlayerUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PlayerPayload>
          }
          deleteMany: {
            args: Prisma.PlayerDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.PlayerUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.PlayerUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PlayerPayload>[]
          }
          upsert: {
            args: Prisma.PlayerUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PlayerPayload>
          }
          aggregate: {
            args: Prisma.PlayerAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregatePlayer>
          }
          groupBy: {
            args: Prisma.PlayerGroupByArgs<ExtArgs>
            result: $Utils.Optional<PlayerGroupByOutputType>[]
          }
          count: {
            args: Prisma.PlayerCountArgs<ExtArgs>
            result: $Utils.Optional<PlayerCountAggregateOutputType> | number
          }
        }
      }
      Match: {
        payload: Prisma.$MatchPayload<ExtArgs>
        fields: Prisma.MatchFieldRefs
        operations: {
          findUnique: {
            args: Prisma.MatchFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MatchPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.MatchFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MatchPayload>
          }
          findFirst: {
            args: Prisma.MatchFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MatchPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.MatchFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MatchPayload>
          }
          findMany: {
            args: Prisma.MatchFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MatchPayload>[]
          }
          create: {
            args: Prisma.MatchCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MatchPayload>
          }
          createMany: {
            args: Prisma.MatchCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.MatchCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MatchPayload>[]
          }
          delete: {
            args: Prisma.MatchDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MatchPayload>
          }
          update: {
            args: Prisma.MatchUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MatchPayload>
          }
          deleteMany: {
            args: Prisma.MatchDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.MatchUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.MatchUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MatchPayload>[]
          }
          upsert: {
            args: Prisma.MatchUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MatchPayload>
          }
          aggregate: {
            args: Prisma.MatchAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateMatch>
          }
          groupBy: {
            args: Prisma.MatchGroupByArgs<ExtArgs>
            result: $Utils.Optional<MatchGroupByOutputType>[]
          }
          count: {
            args: Prisma.MatchCountArgs<ExtArgs>
            result: $Utils.Optional<MatchCountAggregateOutputType> | number
          }
        }
      }
      Round: {
        payload: Prisma.$RoundPayload<ExtArgs>
        fields: Prisma.RoundFieldRefs
        operations: {
          findUnique: {
            args: Prisma.RoundFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$RoundPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.RoundFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$RoundPayload>
          }
          findFirst: {
            args: Prisma.RoundFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$RoundPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.RoundFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$RoundPayload>
          }
          findMany: {
            args: Prisma.RoundFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$RoundPayload>[]
          }
          create: {
            args: Prisma.RoundCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$RoundPayload>
          }
          createMany: {
            args: Prisma.RoundCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.RoundCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$RoundPayload>[]
          }
          delete: {
            args: Prisma.RoundDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$RoundPayload>
          }
          update: {
            args: Prisma.RoundUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$RoundPayload>
          }
          deleteMany: {
            args: Prisma.RoundDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.RoundUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.RoundUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$RoundPayload>[]
          }
          upsert: {
            args: Prisma.RoundUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$RoundPayload>
          }
          aggregate: {
            args: Prisma.RoundAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateRound>
          }
          groupBy: {
            args: Prisma.RoundGroupByArgs<ExtArgs>
            result: $Utils.Optional<RoundGroupByOutputType>[]
          }
          count: {
            args: Prisma.RoundCountArgs<ExtArgs>
            result: $Utils.Optional<RoundCountAggregateOutputType> | number
          }
        }
      }
      Gameweek: {
        payload: Prisma.$GameweekPayload<ExtArgs>
        fields: Prisma.GameweekFieldRefs
        operations: {
          findUnique: {
            args: Prisma.GameweekFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$GameweekPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.GameweekFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$GameweekPayload>
          }
          findFirst: {
            args: Prisma.GameweekFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$GameweekPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.GameweekFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$GameweekPayload>
          }
          findMany: {
            args: Prisma.GameweekFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$GameweekPayload>[]
          }
          create: {
            args: Prisma.GameweekCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$GameweekPayload>
          }
          createMany: {
            args: Prisma.GameweekCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.GameweekCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$GameweekPayload>[]
          }
          delete: {
            args: Prisma.GameweekDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$GameweekPayload>
          }
          update: {
            args: Prisma.GameweekUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$GameweekPayload>
          }
          deleteMany: {
            args: Prisma.GameweekDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.GameweekUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.GameweekUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$GameweekPayload>[]
          }
          upsert: {
            args: Prisma.GameweekUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$GameweekPayload>
          }
          aggregate: {
            args: Prisma.GameweekAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateGameweek>
          }
          groupBy: {
            args: Prisma.GameweekGroupByArgs<ExtArgs>
            result: $Utils.Optional<GameweekGroupByOutputType>[]
          }
          count: {
            args: Prisma.GameweekCountArgs<ExtArgs>
            result: $Utils.Optional<GameweekCountAggregateOutputType> | number
          }
        }
      }
      MatchEvent: {
        payload: Prisma.$MatchEventPayload<ExtArgs>
        fields: Prisma.MatchEventFieldRefs
        operations: {
          findUnique: {
            args: Prisma.MatchEventFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MatchEventPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.MatchEventFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MatchEventPayload>
          }
          findFirst: {
            args: Prisma.MatchEventFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MatchEventPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.MatchEventFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MatchEventPayload>
          }
          findMany: {
            args: Prisma.MatchEventFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MatchEventPayload>[]
          }
          create: {
            args: Prisma.MatchEventCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MatchEventPayload>
          }
          createMany: {
            args: Prisma.MatchEventCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.MatchEventCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MatchEventPayload>[]
          }
          delete: {
            args: Prisma.MatchEventDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MatchEventPayload>
          }
          update: {
            args: Prisma.MatchEventUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MatchEventPayload>
          }
          deleteMany: {
            args: Prisma.MatchEventDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.MatchEventUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.MatchEventUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MatchEventPayload>[]
          }
          upsert: {
            args: Prisma.MatchEventUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MatchEventPayload>
          }
          aggregate: {
            args: Prisma.MatchEventAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateMatchEvent>
          }
          groupBy: {
            args: Prisma.MatchEventGroupByArgs<ExtArgs>
            result: $Utils.Optional<MatchEventGroupByOutputType>[]
          }
          count: {
            args: Prisma.MatchEventCountArgs<ExtArgs>
            result: $Utils.Optional<MatchEventCountAggregateOutputType> | number
          }
        }
      }
      MatchLineup: {
        payload: Prisma.$MatchLineupPayload<ExtArgs>
        fields: Prisma.MatchLineupFieldRefs
        operations: {
          findUnique: {
            args: Prisma.MatchLineupFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MatchLineupPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.MatchLineupFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MatchLineupPayload>
          }
          findFirst: {
            args: Prisma.MatchLineupFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MatchLineupPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.MatchLineupFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MatchLineupPayload>
          }
          findMany: {
            args: Prisma.MatchLineupFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MatchLineupPayload>[]
          }
          create: {
            args: Prisma.MatchLineupCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MatchLineupPayload>
          }
          createMany: {
            args: Prisma.MatchLineupCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.MatchLineupCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MatchLineupPayload>[]
          }
          delete: {
            args: Prisma.MatchLineupDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MatchLineupPayload>
          }
          update: {
            args: Prisma.MatchLineupUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MatchLineupPayload>
          }
          deleteMany: {
            args: Prisma.MatchLineupDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.MatchLineupUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.MatchLineupUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MatchLineupPayload>[]
          }
          upsert: {
            args: Prisma.MatchLineupUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MatchLineupPayload>
          }
          aggregate: {
            args: Prisma.MatchLineupAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateMatchLineup>
          }
          groupBy: {
            args: Prisma.MatchLineupGroupByArgs<ExtArgs>
            result: $Utils.Optional<MatchLineupGroupByOutputType>[]
          }
          count: {
            args: Prisma.MatchLineupCountArgs<ExtArgs>
            result: $Utils.Optional<MatchLineupCountAggregateOutputType> | number
          }
        }
      }
      PlayerMatchStat: {
        payload: Prisma.$PlayerMatchStatPayload<ExtArgs>
        fields: Prisma.PlayerMatchStatFieldRefs
        operations: {
          findUnique: {
            args: Prisma.PlayerMatchStatFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PlayerMatchStatPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.PlayerMatchStatFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PlayerMatchStatPayload>
          }
          findFirst: {
            args: Prisma.PlayerMatchStatFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PlayerMatchStatPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.PlayerMatchStatFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PlayerMatchStatPayload>
          }
          findMany: {
            args: Prisma.PlayerMatchStatFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PlayerMatchStatPayload>[]
          }
          create: {
            args: Prisma.PlayerMatchStatCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PlayerMatchStatPayload>
          }
          createMany: {
            args: Prisma.PlayerMatchStatCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.PlayerMatchStatCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PlayerMatchStatPayload>[]
          }
          delete: {
            args: Prisma.PlayerMatchStatDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PlayerMatchStatPayload>
          }
          update: {
            args: Prisma.PlayerMatchStatUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PlayerMatchStatPayload>
          }
          deleteMany: {
            args: Prisma.PlayerMatchStatDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.PlayerMatchStatUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.PlayerMatchStatUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PlayerMatchStatPayload>[]
          }
          upsert: {
            args: Prisma.PlayerMatchStatUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PlayerMatchStatPayload>
          }
          aggregate: {
            args: Prisma.PlayerMatchStatAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregatePlayerMatchStat>
          }
          groupBy: {
            args: Prisma.PlayerMatchStatGroupByArgs<ExtArgs>
            result: $Utils.Optional<PlayerMatchStatGroupByOutputType>[]
          }
          count: {
            args: Prisma.PlayerMatchStatCountArgs<ExtArgs>
            result: $Utils.Optional<PlayerMatchStatCountAggregateOutputType> | number
          }
        }
      }
      ScoringRule: {
        payload: Prisma.$ScoringRulePayload<ExtArgs>
        fields: Prisma.ScoringRuleFieldRefs
        operations: {
          findUnique: {
            args: Prisma.ScoringRuleFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ScoringRulePayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.ScoringRuleFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ScoringRulePayload>
          }
          findFirst: {
            args: Prisma.ScoringRuleFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ScoringRulePayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.ScoringRuleFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ScoringRulePayload>
          }
          findMany: {
            args: Prisma.ScoringRuleFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ScoringRulePayload>[]
          }
          create: {
            args: Prisma.ScoringRuleCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ScoringRulePayload>
          }
          createMany: {
            args: Prisma.ScoringRuleCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.ScoringRuleCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ScoringRulePayload>[]
          }
          delete: {
            args: Prisma.ScoringRuleDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ScoringRulePayload>
          }
          update: {
            args: Prisma.ScoringRuleUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ScoringRulePayload>
          }
          deleteMany: {
            args: Prisma.ScoringRuleDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.ScoringRuleUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.ScoringRuleUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ScoringRulePayload>[]
          }
          upsert: {
            args: Prisma.ScoringRuleUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ScoringRulePayload>
          }
          aggregate: {
            args: Prisma.ScoringRuleAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateScoringRule>
          }
          groupBy: {
            args: Prisma.ScoringRuleGroupByArgs<ExtArgs>
            result: $Utils.Optional<ScoringRuleGroupByOutputType>[]
          }
          count: {
            args: Prisma.ScoringRuleCountArgs<ExtArgs>
            result: $Utils.Optional<ScoringRuleCountAggregateOutputType> | number
          }
        }
      }
      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
          }
          createManyAndReturn: {
            args: Prisma.UserCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserPayload>[]
          }
          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
          }
          updateManyAndReturn: {
            args: Prisma.UserUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserPayload>[]
          }
          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>[]
          }
          count: {
            args: Prisma.UserCountArgs<ExtArgs>
            result: $Utils.Optional<UserCountAggregateOutputType> | number
          }
        }
      }
      LoginOtp: {
        payload: Prisma.$LoginOtpPayload<ExtArgs>
        fields: Prisma.LoginOtpFieldRefs
        operations: {
          findUnique: {
            args: Prisma.LoginOtpFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$LoginOtpPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.LoginOtpFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$LoginOtpPayload>
          }
          findFirst: {
            args: Prisma.LoginOtpFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$LoginOtpPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.LoginOtpFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$LoginOtpPayload>
          }
          findMany: {
            args: Prisma.LoginOtpFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$LoginOtpPayload>[]
          }
          create: {
            args: Prisma.LoginOtpCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$LoginOtpPayload>
          }
          createMany: {
            args: Prisma.LoginOtpCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.LoginOtpCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$LoginOtpPayload>[]
          }
          delete: {
            args: Prisma.LoginOtpDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$LoginOtpPayload>
          }
          update: {
            args: Prisma.LoginOtpUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$LoginOtpPayload>
          }
          deleteMany: {
            args: Prisma.LoginOtpDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.LoginOtpUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.LoginOtpUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$LoginOtpPayload>[]
          }
          upsert: {
            args: Prisma.LoginOtpUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$LoginOtpPayload>
          }
          aggregate: {
            args: Prisma.LoginOtpAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateLoginOtp>
          }
          groupBy: {
            args: Prisma.LoginOtpGroupByArgs<ExtArgs>
            result: $Utils.Optional<LoginOtpGroupByOutputType>[]
          }
          count: {
            args: Prisma.LoginOtpCountArgs<ExtArgs>
            result: $Utils.Optional<LoginOtpCountAggregateOutputType> | number
          }
        }
      }
      FantasyNews: {
        payload: Prisma.$FantasyNewsPayload<ExtArgs>
        fields: Prisma.FantasyNewsFieldRefs
        operations: {
          findUnique: {
            args: Prisma.FantasyNewsFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$FantasyNewsPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.FantasyNewsFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$FantasyNewsPayload>
          }
          findFirst: {
            args: Prisma.FantasyNewsFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$FantasyNewsPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.FantasyNewsFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$FantasyNewsPayload>
          }
          findMany: {
            args: Prisma.FantasyNewsFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$FantasyNewsPayload>[]
          }
          create: {
            args: Prisma.FantasyNewsCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$FantasyNewsPayload>
          }
          createMany: {
            args: Prisma.FantasyNewsCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.FantasyNewsCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$FantasyNewsPayload>[]
          }
          delete: {
            args: Prisma.FantasyNewsDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$FantasyNewsPayload>
          }
          update: {
            args: Prisma.FantasyNewsUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$FantasyNewsPayload>
          }
          deleteMany: {
            args: Prisma.FantasyNewsDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.FantasyNewsUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.FantasyNewsUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$FantasyNewsPayload>[]
          }
          upsert: {
            args: Prisma.FantasyNewsUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$FantasyNewsPayload>
          }
          aggregate: {
            args: Prisma.FantasyNewsAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateFantasyNews>
          }
          groupBy: {
            args: Prisma.FantasyNewsGroupByArgs<ExtArgs>
            result: $Utils.Optional<FantasyNewsGroupByOutputType>[]
          }
          count: {
            args: Prisma.FantasyNewsCountArgs<ExtArgs>
            result: $Utils.Optional<FantasyNewsCountAggregateOutputType> | number
          }
        }
      }
      DailyQuiz: {
        payload: Prisma.$DailyQuizPayload<ExtArgs>
        fields: Prisma.DailyQuizFieldRefs
        operations: {
          findUnique: {
            args: Prisma.DailyQuizFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$DailyQuizPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.DailyQuizFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$DailyQuizPayload>
          }
          findFirst: {
            args: Prisma.DailyQuizFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$DailyQuizPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.DailyQuizFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$DailyQuizPayload>
          }
          findMany: {
            args: Prisma.DailyQuizFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$DailyQuizPayload>[]
          }
          create: {
            args: Prisma.DailyQuizCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$DailyQuizPayload>
          }
          createMany: {
            args: Prisma.DailyQuizCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.DailyQuizCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$DailyQuizPayload>[]
          }
          delete: {
            args: Prisma.DailyQuizDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$DailyQuizPayload>
          }
          update: {
            args: Prisma.DailyQuizUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$DailyQuizPayload>
          }
          deleteMany: {
            args: Prisma.DailyQuizDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.DailyQuizUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.DailyQuizUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$DailyQuizPayload>[]
          }
          upsert: {
            args: Prisma.DailyQuizUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$DailyQuizPayload>
          }
          aggregate: {
            args: Prisma.DailyQuizAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateDailyQuiz>
          }
          groupBy: {
            args: Prisma.DailyQuizGroupByArgs<ExtArgs>
            result: $Utils.Optional<DailyQuizGroupByOutputType>[]
          }
          count: {
            args: Prisma.DailyQuizCountArgs<ExtArgs>
            result: $Utils.Optional<DailyQuizCountAggregateOutputType> | number
          }
        }
      }
      QuizQuestion: {
        payload: Prisma.$QuizQuestionPayload<ExtArgs>
        fields: Prisma.QuizQuestionFieldRefs
        operations: {
          findUnique: {
            args: Prisma.QuizQuestionFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$QuizQuestionPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.QuizQuestionFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$QuizQuestionPayload>
          }
          findFirst: {
            args: Prisma.QuizQuestionFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$QuizQuestionPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.QuizQuestionFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$QuizQuestionPayload>
          }
          findMany: {
            args: Prisma.QuizQuestionFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$QuizQuestionPayload>[]
          }
          create: {
            args: Prisma.QuizQuestionCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$QuizQuestionPayload>
          }
          createMany: {
            args: Prisma.QuizQuestionCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.QuizQuestionCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$QuizQuestionPayload>[]
          }
          delete: {
            args: Prisma.QuizQuestionDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$QuizQuestionPayload>
          }
          update: {
            args: Prisma.QuizQuestionUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$QuizQuestionPayload>
          }
          deleteMany: {
            args: Prisma.QuizQuestionDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.QuizQuestionUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.QuizQuestionUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$QuizQuestionPayload>[]
          }
          upsert: {
            args: Prisma.QuizQuestionUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$QuizQuestionPayload>
          }
          aggregate: {
            args: Prisma.QuizQuestionAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateQuizQuestion>
          }
          groupBy: {
            args: Prisma.QuizQuestionGroupByArgs<ExtArgs>
            result: $Utils.Optional<QuizQuestionGroupByOutputType>[]
          }
          count: {
            args: Prisma.QuizQuestionCountArgs<ExtArgs>
            result: $Utils.Optional<QuizQuestionCountAggregateOutputType> | number
          }
        }
      }
      QuizSubmission: {
        payload: Prisma.$QuizSubmissionPayload<ExtArgs>
        fields: Prisma.QuizSubmissionFieldRefs
        operations: {
          findUnique: {
            args: Prisma.QuizSubmissionFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$QuizSubmissionPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.QuizSubmissionFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$QuizSubmissionPayload>
          }
          findFirst: {
            args: Prisma.QuizSubmissionFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$QuizSubmissionPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.QuizSubmissionFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$QuizSubmissionPayload>
          }
          findMany: {
            args: Prisma.QuizSubmissionFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$QuizSubmissionPayload>[]
          }
          create: {
            args: Prisma.QuizSubmissionCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$QuizSubmissionPayload>
          }
          createMany: {
            args: Prisma.QuizSubmissionCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.QuizSubmissionCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$QuizSubmissionPayload>[]
          }
          delete: {
            args: Prisma.QuizSubmissionDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$QuizSubmissionPayload>
          }
          update: {
            args: Prisma.QuizSubmissionUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$QuizSubmissionPayload>
          }
          deleteMany: {
            args: Prisma.QuizSubmissionDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.QuizSubmissionUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.QuizSubmissionUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$QuizSubmissionPayload>[]
          }
          upsert: {
            args: Prisma.QuizSubmissionUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$QuizSubmissionPayload>
          }
          aggregate: {
            args: Prisma.QuizSubmissionAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateQuizSubmission>
          }
          groupBy: {
            args: Prisma.QuizSubmissionGroupByArgs<ExtArgs>
            result: $Utils.Optional<QuizSubmissionGroupByOutputType>[]
          }
          count: {
            args: Prisma.QuizSubmissionCountArgs<ExtArgs>
            result: $Utils.Optional<QuizSubmissionCountAggregateOutputType> | number
          }
        }
      }
      GoldenCard: {
        payload: Prisma.$GoldenCardPayload<ExtArgs>
        fields: Prisma.GoldenCardFieldRefs
        operations: {
          findUnique: {
            args: Prisma.GoldenCardFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$GoldenCardPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.GoldenCardFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$GoldenCardPayload>
          }
          findFirst: {
            args: Prisma.GoldenCardFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$GoldenCardPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.GoldenCardFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$GoldenCardPayload>
          }
          findMany: {
            args: Prisma.GoldenCardFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$GoldenCardPayload>[]
          }
          create: {
            args: Prisma.GoldenCardCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$GoldenCardPayload>
          }
          createMany: {
            args: Prisma.GoldenCardCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.GoldenCardCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$GoldenCardPayload>[]
          }
          delete: {
            args: Prisma.GoldenCardDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$GoldenCardPayload>
          }
          update: {
            args: Prisma.GoldenCardUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$GoldenCardPayload>
          }
          deleteMany: {
            args: Prisma.GoldenCardDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.GoldenCardUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.GoldenCardUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$GoldenCardPayload>[]
          }
          upsert: {
            args: Prisma.GoldenCardUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$GoldenCardPayload>
          }
          aggregate: {
            args: Prisma.GoldenCardAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateGoldenCard>
          }
          groupBy: {
            args: Prisma.GoldenCardGroupByArgs<ExtArgs>
            result: $Utils.Optional<GoldenCardGroupByOutputType>[]
          }
          count: {
            args: Prisma.GoldenCardCountArgs<ExtArgs>
            result: $Utils.Optional<GoldenCardCountAggregateOutputType> | number
          }
        }
      }
      Session: {
        payload: Prisma.$SessionPayload<ExtArgs>
        fields: Prisma.SessionFieldRefs
        operations: {
          findUnique: {
            args: Prisma.SessionFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SessionPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.SessionFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SessionPayload>
          }
          findFirst: {
            args: Prisma.SessionFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SessionPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.SessionFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SessionPayload>
          }
          findMany: {
            args: Prisma.SessionFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SessionPayload>[]
          }
          create: {
            args: Prisma.SessionCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SessionPayload>
          }
          createMany: {
            args: Prisma.SessionCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.SessionCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SessionPayload>[]
          }
          delete: {
            args: Prisma.SessionDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SessionPayload>
          }
          update: {
            args: Prisma.SessionUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SessionPayload>
          }
          deleteMany: {
            args: Prisma.SessionDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.SessionUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.SessionUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SessionPayload>[]
          }
          upsert: {
            args: Prisma.SessionUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SessionPayload>
          }
          aggregate: {
            args: Prisma.SessionAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateSession>
          }
          groupBy: {
            args: Prisma.SessionGroupByArgs<ExtArgs>
            result: $Utils.Optional<SessionGroupByOutputType>[]
          }
          count: {
            args: Prisma.SessionCountArgs<ExtArgs>
            result: $Utils.Optional<SessionCountAggregateOutputType> | number
          }
        }
      }
      Team: {
        payload: Prisma.$TeamPayload<ExtArgs>
        fields: Prisma.TeamFieldRefs
        operations: {
          findUnique: {
            args: Prisma.TeamFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TeamPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.TeamFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TeamPayload>
          }
          findFirst: {
            args: Prisma.TeamFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TeamPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.TeamFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TeamPayload>
          }
          findMany: {
            args: Prisma.TeamFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TeamPayload>[]
          }
          create: {
            args: Prisma.TeamCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TeamPayload>
          }
          createMany: {
            args: Prisma.TeamCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.TeamCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TeamPayload>[]
          }
          delete: {
            args: Prisma.TeamDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TeamPayload>
          }
          update: {
            args: Prisma.TeamUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TeamPayload>
          }
          deleteMany: {
            args: Prisma.TeamDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.TeamUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.TeamUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TeamPayload>[]
          }
          upsert: {
            args: Prisma.TeamUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TeamPayload>
          }
          aggregate: {
            args: Prisma.TeamAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateTeam>
          }
          groupBy: {
            args: Prisma.TeamGroupByArgs<ExtArgs>
            result: $Utils.Optional<TeamGroupByOutputType>[]
          }
          count: {
            args: Prisma.TeamCountArgs<ExtArgs>
            result: $Utils.Optional<TeamCountAggregateOutputType> | number
          }
        }
      }
      TeamPlayer: {
        payload: Prisma.$TeamPlayerPayload<ExtArgs>
        fields: Prisma.TeamPlayerFieldRefs
        operations: {
          findUnique: {
            args: Prisma.TeamPlayerFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TeamPlayerPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.TeamPlayerFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TeamPlayerPayload>
          }
          findFirst: {
            args: Prisma.TeamPlayerFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TeamPlayerPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.TeamPlayerFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TeamPlayerPayload>
          }
          findMany: {
            args: Prisma.TeamPlayerFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TeamPlayerPayload>[]
          }
          create: {
            args: Prisma.TeamPlayerCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TeamPlayerPayload>
          }
          createMany: {
            args: Prisma.TeamPlayerCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.TeamPlayerCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TeamPlayerPayload>[]
          }
          delete: {
            args: Prisma.TeamPlayerDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TeamPlayerPayload>
          }
          update: {
            args: Prisma.TeamPlayerUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TeamPlayerPayload>
          }
          deleteMany: {
            args: Prisma.TeamPlayerDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.TeamPlayerUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.TeamPlayerUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TeamPlayerPayload>[]
          }
          upsert: {
            args: Prisma.TeamPlayerUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TeamPlayerPayload>
          }
          aggregate: {
            args: Prisma.TeamPlayerAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateTeamPlayer>
          }
          groupBy: {
            args: Prisma.TeamPlayerGroupByArgs<ExtArgs>
            result: $Utils.Optional<TeamPlayerGroupByOutputType>[]
          }
          count: {
            args: Prisma.TeamPlayerCountArgs<ExtArgs>
            result: $Utils.Optional<TeamPlayerCountAggregateOutputType> | number
          }
        }
      }
      Package: {
        payload: Prisma.$PackagePayload<ExtArgs>
        fields: Prisma.PackageFieldRefs
        operations: {
          findUnique: {
            args: Prisma.PackageFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PackagePayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.PackageFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PackagePayload>
          }
          findFirst: {
            args: Prisma.PackageFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PackagePayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.PackageFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PackagePayload>
          }
          findMany: {
            args: Prisma.PackageFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PackagePayload>[]
          }
          create: {
            args: Prisma.PackageCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PackagePayload>
          }
          createMany: {
            args: Prisma.PackageCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.PackageCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PackagePayload>[]
          }
          delete: {
            args: Prisma.PackageDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PackagePayload>
          }
          update: {
            args: Prisma.PackageUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PackagePayload>
          }
          deleteMany: {
            args: Prisma.PackageDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.PackageUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.PackageUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PackagePayload>[]
          }
          upsert: {
            args: Prisma.PackageUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PackagePayload>
          }
          aggregate: {
            args: Prisma.PackageAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregatePackage>
          }
          groupBy: {
            args: Prisma.PackageGroupByArgs<ExtArgs>
            result: $Utils.Optional<PackageGroupByOutputType>[]
          }
          count: {
            args: Prisma.PackageCountArgs<ExtArgs>
            result: $Utils.Optional<PackageCountAggregateOutputType> | number
          }
        }
      }
      Payment: {
        payload: Prisma.$PaymentPayload<ExtArgs>
        fields: Prisma.PaymentFieldRefs
        operations: {
          findUnique: {
            args: Prisma.PaymentFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PaymentPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.PaymentFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PaymentPayload>
          }
          findFirst: {
            args: Prisma.PaymentFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PaymentPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.PaymentFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PaymentPayload>
          }
          findMany: {
            args: Prisma.PaymentFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PaymentPayload>[]
          }
          create: {
            args: Prisma.PaymentCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PaymentPayload>
          }
          createMany: {
            args: Prisma.PaymentCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.PaymentCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PaymentPayload>[]
          }
          delete: {
            args: Prisma.PaymentDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PaymentPayload>
          }
          update: {
            args: Prisma.PaymentUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PaymentPayload>
          }
          deleteMany: {
            args: Prisma.PaymentDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.PaymentUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.PaymentUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PaymentPayload>[]
          }
          upsert: {
            args: Prisma.PaymentUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PaymentPayload>
          }
          aggregate: {
            args: Prisma.PaymentAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregatePayment>
          }
          groupBy: {
            args: Prisma.PaymentGroupByArgs<ExtArgs>
            result: $Utils.Optional<PaymentGroupByOutputType>[]
          }
          count: {
            args: Prisma.PaymentCountArgs<ExtArgs>
            result: $Utils.Optional<PaymentCountAggregateOutputType> | number
          }
        }
      }
    }
  } & {
    other: {
      payload: any
      operations: {
        $executeRaw: {
          args: [query: TemplateStringsArray | Prisma.Sql, ...values: any[]],
          result: any
        }
        $executeRawUnsafe: {
          args: [query: string, ...values: any[]],
          result: any
        }
        $queryRaw: {
          args: [query: TemplateStringsArray | Prisma.Sql, ...values: any[]],
          result: any
        }
        $queryRawUnsafe: {
          args: [query: string, ...values: any[]],
          result: any
        }
      }
    }
  }
  export const defineExtension: $Extensions.ExtendsHook<"define", Prisma.TypeMapCb, $Extensions.DefaultArgs>
  export type DefaultPrismaClient = PrismaClient
  export type ErrorFormat = 'pretty' | 'colorless' | 'minimal'
  export interface PrismaClientOptions {
    /**
     * Overwrites the datasource url from your schema.prisma file
     */
    datasources?: Datasources
    /**
     * Overwrites the datasource url from your schema.prisma file
     */
    datasourceUrl?: string
    /**
     * @default "colorless"
     */
    errorFormat?: ErrorFormat
    /**
     * @example
     * ```
     * // Shorthand for `emit: 'stdout'`
     * log: ['query', 'info', 'warn', 'error']
     * 
     * // Emit as events only
     * log: [
     *   { emit: 'event', level: 'query' },
     *   { emit: 'event', level: 'info' },
     *   { emit: 'event', level: 'warn' }
     *   { emit: 'event', level: 'error' }
     * ]
     * 
     * / Emit as events and log to stdout
     * og: [
     *  { emit: 'stdout', level: 'query' },
     *  { emit: 'stdout', level: 'info' },
     *  { emit: 'stdout', level: 'warn' }
     *  { emit: 'stdout', level: 'error' }
     * 
     * ```
     * Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client/logging#the-log-option).
     */
    log?: (LogLevel | LogDefinition)[]
    /**
     * The default values for transactionOptions
     * maxWait ?= 2000
     * timeout ?= 5000
     */
    transactionOptions?: {
      maxWait?: number
      timeout?: number
      isolationLevel?: Prisma.TransactionIsolationLevel
    }
    /**
     * Instance of a Driver Adapter, e.g., like one provided by `@prisma/adapter-planetscale`
     */
    adapter?: runtime.SqlDriverAdapterFactory | null
    /**
     * Global configuration for omitting model fields by default.
     * 
     * @example
     * ```
     * const prisma = new PrismaClient({
     *   omit: {
     *     user: {
     *       password: true
     *     }
     *   }
     * })
     * ```
     */
    omit?: Prisma.GlobalOmitConfig
  }
  export type GlobalOmitConfig = {
    country?: CountryOmit
    group?: GroupOmit
    player?: PlayerOmit
    match?: MatchOmit
    round?: RoundOmit
    gameweek?: GameweekOmit
    matchEvent?: MatchEventOmit
    matchLineup?: MatchLineupOmit
    playerMatchStat?: PlayerMatchStatOmit
    scoringRule?: ScoringRuleOmit
    user?: UserOmit
    loginOtp?: LoginOtpOmit
    fantasyNews?: FantasyNewsOmit
    dailyQuiz?: DailyQuizOmit
    quizQuestion?: QuizQuestionOmit
    quizSubmission?: QuizSubmissionOmit
    goldenCard?: GoldenCardOmit
    session?: SessionOmit
    team?: TeamOmit
    teamPlayer?: TeamPlayerOmit
    package?: PackageOmit
    payment?: PaymentOmit
  }

  /* Types for Logging */
  export type LogLevel = 'info' | 'query' | 'warn' | 'error'
  export type LogDefinition = {
    level: LogLevel
    emit: 'stdout' | 'event'
  }

  export type CheckIsLogLevel<T> = T extends LogLevel ? T : never;

  export type GetLogType<T> = CheckIsLogLevel<
    T extends LogDefinition ? T['level'] : T
  >;

  export type GetEvents<T extends any[]> = T extends Array<LogLevel | LogDefinition>
    ? GetLogType<T[number]>
    : never;

  export type QueryEvent = {
    timestamp: Date
    query: string
    params: string
    duration: number
    target: string
  }

  export type LogEvent = {
    timestamp: Date
    message: string
    target: string
  }
  /* End Types for Logging */


  export type PrismaAction =
    | 'findUnique'
    | 'findUniqueOrThrow'
    | 'findMany'
    | 'findFirst'
    | 'findFirstOrThrow'
    | 'create'
    | 'createMany'
    | 'createManyAndReturn'
    | 'update'
    | 'updateMany'
    | 'updateManyAndReturn'
    | 'upsert'
    | 'delete'
    | 'deleteMany'
    | 'executeRaw'
    | 'queryRaw'
    | 'aggregate'
    | 'count'
    | 'runCommandRaw'
    | 'findRaw'
    | 'groupBy'

  // tested in getLogLevel.test.ts
  export function getLogLevel(log: Array<LogLevel | LogDefinition>): LogLevel | undefined;

  /**
   * `PrismaClient` proxy available in interactive transactions.
   */
  export type TransactionClient = Omit<Prisma.DefaultPrismaClient, runtime.ITXClientDenyList>

  export type Datasource = {
    url?: string
  }

  /**
   * Count Types
   */


  /**
   * Count Type CountryCountOutputType
   */

  export type CountryCountOutputType = {
    players: number
    homeMatches: number
    awayMatches: number
  }

  export type CountryCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    players?: boolean | CountryCountOutputTypeCountPlayersArgs
    homeMatches?: boolean | CountryCountOutputTypeCountHomeMatchesArgs
    awayMatches?: boolean | CountryCountOutputTypeCountAwayMatchesArgs
  }

  // Custom InputTypes
  /**
   * CountryCountOutputType without action
   */
  export type CountryCountOutputTypeDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CountryCountOutputType
     */
    select?: CountryCountOutputTypeSelect<ExtArgs> | null
  }

  /**
   * CountryCountOutputType without action
   */
  export type CountryCountOutputTypeCountPlayersArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: PlayerWhereInput
  }

  /**
   * CountryCountOutputType without action
   */
  export type CountryCountOutputTypeCountHomeMatchesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: MatchWhereInput
  }

  /**
   * CountryCountOutputType without action
   */
  export type CountryCountOutputTypeCountAwayMatchesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: MatchWhereInput
  }


  /**
   * Count Type GroupCountOutputType
   */

  export type GroupCountOutputType = {
    countries: number
  }

  export type GroupCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    countries?: boolean | GroupCountOutputTypeCountCountriesArgs
  }

  // Custom InputTypes
  /**
   * GroupCountOutputType without action
   */
  export type GroupCountOutputTypeDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the GroupCountOutputType
     */
    select?: GroupCountOutputTypeSelect<ExtArgs> | null
  }

  /**
   * GroupCountOutputType without action
   */
  export type GroupCountOutputTypeCountCountriesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: CountryWhereInput
  }


  /**
   * Count Type PlayerCountOutputType
   */

  export type PlayerCountOutputType = {
    matchStats: number
    teamPlayers: number
    events: number
    goldenCards: number
  }

  export type PlayerCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    matchStats?: boolean | PlayerCountOutputTypeCountMatchStatsArgs
    teamPlayers?: boolean | PlayerCountOutputTypeCountTeamPlayersArgs
    events?: boolean | PlayerCountOutputTypeCountEventsArgs
    goldenCards?: boolean | PlayerCountOutputTypeCountGoldenCardsArgs
  }

  // Custom InputTypes
  /**
   * PlayerCountOutputType without action
   */
  export type PlayerCountOutputTypeDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PlayerCountOutputType
     */
    select?: PlayerCountOutputTypeSelect<ExtArgs> | null
  }

  /**
   * PlayerCountOutputType without action
   */
  export type PlayerCountOutputTypeCountMatchStatsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: PlayerMatchStatWhereInput
  }

  /**
   * PlayerCountOutputType without action
   */
  export type PlayerCountOutputTypeCountTeamPlayersArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: TeamPlayerWhereInput
  }

  /**
   * PlayerCountOutputType without action
   */
  export type PlayerCountOutputTypeCountEventsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: MatchEventWhereInput
  }

  /**
   * PlayerCountOutputType without action
   */
  export type PlayerCountOutputTypeCountGoldenCardsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: GoldenCardWhereInput
  }


  /**
   * Count Type MatchCountOutputType
   */

  export type MatchCountOutputType = {
    playerStats: number
    events: number
    lineups: number
  }

  export type MatchCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    playerStats?: boolean | MatchCountOutputTypeCountPlayerStatsArgs
    events?: boolean | MatchCountOutputTypeCountEventsArgs
    lineups?: boolean | MatchCountOutputTypeCountLineupsArgs
  }

  // Custom InputTypes
  /**
   * MatchCountOutputType without action
   */
  export type MatchCountOutputTypeDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MatchCountOutputType
     */
    select?: MatchCountOutputTypeSelect<ExtArgs> | null
  }

  /**
   * MatchCountOutputType without action
   */
  export type MatchCountOutputTypeCountPlayerStatsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: PlayerMatchStatWhereInput
  }

  /**
   * MatchCountOutputType without action
   */
  export type MatchCountOutputTypeCountEventsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: MatchEventWhereInput
  }

  /**
   * MatchCountOutputType without action
   */
  export type MatchCountOutputTypeCountLineupsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: MatchLineupWhereInput
  }


  /**
   * Count Type RoundCountOutputType
   */

  export type RoundCountOutputType = {
    matches: number
  }

  export type RoundCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    matches?: boolean | RoundCountOutputTypeCountMatchesArgs
  }

  // Custom InputTypes
  /**
   * RoundCountOutputType without action
   */
  export type RoundCountOutputTypeDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the RoundCountOutputType
     */
    select?: RoundCountOutputTypeSelect<ExtArgs> | null
  }

  /**
   * RoundCountOutputType without action
   */
  export type RoundCountOutputTypeCountMatchesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: MatchWhereInput
  }


  /**
   * Count Type UserCountOutputType
   */

  export type UserCountOutputType = {
    sessions: number
    payments: number
    quizSubmissions: number
    goldenCards: number
  }

  export type UserCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    sessions?: boolean | UserCountOutputTypeCountSessionsArgs
    payments?: boolean | UserCountOutputTypeCountPaymentsArgs
    quizSubmissions?: boolean | UserCountOutputTypeCountQuizSubmissionsArgs
    goldenCards?: boolean | UserCountOutputTypeCountGoldenCardsArgs
  }

  // Custom InputTypes
  /**
   * UserCountOutputType without action
   */
  export type UserCountOutputTypeDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the UserCountOutputType
     */
    select?: UserCountOutputTypeSelect<ExtArgs> | null
  }

  /**
   * UserCountOutputType without action
   */
  export type UserCountOutputTypeCountSessionsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: SessionWhereInput
  }

  /**
   * UserCountOutputType without action
   */
  export type UserCountOutputTypeCountPaymentsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: PaymentWhereInput
  }

  /**
   * UserCountOutputType without action
   */
  export type UserCountOutputTypeCountQuizSubmissionsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: QuizSubmissionWhereInput
  }

  /**
   * UserCountOutputType without action
   */
  export type UserCountOutputTypeCountGoldenCardsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: GoldenCardWhereInput
  }


  /**
   * Count Type DailyQuizCountOutputType
   */

  export type DailyQuizCountOutputType = {
    questions: number
    submissions: number
    awardedCards: number
  }

  export type DailyQuizCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    questions?: boolean | DailyQuizCountOutputTypeCountQuestionsArgs
    submissions?: boolean | DailyQuizCountOutputTypeCountSubmissionsArgs
    awardedCards?: boolean | DailyQuizCountOutputTypeCountAwardedCardsArgs
  }

  // Custom InputTypes
  /**
   * DailyQuizCountOutputType without action
   */
  export type DailyQuizCountOutputTypeDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the DailyQuizCountOutputType
     */
    select?: DailyQuizCountOutputTypeSelect<ExtArgs> | null
  }

  /**
   * DailyQuizCountOutputType without action
   */
  export type DailyQuizCountOutputTypeCountQuestionsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: QuizQuestionWhereInput
  }

  /**
   * DailyQuizCountOutputType without action
   */
  export type DailyQuizCountOutputTypeCountSubmissionsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: QuizSubmissionWhereInput
  }

  /**
   * DailyQuizCountOutputType without action
   */
  export type DailyQuizCountOutputTypeCountAwardedCardsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: GoldenCardWhereInput
  }


  /**
   * Count Type TeamCountOutputType
   */

  export type TeamCountOutputType = {
    players: number
  }

  export type TeamCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    players?: boolean | TeamCountOutputTypeCountPlayersArgs
  }

  // Custom InputTypes
  /**
   * TeamCountOutputType without action
   */
  export type TeamCountOutputTypeDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TeamCountOutputType
     */
    select?: TeamCountOutputTypeSelect<ExtArgs> | null
  }

  /**
   * TeamCountOutputType without action
   */
  export type TeamCountOutputTypeCountPlayersArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: TeamPlayerWhereInput
  }


  /**
   * Count Type PackageCountOutputType
   */

  export type PackageCountOutputType = {
    payments: number
  }

  export type PackageCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    payments?: boolean | PackageCountOutputTypeCountPaymentsArgs
  }

  // Custom InputTypes
  /**
   * PackageCountOutputType without action
   */
  export type PackageCountOutputTypeDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PackageCountOutputType
     */
    select?: PackageCountOutputTypeSelect<ExtArgs> | null
  }

  /**
   * PackageCountOutputType without action
   */
  export type PackageCountOutputTypeCountPaymentsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: PaymentWhereInput
  }


  /**
   * Models
   */

  /**
   * Model Country
   */

  export type AggregateCountry = {
    _count: CountryCountAggregateOutputType | null
    _min: CountryMinAggregateOutputType | null
    _max: CountryMaxAggregateOutputType | null
  }

  export type CountryMinAggregateOutputType = {
    id: string | null
    name: string | null
    code: string | null
    flagUrl: string | null
    flagImage: string | null
    confederation: string | null
    qualificationMethod: string | null
    qualificationDate: string | null
    participationHistory: string | null
    bestResult: string | null
    description: string | null
    defaultFormation: string | null
    defaultCaptainId: string | null
    groupId: string | null
    isEliminated: boolean | null
  }

  export type CountryMaxAggregateOutputType = {
    id: string | null
    name: string | null
    code: string | null
    flagUrl: string | null
    flagImage: string | null
    confederation: string | null
    qualificationMethod: string | null
    qualificationDate: string | null
    participationHistory: string | null
    bestResult: string | null
    description: string | null
    defaultFormation: string | null
    defaultCaptainId: string | null
    groupId: string | null
    isEliminated: boolean | null
  }

  export type CountryCountAggregateOutputType = {
    id: number
    name: number
    code: number
    flagUrl: number
    flagImage: number
    confederation: number
    qualificationMethod: number
    qualificationDate: number
    participationHistory: number
    bestResult: number
    description: number
    defaultFormation: number
    defaultLineupPlayerIds: number
    defaultCaptainId: number
    groupId: number
    isEliminated: number
    _all: number
  }


  export type CountryMinAggregateInputType = {
    id?: true
    name?: true
    code?: true
    flagUrl?: true
    flagImage?: true
    confederation?: true
    qualificationMethod?: true
    qualificationDate?: true
    participationHistory?: true
    bestResult?: true
    description?: true
    defaultFormation?: true
    defaultCaptainId?: true
    groupId?: true
    isEliminated?: true
  }

  export type CountryMaxAggregateInputType = {
    id?: true
    name?: true
    code?: true
    flagUrl?: true
    flagImage?: true
    confederation?: true
    qualificationMethod?: true
    qualificationDate?: true
    participationHistory?: true
    bestResult?: true
    description?: true
    defaultFormation?: true
    defaultCaptainId?: true
    groupId?: true
    isEliminated?: true
  }

  export type CountryCountAggregateInputType = {
    id?: true
    name?: true
    code?: true
    flagUrl?: true
    flagImage?: true
    confederation?: true
    qualificationMethod?: true
    qualificationDate?: true
    participationHistory?: true
    bestResult?: true
    description?: true
    defaultFormation?: true
    defaultLineupPlayerIds?: true
    defaultCaptainId?: true
    groupId?: true
    isEliminated?: true
    _all?: true
  }

  export type CountryAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Country to aggregate.
     */
    where?: CountryWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Countries to fetch.
     */
    orderBy?: CountryOrderByWithRelationInput | CountryOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: CountryWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Countries 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` Countries.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned Countries
    **/
    _count?: true | CountryCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: CountryMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: CountryMaxAggregateInputType
  }

  export type GetCountryAggregateType<T extends CountryAggregateArgs> = {
        [P in keyof T & keyof AggregateCountry]: P extends '_count' | 'count'
      ? T[P] extends true
        ? number
        : GetScalarType<T[P], AggregateCountry[P]>
      : GetScalarType<T[P], AggregateCountry[P]>
  }




  export type CountryGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: CountryWhereInput
    orderBy?: CountryOrderByWithAggregationInput | CountryOrderByWithAggregationInput[]
    by: CountryScalarFieldEnum[] | CountryScalarFieldEnum
    having?: CountryScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: CountryCountAggregateInputType | true
    _min?: CountryMinAggregateInputType
    _max?: CountryMaxAggregateInputType
  }

  export type CountryGroupByOutputType = {
    id: string
    name: string
    code: string
    flagUrl: string | null
    flagImage: string | null
    confederation: string | null
    qualificationMethod: string | null
    qualificationDate: string | null
    participationHistory: string | null
    bestResult: string | null
    description: string | null
    defaultFormation: string
    defaultLineupPlayerIds: string[]
    defaultCaptainId: string | null
    groupId: string | null
    isEliminated: boolean
    _count: CountryCountAggregateOutputType | null
    _min: CountryMinAggregateOutputType | null
    _max: CountryMaxAggregateOutputType | null
  }

  type GetCountryGroupByPayload<T extends CountryGroupByArgs> = Prisma.PrismaPromise<
    Array<
      PickEnumerable<CountryGroupByOutputType, T['by']> &
        {
          [P in ((keyof T) & (keyof CountryGroupByOutputType))]: P extends '_count'
            ? T[P] extends boolean
              ? number
              : GetScalarType<T[P], CountryGroupByOutputType[P]>
            : GetScalarType<T[P], CountryGroupByOutputType[P]>
        }
      >
    >


  export type CountrySelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
    code?: boolean
    flagUrl?: boolean
    flagImage?: boolean
    confederation?: boolean
    qualificationMethod?: boolean
    qualificationDate?: boolean
    participationHistory?: boolean
    bestResult?: boolean
    description?: boolean
    defaultFormation?: boolean
    defaultLineupPlayerIds?: boolean
    defaultCaptainId?: boolean
    groupId?: boolean
    isEliminated?: boolean
    group?: boolean | Country$groupArgs<ExtArgs>
    players?: boolean | Country$playersArgs<ExtArgs>
    homeMatches?: boolean | Country$homeMatchesArgs<ExtArgs>
    awayMatches?: boolean | Country$awayMatchesArgs<ExtArgs>
    _count?: boolean | CountryCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["country"]>

  export type CountrySelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
    code?: boolean
    flagUrl?: boolean
    flagImage?: boolean
    confederation?: boolean
    qualificationMethod?: boolean
    qualificationDate?: boolean
    participationHistory?: boolean
    bestResult?: boolean
    description?: boolean
    defaultFormation?: boolean
    defaultLineupPlayerIds?: boolean
    defaultCaptainId?: boolean
    groupId?: boolean
    isEliminated?: boolean
    group?: boolean | Country$groupArgs<ExtArgs>
  }, ExtArgs["result"]["country"]>

  export type CountrySelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
    code?: boolean
    flagUrl?: boolean
    flagImage?: boolean
    confederation?: boolean
    qualificationMethod?: boolean
    qualificationDate?: boolean
    participationHistory?: boolean
    bestResult?: boolean
    description?: boolean
    defaultFormation?: boolean
    defaultLineupPlayerIds?: boolean
    defaultCaptainId?: boolean
    groupId?: boolean
    isEliminated?: boolean
    group?: boolean | Country$groupArgs<ExtArgs>
  }, ExtArgs["result"]["country"]>

  export type CountrySelectScalar = {
    id?: boolean
    name?: boolean
    code?: boolean
    flagUrl?: boolean
    flagImage?: boolean
    confederation?: boolean
    qualificationMethod?: boolean
    qualificationDate?: boolean
    participationHistory?: boolean
    bestResult?: boolean
    description?: boolean
    defaultFormation?: boolean
    defaultLineupPlayerIds?: boolean
    defaultCaptainId?: boolean
    groupId?: boolean
    isEliminated?: boolean
  }

  export type CountryOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "name" | "code" | "flagUrl" | "flagImage" | "confederation" | "qualificationMethod" | "qualificationDate" | "participationHistory" | "bestResult" | "description" | "defaultFormation" | "defaultLineupPlayerIds" | "defaultCaptainId" | "groupId" | "isEliminated", ExtArgs["result"]["country"]>
  export type CountryInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    group?: boolean | Country$groupArgs<ExtArgs>
    players?: boolean | Country$playersArgs<ExtArgs>
    homeMatches?: boolean | Country$homeMatchesArgs<ExtArgs>
    awayMatches?: boolean | Country$awayMatchesArgs<ExtArgs>
    _count?: boolean | CountryCountOutputTypeDefaultArgs<ExtArgs>
  }
  export type CountryIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    group?: boolean | Country$groupArgs<ExtArgs>
  }
  export type CountryIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    group?: boolean | Country$groupArgs<ExtArgs>
  }

  export type $CountryPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Country"
    objects: {
      group: Prisma.$GroupPayload<ExtArgs> | null
      players: Prisma.$PlayerPayload<ExtArgs>[]
      homeMatches: Prisma.$MatchPayload<ExtArgs>[]
      awayMatches: Prisma.$MatchPayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      name: string
      code: string
      flagUrl: string | null
      flagImage: string | null
      confederation: string | null
      qualificationMethod: string | null
      qualificationDate: string | null
      participationHistory: string | null
      bestResult: string | null
      description: string | null
      defaultFormation: string
      defaultLineupPlayerIds: string[]
      defaultCaptainId: string | null
      groupId: string | null
      isEliminated: boolean
    }, ExtArgs["result"]["country"]>
    composites: {}
  }

  type CountryGetPayload<S extends boolean | null | undefined | CountryDefaultArgs> = $Result.GetResult<Prisma.$CountryPayload, S>

  type CountryCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
    Omit<CountryFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
      select?: CountryCountAggregateInputType | true
    }

  export interface CountryDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> {
    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['Country'], meta: { name: 'Country' } }
    /**
     * Find zero or one Country that matches the filter.
     * @param {CountryFindUniqueArgs} args - Arguments to find a Country
     * @example
     * // Get one Country
     * const country = await prisma.country.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUnique<T extends CountryFindUniqueArgs>(args: SelectSubset<T, CountryFindUniqueArgs<ExtArgs>>): Prisma__CountryClient<$Result.GetResult<Prisma.$CountryPayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find one Country that matches the filter or throw an error with `error.code='P2025'`
     * if no matches were found.
     * @param {CountryFindUniqueOrThrowArgs} args - Arguments to find a Country
     * @example
     * // Get one Country
     * const country = await prisma.country.findUniqueOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUniqueOrThrow<T extends CountryFindUniqueOrThrowArgs>(args: SelectSubset<T, CountryFindUniqueOrThrowArgs<ExtArgs>>): Prisma__CountryClient<$Result.GetResult<Prisma.$CountryPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first Country 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 {CountryFindFirstArgs} args - Arguments to find a Country
     * @example
     * // Get one Country
     * const country = await prisma.country.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends CountryFindFirstArgs>(args?: SelectSubset<T, CountryFindFirstArgs<ExtArgs>>): Prisma__CountryClient<$Result.GetResult<Prisma.$CountryPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first Country 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 {CountryFindFirstOrThrowArgs} args - Arguments to find a Country
     * @example
     * // Get one Country
     * const country = await prisma.country.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends CountryFindFirstOrThrowArgs>(args?: SelectSubset<T, CountryFindFirstOrThrowArgs<ExtArgs>>): Prisma__CountryClient<$Result.GetResult<Prisma.$CountryPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find zero or more Countries 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 {CountryFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all Countries
     * const countries = await prisma.country.findMany()
     * 
     * // Get first 10 Countries
     * const countries = await prisma.country.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const countryWithIdOnly = await prisma.country.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends CountryFindManyArgs>(args?: SelectSubset<T, CountryFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$CountryPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>

    /**
     * Create a Country.
     * @param {CountryCreateArgs} args - Arguments to create a Country.
     * @example
     * // Create one Country
     * const Country = await prisma.country.create({
     *   data: {
     *     // ... data to create a Country
     *   }
     * })
     * 
     */
    create<T extends CountryCreateArgs>(args: SelectSubset<T, CountryCreateArgs<ExtArgs>>): Prisma__CountryClient<$Result.GetResult<Prisma.$CountryPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Create many Countries.
     * @param {CountryCreateManyArgs} args - Arguments to create many Countries.
     * @example
     * // Create many Countries
     * const country = await prisma.country.createMany({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     *     
     */
    createMany<T extends CountryCreateManyArgs>(args?: SelectSubset<T, CountryCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create many Countries and returns the data saved in the database.
     * @param {CountryCreateManyAndReturnArgs} args - Arguments to create many Countries.
     * @example
     * // Create many Countries
     * const country = await prisma.country.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many Countries and only return the `id`
     * const countryWithIdOnly = await prisma.country.createManyAndReturn({
     *   select: { id: true },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    createManyAndReturn<T extends CountryCreateManyAndReturnArgs>(args?: SelectSubset<T, CountryCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$CountryPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>

    /**
     * Delete a Country.
     * @param {CountryDeleteArgs} args - Arguments to delete one Country.
     * @example
     * // Delete one Country
     * const Country = await prisma.country.delete({
     *   where: {
     *     // ... filter to delete one Country
     *   }
     * })
     * 
     */
    delete<T extends CountryDeleteArgs>(args: SelectSubset<T, CountryDeleteArgs<ExtArgs>>): Prisma__CountryClient<$Result.GetResult<Prisma.$CountryPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Update one Country.
     * @param {CountryUpdateArgs} args - Arguments to update one Country.
     * @example
     * // Update one Country
     * const country = await prisma.country.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends CountryUpdateArgs>(args: SelectSubset<T, CountryUpdateArgs<ExtArgs>>): Prisma__CountryClient<$Result.GetResult<Prisma.$CountryPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Delete zero or more Countries.
     * @param {CountryDeleteManyArgs} args - Arguments to filter Countries to delete.
     * @example
     * // Delete a few Countries
     * const { count } = await prisma.country.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
     */
    deleteMany<T extends CountryDeleteManyArgs>(args?: SelectSubset<T, CountryDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more Countries.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {CountryUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many Countries
     * const country = await prisma.country.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    updateMany<T extends CountryUpdateManyArgs>(args: SelectSubset<T, CountryUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more Countries and returns the data updated in the database.
     * @param {CountryUpdateManyAndReturnArgs} args - Arguments to update many Countries.
     * @example
     * // Update many Countries
     * const country = await prisma.country.updateManyAndReturn({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Update zero or more Countries and only return the `id`
     * const countryWithIdOnly = await prisma.country.updateManyAndReturn({
     *   select: { id: true },
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    updateManyAndReturn<T extends CountryUpdateManyAndReturnArgs>(args: SelectSubset<T, CountryUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$CountryPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>

    /**
     * Create or update one Country.
     * @param {CountryUpsertArgs} args - Arguments to update or create a Country.
     * @example
     * // Update or create a Country
     * const country = await prisma.country.upsert({
     *   create: {
     *     // ... data to create a Country
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the Country we want to update
     *   }
     * })
     */
    upsert<T extends CountryUpsertArgs>(args: SelectSubset<T, CountryUpsertArgs<ExtArgs>>): Prisma__CountryClient<$Result.GetResult<Prisma.$CountryPayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>


    /**
     * Count the number of Countries.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {CountryCountArgs} args - Arguments to filter Countries to count.
     * @example
     * // Count the number of Countries
     * const count = await prisma.country.count({
     *   where: {
     *     // ... the filter for the Countries we want to count
     *   }
     * })
    **/
    count<T extends CountryCountArgs>(
      args?: Subset<T, CountryCountArgs>,
    ): Prisma.PrismaPromise<
      T extends $Utils.Record<'select', any>
        ? T['select'] extends true
          ? number
          : GetScalarType<T['select'], CountryCountAggregateOutputType>
        : number
    >

    /**
     * Allows you to perform aggregations operations on a Country.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {CountryAggregateArgs} 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 CountryAggregateArgs>(args: Subset<T, CountryAggregateArgs>): Prisma.PrismaPromise<GetCountryAggregateType<T>>

    /**
     * Group by Country.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {CountryGroupByArgs} 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 CountryGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: CountryGroupByArgs['orderBy'] }
        : { orderBy?: CountryGroupByArgs['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, CountryGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetCountryGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the Country model
   */
  readonly fields: CountryFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for Country.
   * 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__CountryClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    group<T extends Country$groupArgs<ExtArgs> = {}>(args?: Subset<T, Country$groupArgs<ExtArgs>>): Prisma__GroupClient<$Result.GetResult<Prisma.$GroupPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
    players<T extends Country$playersArgs<ExtArgs> = {}>(args?: Subset<T, Country$playersArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$PlayerPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    homeMatches<T extends Country$homeMatchesArgs<ExtArgs> = {}>(args?: Subset<T, Country$homeMatchesArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$MatchPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    awayMatches<T extends Country$awayMatchesArgs<ExtArgs> = {}>(args?: Subset<T, Country$awayMatchesArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$MatchPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    /**
     * 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 Country model
   */
  interface CountryFieldRefs {
    readonly id: FieldRef<"Country", 'String'>
    readonly name: FieldRef<"Country", 'String'>
    readonly code: FieldRef<"Country", 'String'>
    readonly flagUrl: FieldRef<"Country", 'String'>
    readonly flagImage: FieldRef<"Country", 'String'>
    readonly confederation: FieldRef<"Country", 'String'>
    readonly qualificationMethod: FieldRef<"Country", 'String'>
    readonly qualificationDate: FieldRef<"Country", 'String'>
    readonly participationHistory: FieldRef<"Country", 'String'>
    readonly bestResult: FieldRef<"Country", 'String'>
    readonly description: FieldRef<"Country", 'String'>
    readonly defaultFormation: FieldRef<"Country", 'String'>
    readonly defaultLineupPlayerIds: FieldRef<"Country", 'String[]'>
    readonly defaultCaptainId: FieldRef<"Country", 'String'>
    readonly groupId: FieldRef<"Country", 'String'>
    readonly isEliminated: FieldRef<"Country", 'Boolean'>
  }
    

  // Custom InputTypes
  /**
   * Country findUnique
   */
  export type CountryFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Country
     */
    select?: CountrySelect<ExtArgs> | null
    /**
     * Omit specific fields from the Country
     */
    omit?: CountryOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CountryInclude<ExtArgs> | null
    /**
     * Filter, which Country to fetch.
     */
    where: CountryWhereUniqueInput
  }

  /**
   * Country findUniqueOrThrow
   */
  export type CountryFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Country
     */
    select?: CountrySelect<ExtArgs> | null
    /**
     * Omit specific fields from the Country
     */
    omit?: CountryOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CountryInclude<ExtArgs> | null
    /**
     * Filter, which Country to fetch.
     */
    where: CountryWhereUniqueInput
  }

  /**
   * Country findFirst
   */
  export type CountryFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Country
     */
    select?: CountrySelect<ExtArgs> | null
    /**
     * Omit specific fields from the Country
     */
    omit?: CountryOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CountryInclude<ExtArgs> | null
    /**
     * Filter, which Country to fetch.
     */
    where?: CountryWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Countries to fetch.
     */
    orderBy?: CountryOrderByWithRelationInput | CountryOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Countries.
     */
    cursor?: CountryWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Countries 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` Countries.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Countries.
     */
    distinct?: CountryScalarFieldEnum | CountryScalarFieldEnum[]
  }

  /**
   * Country findFirstOrThrow
   */
  export type CountryFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Country
     */
    select?: CountrySelect<ExtArgs> | null
    /**
     * Omit specific fields from the Country
     */
    omit?: CountryOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CountryInclude<ExtArgs> | null
    /**
     * Filter, which Country to fetch.
     */
    where?: CountryWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Countries to fetch.
     */
    orderBy?: CountryOrderByWithRelationInput | CountryOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Countries.
     */
    cursor?: CountryWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Countries 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` Countries.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Countries.
     */
    distinct?: CountryScalarFieldEnum | CountryScalarFieldEnum[]
  }

  /**
   * Country findMany
   */
  export type CountryFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Country
     */
    select?: CountrySelect<ExtArgs> | null
    /**
     * Omit specific fields from the Country
     */
    omit?: CountryOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CountryInclude<ExtArgs> | null
    /**
     * Filter, which Countries to fetch.
     */
    where?: CountryWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Countries to fetch.
     */
    orderBy?: CountryOrderByWithRelationInput | CountryOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing Countries.
     */
    cursor?: CountryWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Countries 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` Countries.
     */
    skip?: number
    distinct?: CountryScalarFieldEnum | CountryScalarFieldEnum[]
  }

  /**
   * Country create
   */
  export type CountryCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Country
     */
    select?: CountrySelect<ExtArgs> | null
    /**
     * Omit specific fields from the Country
     */
    omit?: CountryOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CountryInclude<ExtArgs> | null
    /**
     * The data needed to create a Country.
     */
    data: XOR<CountryCreateInput, CountryUncheckedCreateInput>
  }

  /**
   * Country createMany
   */
  export type CountryCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many Countries.
     */
    data: CountryCreateManyInput | CountryCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * Country createManyAndReturn
   */
  export type CountryCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Country
     */
    select?: CountrySelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the Country
     */
    omit?: CountryOmit<ExtArgs> | null
    /**
     * The data used to create many Countries.
     */
    data: CountryCreateManyInput | CountryCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CountryIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * Country update
   */
  export type CountryUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Country
     */
    select?: CountrySelect<ExtArgs> | null
    /**
     * Omit specific fields from the Country
     */
    omit?: CountryOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CountryInclude<ExtArgs> | null
    /**
     * The data needed to update a Country.
     */
    data: XOR<CountryUpdateInput, CountryUncheckedUpdateInput>
    /**
     * Choose, which Country to update.
     */
    where: CountryWhereUniqueInput
  }

  /**
   * Country updateMany
   */
  export type CountryUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Countries.
     */
    data: XOR<CountryUpdateManyMutationInput, CountryUncheckedUpdateManyInput>
    /**
     * Filter which Countries to update
     */
    where?: CountryWhereInput
    /**
     * Limit how many Countries to update.
     */
    limit?: number
  }

  /**
   * Country updateManyAndReturn
   */
  export type CountryUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Country
     */
    select?: CountrySelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the Country
     */
    omit?: CountryOmit<ExtArgs> | null
    /**
     * The data used to update Countries.
     */
    data: XOR<CountryUpdateManyMutationInput, CountryUncheckedUpdateManyInput>
    /**
     * Filter which Countries to update
     */
    where?: CountryWhereInput
    /**
     * Limit how many Countries to update.
     */
    limit?: number
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CountryIncludeUpdateManyAndReturn<ExtArgs> | null
  }

  /**
   * Country upsert
   */
  export type CountryUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Country
     */
    select?: CountrySelect<ExtArgs> | null
    /**
     * Omit specific fields from the Country
     */
    omit?: CountryOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CountryInclude<ExtArgs> | null
    /**
     * The filter to search for the Country to update in case it exists.
     */
    where: CountryWhereUniqueInput
    /**
     * In case the Country found by the `where` argument doesn't exist, create a new Country with this data.
     */
    create: XOR<CountryCreateInput, CountryUncheckedCreateInput>
    /**
     * In case the Country was found with the provided `where` argument, update it with this data.
     */
    update: XOR<CountryUpdateInput, CountryUncheckedUpdateInput>
  }

  /**
   * Country delete
   */
  export type CountryDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Country
     */
    select?: CountrySelect<ExtArgs> | null
    /**
     * Omit specific fields from the Country
     */
    omit?: CountryOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CountryInclude<ExtArgs> | null
    /**
     * Filter which Country to delete.
     */
    where: CountryWhereUniqueInput
  }

  /**
   * Country deleteMany
   */
  export type CountryDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Countries to delete
     */
    where?: CountryWhereInput
    /**
     * Limit how many Countries to delete.
     */
    limit?: number
  }

  /**
   * Country.group
   */
  export type Country$groupArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Group
     */
    select?: GroupSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Group
     */
    omit?: GroupOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: GroupInclude<ExtArgs> | null
    where?: GroupWhereInput
  }

  /**
   * Country.players
   */
  export type Country$playersArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Player
     */
    select?: PlayerSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Player
     */
    omit?: PlayerOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PlayerInclude<ExtArgs> | null
    where?: PlayerWhereInput
    orderBy?: PlayerOrderByWithRelationInput | PlayerOrderByWithRelationInput[]
    cursor?: PlayerWhereUniqueInput
    take?: number
    skip?: number
    distinct?: PlayerScalarFieldEnum | PlayerScalarFieldEnum[]
  }

  /**
   * Country.homeMatches
   */
  export type Country$homeMatchesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Match
     */
    select?: MatchSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Match
     */
    omit?: MatchOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MatchInclude<ExtArgs> | null
    where?: MatchWhereInput
    orderBy?: MatchOrderByWithRelationInput | MatchOrderByWithRelationInput[]
    cursor?: MatchWhereUniqueInput
    take?: number
    skip?: number
    distinct?: MatchScalarFieldEnum | MatchScalarFieldEnum[]
  }

  /**
   * Country.awayMatches
   */
  export type Country$awayMatchesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Match
     */
    select?: MatchSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Match
     */
    omit?: MatchOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MatchInclude<ExtArgs> | null
    where?: MatchWhereInput
    orderBy?: MatchOrderByWithRelationInput | MatchOrderByWithRelationInput[]
    cursor?: MatchWhereUniqueInput
    take?: number
    skip?: number
    distinct?: MatchScalarFieldEnum | MatchScalarFieldEnum[]
  }

  /**
   * Country without action
   */
  export type CountryDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Country
     */
    select?: CountrySelect<ExtArgs> | null
    /**
     * Omit specific fields from the Country
     */
    omit?: CountryOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CountryInclude<ExtArgs> | null
  }


  /**
   * Model Group
   */

  export type AggregateGroup = {
    _count: GroupCountAggregateOutputType | null
    _min: GroupMinAggregateOutputType | null
    _max: GroupMaxAggregateOutputType | null
  }

  export type GroupMinAggregateOutputType = {
    id: string | null
    name: string | null
  }

  export type GroupMaxAggregateOutputType = {
    id: string | null
    name: string | null
  }

  export type GroupCountAggregateOutputType = {
    id: number
    name: number
    _all: number
  }


  export type GroupMinAggregateInputType = {
    id?: true
    name?: true
  }

  export type GroupMaxAggregateInputType = {
    id?: true
    name?: true
  }

  export type GroupCountAggregateInputType = {
    id?: true
    name?: true
    _all?: true
  }

  export type GroupAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Group to aggregate.
     */
    where?: GroupWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Groups to fetch.
     */
    orderBy?: GroupOrderByWithRelationInput | GroupOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: GroupWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Groups 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` Groups.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned Groups
    **/
    _count?: true | GroupCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: GroupMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: GroupMaxAggregateInputType
  }

  export type GetGroupAggregateType<T extends GroupAggregateArgs> = {
        [P in keyof T & keyof AggregateGroup]: P extends '_count' | 'count'
      ? T[P] extends true
        ? number
        : GetScalarType<T[P], AggregateGroup[P]>
      : GetScalarType<T[P], AggregateGroup[P]>
  }




  export type GroupGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: GroupWhereInput
    orderBy?: GroupOrderByWithAggregationInput | GroupOrderByWithAggregationInput[]
    by: GroupScalarFieldEnum[] | GroupScalarFieldEnum
    having?: GroupScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: GroupCountAggregateInputType | true
    _min?: GroupMinAggregateInputType
    _max?: GroupMaxAggregateInputType
  }

  export type GroupGroupByOutputType = {
    id: string
    name: string
    _count: GroupCountAggregateOutputType | null
    _min: GroupMinAggregateOutputType | null
    _max: GroupMaxAggregateOutputType | null
  }

  type GetGroupGroupByPayload<T extends GroupGroupByArgs> = Prisma.PrismaPromise<
    Array<
      PickEnumerable<GroupGroupByOutputType, T['by']> &
        {
          [P in ((keyof T) & (keyof GroupGroupByOutputType))]: P extends '_count'
            ? T[P] extends boolean
              ? number
              : GetScalarType<T[P], GroupGroupByOutputType[P]>
            : GetScalarType<T[P], GroupGroupByOutputType[P]>
        }
      >
    >


  export type GroupSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
    countries?: boolean | Group$countriesArgs<ExtArgs>
    _count?: boolean | GroupCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["group"]>

  export type GroupSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
  }, ExtArgs["result"]["group"]>

  export type GroupSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
  }, ExtArgs["result"]["group"]>

  export type GroupSelectScalar = {
    id?: boolean
    name?: boolean
  }

  export type GroupOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "name", ExtArgs["result"]["group"]>
  export type GroupInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    countries?: boolean | Group$countriesArgs<ExtArgs>
    _count?: boolean | GroupCountOutputTypeDefaultArgs<ExtArgs>
  }
  export type GroupIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {}
  export type GroupIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {}

  export type $GroupPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Group"
    objects: {
      countries: Prisma.$CountryPayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      name: string
    }, ExtArgs["result"]["group"]>
    composites: {}
  }

  type GroupGetPayload<S extends boolean | null | undefined | GroupDefaultArgs> = $Result.GetResult<Prisma.$GroupPayload, S>

  type GroupCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
    Omit<GroupFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
      select?: GroupCountAggregateInputType | true
    }

  export interface GroupDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> {
    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['Group'], meta: { name: 'Group' } }
    /**
     * Find zero or one Group that matches the filter.
     * @param {GroupFindUniqueArgs} args - Arguments to find a Group
     * @example
     * // Get one Group
     * const group = await prisma.group.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUnique<T extends GroupFindUniqueArgs>(args: SelectSubset<T, GroupFindUniqueArgs<ExtArgs>>): Prisma__GroupClient<$Result.GetResult<Prisma.$GroupPayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find one Group that matches the filter or throw an error with `error.code='P2025'`
     * if no matches were found.
     * @param {GroupFindUniqueOrThrowArgs} args - Arguments to find a Group
     * @example
     * // Get one Group
     * const group = await prisma.group.findUniqueOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUniqueOrThrow<T extends GroupFindUniqueOrThrowArgs>(args: SelectSubset<T, GroupFindUniqueOrThrowArgs<ExtArgs>>): Prisma__GroupClient<$Result.GetResult<Prisma.$GroupPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first Group 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 {GroupFindFirstArgs} args - Arguments to find a Group
     * @example
     * // Get one Group
     * const group = await prisma.group.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends GroupFindFirstArgs>(args?: SelectSubset<T, GroupFindFirstArgs<ExtArgs>>): Prisma__GroupClient<$Result.GetResult<Prisma.$GroupPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first Group 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 {GroupFindFirstOrThrowArgs} args - Arguments to find a Group
     * @example
     * // Get one Group
     * const group = await prisma.group.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends GroupFindFirstOrThrowArgs>(args?: SelectSubset<T, GroupFindFirstOrThrowArgs<ExtArgs>>): Prisma__GroupClient<$Result.GetResult<Prisma.$GroupPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find zero or more Groups 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 {GroupFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all Groups
     * const groups = await prisma.group.findMany()
     * 
     * // Get first 10 Groups
     * const groups = await prisma.group.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const groupWithIdOnly = await prisma.group.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends GroupFindManyArgs>(args?: SelectSubset<T, GroupFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$GroupPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>

    /**
     * Create a Group.
     * @param {GroupCreateArgs} args - Arguments to create a Group.
     * @example
     * // Create one Group
     * const Group = await prisma.group.create({
     *   data: {
     *     // ... data to create a Group
     *   }
     * })
     * 
     */
    create<T extends GroupCreateArgs>(args: SelectSubset<T, GroupCreateArgs<ExtArgs>>): Prisma__GroupClient<$Result.GetResult<Prisma.$GroupPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Create many Groups.
     * @param {GroupCreateManyArgs} args - Arguments to create many Groups.
     * @example
     * // Create many Groups
     * const group = await prisma.group.createMany({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     *     
     */
    createMany<T extends GroupCreateManyArgs>(args?: SelectSubset<T, GroupCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create many Groups and returns the data saved in the database.
     * @param {GroupCreateManyAndReturnArgs} args - Arguments to create many Groups.
     * @example
     * // Create many Groups
     * const group = await prisma.group.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many Groups and only return the `id`
     * const groupWithIdOnly = await prisma.group.createManyAndReturn({
     *   select: { id: true },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    createManyAndReturn<T extends GroupCreateManyAndReturnArgs>(args?: SelectSubset<T, GroupCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$GroupPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>

    /**
     * Delete a Group.
     * @param {GroupDeleteArgs} args - Arguments to delete one Group.
     * @example
     * // Delete one Group
     * const Group = await prisma.group.delete({
     *   where: {
     *     // ... filter to delete one Group
     *   }
     * })
     * 
     */
    delete<T extends GroupDeleteArgs>(args: SelectSubset<T, GroupDeleteArgs<ExtArgs>>): Prisma__GroupClient<$Result.GetResult<Prisma.$GroupPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Update one Group.
     * @param {GroupUpdateArgs} args - Arguments to update one Group.
     * @example
     * // Update one Group
     * const group = await prisma.group.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends GroupUpdateArgs>(args: SelectSubset<T, GroupUpdateArgs<ExtArgs>>): Prisma__GroupClient<$Result.GetResult<Prisma.$GroupPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Delete zero or more Groups.
     * @param {GroupDeleteManyArgs} args - Arguments to filter Groups to delete.
     * @example
     * // Delete a few Groups
     * const { count } = await prisma.group.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
     */
    deleteMany<T extends GroupDeleteManyArgs>(args?: SelectSubset<T, GroupDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more Groups.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {GroupUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many Groups
     * const group = await prisma.group.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    updateMany<T extends GroupUpdateManyArgs>(args: SelectSubset<T, GroupUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more Groups and returns the data updated in the database.
     * @param {GroupUpdateManyAndReturnArgs} args - Arguments to update many Groups.
     * @example
     * // Update many Groups
     * const group = await prisma.group.updateManyAndReturn({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Update zero or more Groups and only return the `id`
     * const groupWithIdOnly = await prisma.group.updateManyAndReturn({
     *   select: { id: true },
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    updateManyAndReturn<T extends GroupUpdateManyAndReturnArgs>(args: SelectSubset<T, GroupUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$GroupPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>

    /**
     * Create or update one Group.
     * @param {GroupUpsertArgs} args - Arguments to update or create a Group.
     * @example
     * // Update or create a Group
     * const group = await prisma.group.upsert({
     *   create: {
     *     // ... data to create a Group
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the Group we want to update
     *   }
     * })
     */
    upsert<T extends GroupUpsertArgs>(args: SelectSubset<T, GroupUpsertArgs<ExtArgs>>): Prisma__GroupClient<$Result.GetResult<Prisma.$GroupPayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>


    /**
     * Count the number of Groups.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {GroupCountArgs} args - Arguments to filter Groups to count.
     * @example
     * // Count the number of Groups
     * const count = await prisma.group.count({
     *   where: {
     *     // ... the filter for the Groups we want to count
     *   }
     * })
    **/
    count<T extends GroupCountArgs>(
      args?: Subset<T, GroupCountArgs>,
    ): Prisma.PrismaPromise<
      T extends $Utils.Record<'select', any>
        ? T['select'] extends true
          ? number
          : GetScalarType<T['select'], GroupCountAggregateOutputType>
        : number
    >

    /**
     * Allows you to perform aggregations operations on a Group.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {GroupAggregateArgs} 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 GroupAggregateArgs>(args: Subset<T, GroupAggregateArgs>): Prisma.PrismaPromise<GetGroupAggregateType<T>>

    /**
     * Group by Group.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {GroupGroupByArgs} 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 GroupGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: GroupGroupByArgs['orderBy'] }
        : { orderBy?: GroupGroupByArgs['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, GroupGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetGroupGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the Group model
   */
  readonly fields: GroupFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for Group.
   * 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__GroupClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    countries<T extends Group$countriesArgs<ExtArgs> = {}>(args?: Subset<T, Group$countriesArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$CountryPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    /**
     * 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 Group model
   */
  interface GroupFieldRefs {
    readonly id: FieldRef<"Group", 'String'>
    readonly name: FieldRef<"Group", 'String'>
  }
    

  // Custom InputTypes
  /**
   * Group findUnique
   */
  export type GroupFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Group
     */
    select?: GroupSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Group
     */
    omit?: GroupOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: GroupInclude<ExtArgs> | null
    /**
     * Filter, which Group to fetch.
     */
    where: GroupWhereUniqueInput
  }

  /**
   * Group findUniqueOrThrow
   */
  export type GroupFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Group
     */
    select?: GroupSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Group
     */
    omit?: GroupOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: GroupInclude<ExtArgs> | null
    /**
     * Filter, which Group to fetch.
     */
    where: GroupWhereUniqueInput
  }

  /**
   * Group findFirst
   */
  export type GroupFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Group
     */
    select?: GroupSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Group
     */
    omit?: GroupOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: GroupInclude<ExtArgs> | null
    /**
     * Filter, which Group to fetch.
     */
    where?: GroupWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Groups to fetch.
     */
    orderBy?: GroupOrderByWithRelationInput | GroupOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Groups.
     */
    cursor?: GroupWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Groups 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` Groups.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Groups.
     */
    distinct?: GroupScalarFieldEnum | GroupScalarFieldEnum[]
  }

  /**
   * Group findFirstOrThrow
   */
  export type GroupFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Group
     */
    select?: GroupSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Group
     */
    omit?: GroupOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: GroupInclude<ExtArgs> | null
    /**
     * Filter, which Group to fetch.
     */
    where?: GroupWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Groups to fetch.
     */
    orderBy?: GroupOrderByWithRelationInput | GroupOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Groups.
     */
    cursor?: GroupWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Groups 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` Groups.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Groups.
     */
    distinct?: GroupScalarFieldEnum | GroupScalarFieldEnum[]
  }

  /**
   * Group findMany
   */
  export type GroupFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Group
     */
    select?: GroupSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Group
     */
    omit?: GroupOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: GroupInclude<ExtArgs> | null
    /**
     * Filter, which Groups to fetch.
     */
    where?: GroupWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Groups to fetch.
     */
    orderBy?: GroupOrderByWithRelationInput | GroupOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing Groups.
     */
    cursor?: GroupWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Groups 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` Groups.
     */
    skip?: number
    distinct?: GroupScalarFieldEnum | GroupScalarFieldEnum[]
  }

  /**
   * Group create
   */
  export type GroupCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Group
     */
    select?: GroupSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Group
     */
    omit?: GroupOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: GroupInclude<ExtArgs> | null
    /**
     * The data needed to create a Group.
     */
    data: XOR<GroupCreateInput, GroupUncheckedCreateInput>
  }

  /**
   * Group createMany
   */
  export type GroupCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many Groups.
     */
    data: GroupCreateManyInput | GroupCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * Group createManyAndReturn
   */
  export type GroupCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Group
     */
    select?: GroupSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the Group
     */
    omit?: GroupOmit<ExtArgs> | null
    /**
     * The data used to create many Groups.
     */
    data: GroupCreateManyInput | GroupCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * Group update
   */
  export type GroupUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Group
     */
    select?: GroupSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Group
     */
    omit?: GroupOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: GroupInclude<ExtArgs> | null
    /**
     * The data needed to update a Group.
     */
    data: XOR<GroupUpdateInput, GroupUncheckedUpdateInput>
    /**
     * Choose, which Group to update.
     */
    where: GroupWhereUniqueInput
  }

  /**
   * Group updateMany
   */
  export type GroupUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Groups.
     */
    data: XOR<GroupUpdateManyMutationInput, GroupUncheckedUpdateManyInput>
    /**
     * Filter which Groups to update
     */
    where?: GroupWhereInput
    /**
     * Limit how many Groups to update.
     */
    limit?: number
  }

  /**
   * Group updateManyAndReturn
   */
  export type GroupUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Group
     */
    select?: GroupSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the Group
     */
    omit?: GroupOmit<ExtArgs> | null
    /**
     * The data used to update Groups.
     */
    data: XOR<GroupUpdateManyMutationInput, GroupUncheckedUpdateManyInput>
    /**
     * Filter which Groups to update
     */
    where?: GroupWhereInput
    /**
     * Limit how many Groups to update.
     */
    limit?: number
  }

  /**
   * Group upsert
   */
  export type GroupUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Group
     */
    select?: GroupSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Group
     */
    omit?: GroupOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: GroupInclude<ExtArgs> | null
    /**
     * The filter to search for the Group to update in case it exists.
     */
    where: GroupWhereUniqueInput
    /**
     * In case the Group found by the `where` argument doesn't exist, create a new Group with this data.
     */
    create: XOR<GroupCreateInput, GroupUncheckedCreateInput>
    /**
     * In case the Group was found with the provided `where` argument, update it with this data.
     */
    update: XOR<GroupUpdateInput, GroupUncheckedUpdateInput>
  }

  /**
   * Group delete
   */
  export type GroupDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Group
     */
    select?: GroupSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Group
     */
    omit?: GroupOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: GroupInclude<ExtArgs> | null
    /**
     * Filter which Group to delete.
     */
    where: GroupWhereUniqueInput
  }

  /**
   * Group deleteMany
   */
  export type GroupDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Groups to delete
     */
    where?: GroupWhereInput
    /**
     * Limit how many Groups to delete.
     */
    limit?: number
  }

  /**
   * Group.countries
   */
  export type Group$countriesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Country
     */
    select?: CountrySelect<ExtArgs> | null
    /**
     * Omit specific fields from the Country
     */
    omit?: CountryOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CountryInclude<ExtArgs> | null
    where?: CountryWhereInput
    orderBy?: CountryOrderByWithRelationInput | CountryOrderByWithRelationInput[]
    cursor?: CountryWhereUniqueInput
    take?: number
    skip?: number
    distinct?: CountryScalarFieldEnum | CountryScalarFieldEnum[]
  }

  /**
   * Group without action
   */
  export type GroupDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Group
     */
    select?: GroupSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Group
     */
    omit?: GroupOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: GroupInclude<ExtArgs> | null
  }


  /**
   * Model Player
   */

  export type AggregatePlayer = {
    _count: PlayerCountAggregateOutputType | null
    _avg: PlayerAvgAggregateOutputType | null
    _sum: PlayerSumAggregateOutputType | null
    _min: PlayerMinAggregateOutputType | null
    _max: PlayerMaxAggregateOutputType | null
  }

  export type PlayerAvgAggregateOutputType = {
    price: number | null
    totalPoints: number | null
  }

  export type PlayerSumAggregateOutputType = {
    price: number | null
    totalPoints: number | null
  }

  export type PlayerMinAggregateOutputType = {
    id: string | null
    name: string | null
    image: string | null
    position: $Enums.Position | null
    countryId: string | null
    price: number | null
    totalPoints: number | null
    isActive: boolean | null
    isGoldenCardEligible: boolean | null
    cardTier: $Enums.CardTier | null
    createdAt: Date | null
    updatedAt: Date | null
  }

  export type PlayerMaxAggregateOutputType = {
    id: string | null
    name: string | null
    image: string | null
    position: $Enums.Position | null
    countryId: string | null
    price: number | null
    totalPoints: number | null
    isActive: boolean | null
    isGoldenCardEligible: boolean | null
    cardTier: $Enums.CardTier | null
    createdAt: Date | null
    updatedAt: Date | null
  }

  export type PlayerCountAggregateOutputType = {
    id: number
    name: number
    image: number
    position: number
    countryId: number
    price: number
    totalPoints: number
    isActive: number
    isGoldenCardEligible: number
    cardTier: number
    createdAt: number
    updatedAt: number
    _all: number
  }


  export type PlayerAvgAggregateInputType = {
    price?: true
    totalPoints?: true
  }

  export type PlayerSumAggregateInputType = {
    price?: true
    totalPoints?: true
  }

  export type PlayerMinAggregateInputType = {
    id?: true
    name?: true
    image?: true
    position?: true
    countryId?: true
    price?: true
    totalPoints?: true
    isActive?: true
    isGoldenCardEligible?: true
    cardTier?: true
    createdAt?: true
    updatedAt?: true
  }

  export type PlayerMaxAggregateInputType = {
    id?: true
    name?: true
    image?: true
    position?: true
    countryId?: true
    price?: true
    totalPoints?: true
    isActive?: true
    isGoldenCardEligible?: true
    cardTier?: true
    createdAt?: true
    updatedAt?: true
  }

  export type PlayerCountAggregateInputType = {
    id?: true
    name?: true
    image?: true
    position?: true
    countryId?: true
    price?: true
    totalPoints?: true
    isActive?: true
    isGoldenCardEligible?: true
    cardTier?: true
    createdAt?: true
    updatedAt?: true
    _all?: true
  }

  export type PlayerAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Player to aggregate.
     */
    where?: PlayerWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Players to fetch.
     */
    orderBy?: PlayerOrderByWithRelationInput | PlayerOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: PlayerWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Players 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` Players.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned Players
    **/
    _count?: true | PlayerCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: PlayerAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: PlayerSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: PlayerMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: PlayerMaxAggregateInputType
  }

  export type GetPlayerAggregateType<T extends PlayerAggregateArgs> = {
        [P in keyof T & keyof AggregatePlayer]: P extends '_count' | 'count'
      ? T[P] extends true
        ? number
        : GetScalarType<T[P], AggregatePlayer[P]>
      : GetScalarType<T[P], AggregatePlayer[P]>
  }




  export type PlayerGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: PlayerWhereInput
    orderBy?: PlayerOrderByWithAggregationInput | PlayerOrderByWithAggregationInput[]
    by: PlayerScalarFieldEnum[] | PlayerScalarFieldEnum
    having?: PlayerScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: PlayerCountAggregateInputType | true
    _avg?: PlayerAvgAggregateInputType
    _sum?: PlayerSumAggregateInputType
    _min?: PlayerMinAggregateInputType
    _max?: PlayerMaxAggregateInputType
  }

  export type PlayerGroupByOutputType = {
    id: string
    name: string
    image: string | null
    position: $Enums.Position
    countryId: string
    price: number
    totalPoints: number
    isActive: boolean
    isGoldenCardEligible: boolean
    cardTier: $Enums.CardTier
    createdAt: Date
    updatedAt: Date
    _count: PlayerCountAggregateOutputType | null
    _avg: PlayerAvgAggregateOutputType | null
    _sum: PlayerSumAggregateOutputType | null
    _min: PlayerMinAggregateOutputType | null
    _max: PlayerMaxAggregateOutputType | null
  }

  type GetPlayerGroupByPayload<T extends PlayerGroupByArgs> = Prisma.PrismaPromise<
    Array<
      PickEnumerable<PlayerGroupByOutputType, T['by']> &
        {
          [P in ((keyof T) & (keyof PlayerGroupByOutputType))]: P extends '_count'
            ? T[P] extends boolean
              ? number
              : GetScalarType<T[P], PlayerGroupByOutputType[P]>
            : GetScalarType<T[P], PlayerGroupByOutputType[P]>
        }
      >
    >


  export type PlayerSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
    image?: boolean
    position?: boolean
    countryId?: boolean
    price?: boolean
    totalPoints?: boolean
    isActive?: boolean
    isGoldenCardEligible?: boolean
    cardTier?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    country?: boolean | CountryDefaultArgs<ExtArgs>
    matchStats?: boolean | Player$matchStatsArgs<ExtArgs>
    teamPlayers?: boolean | Player$teamPlayersArgs<ExtArgs>
    events?: boolean | Player$eventsArgs<ExtArgs>
    goldenCards?: boolean | Player$goldenCardsArgs<ExtArgs>
    _count?: boolean | PlayerCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["player"]>

  export type PlayerSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
    image?: boolean
    position?: boolean
    countryId?: boolean
    price?: boolean
    totalPoints?: boolean
    isActive?: boolean
    isGoldenCardEligible?: boolean
    cardTier?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    country?: boolean | CountryDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["player"]>

  export type PlayerSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
    image?: boolean
    position?: boolean
    countryId?: boolean
    price?: boolean
    totalPoints?: boolean
    isActive?: boolean
    isGoldenCardEligible?: boolean
    cardTier?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    country?: boolean | CountryDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["player"]>

  export type PlayerSelectScalar = {
    id?: boolean
    name?: boolean
    image?: boolean
    position?: boolean
    countryId?: boolean
    price?: boolean
    totalPoints?: boolean
    isActive?: boolean
    isGoldenCardEligible?: boolean
    cardTier?: boolean
    createdAt?: boolean
    updatedAt?: boolean
  }

  export type PlayerOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "name" | "image" | "position" | "countryId" | "price" | "totalPoints" | "isActive" | "isGoldenCardEligible" | "cardTier" | "createdAt" | "updatedAt", ExtArgs["result"]["player"]>
  export type PlayerInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    country?: boolean | CountryDefaultArgs<ExtArgs>
    matchStats?: boolean | Player$matchStatsArgs<ExtArgs>
    teamPlayers?: boolean | Player$teamPlayersArgs<ExtArgs>
    events?: boolean | Player$eventsArgs<ExtArgs>
    goldenCards?: boolean | Player$goldenCardsArgs<ExtArgs>
    _count?: boolean | PlayerCountOutputTypeDefaultArgs<ExtArgs>
  }
  export type PlayerIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    country?: boolean | CountryDefaultArgs<ExtArgs>
  }
  export type PlayerIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    country?: boolean | CountryDefaultArgs<ExtArgs>
  }

  export type $PlayerPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Player"
    objects: {
      country: Prisma.$CountryPayload<ExtArgs>
      matchStats: Prisma.$PlayerMatchStatPayload<ExtArgs>[]
      teamPlayers: Prisma.$TeamPlayerPayload<ExtArgs>[]
      events: Prisma.$MatchEventPayload<ExtArgs>[]
      goldenCards: Prisma.$GoldenCardPayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      name: string
      image: string | null
      position: $Enums.Position
      countryId: string
      price: number
      totalPoints: number
      isActive: boolean
      isGoldenCardEligible: boolean
      cardTier: $Enums.CardTier
      createdAt: Date
      updatedAt: Date
    }, ExtArgs["result"]["player"]>
    composites: {}
  }

  type PlayerGetPayload<S extends boolean | null | undefined | PlayerDefaultArgs> = $Result.GetResult<Prisma.$PlayerPayload, S>

  type PlayerCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
    Omit<PlayerFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
      select?: PlayerCountAggregateInputType | true
    }

  export interface PlayerDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> {
    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['Player'], meta: { name: 'Player' } }
    /**
     * Find zero or one Player that matches the filter.
     * @param {PlayerFindUniqueArgs} args - Arguments to find a Player
     * @example
     * // Get one Player
     * const player = await prisma.player.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUnique<T extends PlayerFindUniqueArgs>(args: SelectSubset<T, PlayerFindUniqueArgs<ExtArgs>>): Prisma__PlayerClient<$Result.GetResult<Prisma.$PlayerPayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find one Player that matches the filter or throw an error with `error.code='P2025'`
     * if no matches were found.
     * @param {PlayerFindUniqueOrThrowArgs} args - Arguments to find a Player
     * @example
     * // Get one Player
     * const player = await prisma.player.findUniqueOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUniqueOrThrow<T extends PlayerFindUniqueOrThrowArgs>(args: SelectSubset<T, PlayerFindUniqueOrThrowArgs<ExtArgs>>): Prisma__PlayerClient<$Result.GetResult<Prisma.$PlayerPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first Player 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 {PlayerFindFirstArgs} args - Arguments to find a Player
     * @example
     * // Get one Player
     * const player = await prisma.player.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends PlayerFindFirstArgs>(args?: SelectSubset<T, PlayerFindFirstArgs<ExtArgs>>): Prisma__PlayerClient<$Result.GetResult<Prisma.$PlayerPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first Player 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 {PlayerFindFirstOrThrowArgs} args - Arguments to find a Player
     * @example
     * // Get one Player
     * const player = await prisma.player.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends PlayerFindFirstOrThrowArgs>(args?: SelectSubset<T, PlayerFindFirstOrThrowArgs<ExtArgs>>): Prisma__PlayerClient<$Result.GetResult<Prisma.$PlayerPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find zero or more Players 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 {PlayerFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all Players
     * const players = await prisma.player.findMany()
     * 
     * // Get first 10 Players
     * const players = await prisma.player.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const playerWithIdOnly = await prisma.player.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends PlayerFindManyArgs>(args?: SelectSubset<T, PlayerFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$PlayerPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>

    /**
     * Create a Player.
     * @param {PlayerCreateArgs} args - Arguments to create a Player.
     * @example
     * // Create one Player
     * const Player = await prisma.player.create({
     *   data: {
     *     // ... data to create a Player
     *   }
     * })
     * 
     */
    create<T extends PlayerCreateArgs>(args: SelectSubset<T, PlayerCreateArgs<ExtArgs>>): Prisma__PlayerClient<$Result.GetResult<Prisma.$PlayerPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Create many Players.
     * @param {PlayerCreateManyArgs} args - Arguments to create many Players.
     * @example
     * // Create many Players
     * const player = await prisma.player.createMany({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     *     
     */
    createMany<T extends PlayerCreateManyArgs>(args?: SelectSubset<T, PlayerCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create many Players and returns the data saved in the database.
     * @param {PlayerCreateManyAndReturnArgs} args - Arguments to create many Players.
     * @example
     * // Create many Players
     * const player = await prisma.player.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many Players and only return the `id`
     * const playerWithIdOnly = await prisma.player.createManyAndReturn({
     *   select: { id: true },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    createManyAndReturn<T extends PlayerCreateManyAndReturnArgs>(args?: SelectSubset<T, PlayerCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$PlayerPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>

    /**
     * Delete a Player.
     * @param {PlayerDeleteArgs} args - Arguments to delete one Player.
     * @example
     * // Delete one Player
     * const Player = await prisma.player.delete({
     *   where: {
     *     // ... filter to delete one Player
     *   }
     * })
     * 
     */
    delete<T extends PlayerDeleteArgs>(args: SelectSubset<T, PlayerDeleteArgs<ExtArgs>>): Prisma__PlayerClient<$Result.GetResult<Prisma.$PlayerPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Update one Player.
     * @param {PlayerUpdateArgs} args - Arguments to update one Player.
     * @example
     * // Update one Player
     * const player = await prisma.player.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends PlayerUpdateArgs>(args: SelectSubset<T, PlayerUpdateArgs<ExtArgs>>): Prisma__PlayerClient<$Result.GetResult<Prisma.$PlayerPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Delete zero or more Players.
     * @param {PlayerDeleteManyArgs} args - Arguments to filter Players to delete.
     * @example
     * // Delete a few Players
     * const { count } = await prisma.player.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
     */
    deleteMany<T extends PlayerDeleteManyArgs>(args?: SelectSubset<T, PlayerDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more Players.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {PlayerUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many Players
     * const player = await prisma.player.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    updateMany<T extends PlayerUpdateManyArgs>(args: SelectSubset<T, PlayerUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more Players and returns the data updated in the database.
     * @param {PlayerUpdateManyAndReturnArgs} args - Arguments to update many Players.
     * @example
     * // Update many Players
     * const player = await prisma.player.updateManyAndReturn({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Update zero or more Players and only return the `id`
     * const playerWithIdOnly = await prisma.player.updateManyAndReturn({
     *   select: { id: true },
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    updateManyAndReturn<T extends PlayerUpdateManyAndReturnArgs>(args: SelectSubset<T, PlayerUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$PlayerPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>

    /**
     * Create or update one Player.
     * @param {PlayerUpsertArgs} args - Arguments to update or create a Player.
     * @example
     * // Update or create a Player
     * const player = await prisma.player.upsert({
     *   create: {
     *     // ... data to create a Player
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the Player we want to update
     *   }
     * })
     */
    upsert<T extends PlayerUpsertArgs>(args: SelectSubset<T, PlayerUpsertArgs<ExtArgs>>): Prisma__PlayerClient<$Result.GetResult<Prisma.$PlayerPayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>


    /**
     * Count the number of Players.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {PlayerCountArgs} args - Arguments to filter Players to count.
     * @example
     * // Count the number of Players
     * const count = await prisma.player.count({
     *   where: {
     *     // ... the filter for the Players we want to count
     *   }
     * })
    **/
    count<T extends PlayerCountArgs>(
      args?: Subset<T, PlayerCountArgs>,
    ): Prisma.PrismaPromise<
      T extends $Utils.Record<'select', any>
        ? T['select'] extends true
          ? number
          : GetScalarType<T['select'], PlayerCountAggregateOutputType>
        : number
    >

    /**
     * Allows you to perform aggregations operations on a Player.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {PlayerAggregateArgs} 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 PlayerAggregateArgs>(args: Subset<T, PlayerAggregateArgs>): Prisma.PrismaPromise<GetPlayerAggregateType<T>>

    /**
     * Group by Player.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {PlayerGroupByArgs} 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 PlayerGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: PlayerGroupByArgs['orderBy'] }
        : { orderBy?: PlayerGroupByArgs['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, PlayerGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetPlayerGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the Player model
   */
  readonly fields: PlayerFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for Player.
   * 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__PlayerClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    country<T extends CountryDefaultArgs<ExtArgs> = {}>(args?: Subset<T, CountryDefaultArgs<ExtArgs>>): Prisma__CountryClient<$Result.GetResult<Prisma.$CountryPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
    matchStats<T extends Player$matchStatsArgs<ExtArgs> = {}>(args?: Subset<T, Player$matchStatsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$PlayerMatchStatPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    teamPlayers<T extends Player$teamPlayersArgs<ExtArgs> = {}>(args?: Subset<T, Player$teamPlayersArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$TeamPlayerPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    events<T extends Player$eventsArgs<ExtArgs> = {}>(args?: Subset<T, Player$eventsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$MatchEventPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    goldenCards<T extends Player$goldenCardsArgs<ExtArgs> = {}>(args?: Subset<T, Player$goldenCardsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$GoldenCardPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    /**
     * 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 Player model
   */
  interface PlayerFieldRefs {
    readonly id: FieldRef<"Player", 'String'>
    readonly name: FieldRef<"Player", 'String'>
    readonly image: FieldRef<"Player", 'String'>
    readonly position: FieldRef<"Player", 'Position'>
    readonly countryId: FieldRef<"Player", 'String'>
    readonly price: FieldRef<"Player", 'Float'>
    readonly totalPoints: FieldRef<"Player", 'Int'>
    readonly isActive: FieldRef<"Player", 'Boolean'>
    readonly isGoldenCardEligible: FieldRef<"Player", 'Boolean'>
    readonly cardTier: FieldRef<"Player", 'CardTier'>
    readonly createdAt: FieldRef<"Player", 'DateTime'>
    readonly updatedAt: FieldRef<"Player", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * Player findUnique
   */
  export type PlayerFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Player
     */
    select?: PlayerSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Player
     */
    omit?: PlayerOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PlayerInclude<ExtArgs> | null
    /**
     * Filter, which Player to fetch.
     */
    where: PlayerWhereUniqueInput
  }

  /**
   * Player findUniqueOrThrow
   */
  export type PlayerFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Player
     */
    select?: PlayerSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Player
     */
    omit?: PlayerOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PlayerInclude<ExtArgs> | null
    /**
     * Filter, which Player to fetch.
     */
    where: PlayerWhereUniqueInput
  }

  /**
   * Player findFirst
   */
  export type PlayerFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Player
     */
    select?: PlayerSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Player
     */
    omit?: PlayerOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PlayerInclude<ExtArgs> | null
    /**
     * Filter, which Player to fetch.
     */
    where?: PlayerWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Players to fetch.
     */
    orderBy?: PlayerOrderByWithRelationInput | PlayerOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Players.
     */
    cursor?: PlayerWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Players 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` Players.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Players.
     */
    distinct?: PlayerScalarFieldEnum | PlayerScalarFieldEnum[]
  }

  /**
   * Player findFirstOrThrow
   */
  export type PlayerFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Player
     */
    select?: PlayerSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Player
     */
    omit?: PlayerOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PlayerInclude<ExtArgs> | null
    /**
     * Filter, which Player to fetch.
     */
    where?: PlayerWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Players to fetch.
     */
    orderBy?: PlayerOrderByWithRelationInput | PlayerOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Players.
     */
    cursor?: PlayerWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Players 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` Players.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Players.
     */
    distinct?: PlayerScalarFieldEnum | PlayerScalarFieldEnum[]
  }

  /**
   * Player findMany
   */
  export type PlayerFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Player
     */
    select?: PlayerSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Player
     */
    omit?: PlayerOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PlayerInclude<ExtArgs> | null
    /**
     * Filter, which Players to fetch.
     */
    where?: PlayerWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Players to fetch.
     */
    orderBy?: PlayerOrderByWithRelationInput | PlayerOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing Players.
     */
    cursor?: PlayerWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Players 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` Players.
     */
    skip?: number
    distinct?: PlayerScalarFieldEnum | PlayerScalarFieldEnum[]
  }

  /**
   * Player create
   */
  export type PlayerCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Player
     */
    select?: PlayerSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Player
     */
    omit?: PlayerOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PlayerInclude<ExtArgs> | null
    /**
     * The data needed to create a Player.
     */
    data: XOR<PlayerCreateInput, PlayerUncheckedCreateInput>
  }

  /**
   * Player createMany
   */
  export type PlayerCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many Players.
     */
    data: PlayerCreateManyInput | PlayerCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * Player createManyAndReturn
   */
  export type PlayerCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Player
     */
    select?: PlayerSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the Player
     */
    omit?: PlayerOmit<ExtArgs> | null
    /**
     * The data used to create many Players.
     */
    data: PlayerCreateManyInput | PlayerCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PlayerIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * Player update
   */
  export type PlayerUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Player
     */
    select?: PlayerSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Player
     */
    omit?: PlayerOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PlayerInclude<ExtArgs> | null
    /**
     * The data needed to update a Player.
     */
    data: XOR<PlayerUpdateInput, PlayerUncheckedUpdateInput>
    /**
     * Choose, which Player to update.
     */
    where: PlayerWhereUniqueInput
  }

  /**
   * Player updateMany
   */
  export type PlayerUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Players.
     */
    data: XOR<PlayerUpdateManyMutationInput, PlayerUncheckedUpdateManyInput>
    /**
     * Filter which Players to update
     */
    where?: PlayerWhereInput
    /**
     * Limit how many Players to update.
     */
    limit?: number
  }

  /**
   * Player updateManyAndReturn
   */
  export type PlayerUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Player
     */
    select?: PlayerSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the Player
     */
    omit?: PlayerOmit<ExtArgs> | null
    /**
     * The data used to update Players.
     */
    data: XOR<PlayerUpdateManyMutationInput, PlayerUncheckedUpdateManyInput>
    /**
     * Filter which Players to update
     */
    where?: PlayerWhereInput
    /**
     * Limit how many Players to update.
     */
    limit?: number
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PlayerIncludeUpdateManyAndReturn<ExtArgs> | null
  }

  /**
   * Player upsert
   */
  export type PlayerUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Player
     */
    select?: PlayerSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Player
     */
    omit?: PlayerOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PlayerInclude<ExtArgs> | null
    /**
     * The filter to search for the Player to update in case it exists.
     */
    where: PlayerWhereUniqueInput
    /**
     * In case the Player found by the `where` argument doesn't exist, create a new Player with this data.
     */
    create: XOR<PlayerCreateInput, PlayerUncheckedCreateInput>
    /**
     * In case the Player was found with the provided `where` argument, update it with this data.
     */
    update: XOR<PlayerUpdateInput, PlayerUncheckedUpdateInput>
  }

  /**
   * Player delete
   */
  export type PlayerDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Player
     */
    select?: PlayerSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Player
     */
    omit?: PlayerOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PlayerInclude<ExtArgs> | null
    /**
     * Filter which Player to delete.
     */
    where: PlayerWhereUniqueInput
  }

  /**
   * Player deleteMany
   */
  export type PlayerDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Players to delete
     */
    where?: PlayerWhereInput
    /**
     * Limit how many Players to delete.
     */
    limit?: number
  }

  /**
   * Player.matchStats
   */
  export type Player$matchStatsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PlayerMatchStat
     */
    select?: PlayerMatchStatSelect<ExtArgs> | null
    /**
     * Omit specific fields from the PlayerMatchStat
     */
    omit?: PlayerMatchStatOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PlayerMatchStatInclude<ExtArgs> | null
    where?: PlayerMatchStatWhereInput
    orderBy?: PlayerMatchStatOrderByWithRelationInput | PlayerMatchStatOrderByWithRelationInput[]
    cursor?: PlayerMatchStatWhereUniqueInput
    take?: number
    skip?: number
    distinct?: PlayerMatchStatScalarFieldEnum | PlayerMatchStatScalarFieldEnum[]
  }

  /**
   * Player.teamPlayers
   */
  export type Player$teamPlayersArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TeamPlayer
     */
    select?: TeamPlayerSelect<ExtArgs> | null
    /**
     * Omit specific fields from the TeamPlayer
     */
    omit?: TeamPlayerOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TeamPlayerInclude<ExtArgs> | null
    where?: TeamPlayerWhereInput
    orderBy?: TeamPlayerOrderByWithRelationInput | TeamPlayerOrderByWithRelationInput[]
    cursor?: TeamPlayerWhereUniqueInput
    take?: number
    skip?: number
    distinct?: TeamPlayerScalarFieldEnum | TeamPlayerScalarFieldEnum[]
  }

  /**
   * Player.events
   */
  export type Player$eventsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MatchEvent
     */
    select?: MatchEventSelect<ExtArgs> | null
    /**
     * Omit specific fields from the MatchEvent
     */
    omit?: MatchEventOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MatchEventInclude<ExtArgs> | null
    where?: MatchEventWhereInput
    orderBy?: MatchEventOrderByWithRelationInput | MatchEventOrderByWithRelationInput[]
    cursor?: MatchEventWhereUniqueInput
    take?: number
    skip?: number
    distinct?: MatchEventScalarFieldEnum | MatchEventScalarFieldEnum[]
  }

  /**
   * Player.goldenCards
   */
  export type Player$goldenCardsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the GoldenCard
     */
    select?: GoldenCardSelect<ExtArgs> | null
    /**
     * Omit specific fields from the GoldenCard
     */
    omit?: GoldenCardOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: GoldenCardInclude<ExtArgs> | null
    where?: GoldenCardWhereInput
    orderBy?: GoldenCardOrderByWithRelationInput | GoldenCardOrderByWithRelationInput[]
    cursor?: GoldenCardWhereUniqueInput
    take?: number
    skip?: number
    distinct?: GoldenCardScalarFieldEnum | GoldenCardScalarFieldEnum[]
  }

  /**
   * Player without action
   */
  export type PlayerDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Player
     */
    select?: PlayerSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Player
     */
    omit?: PlayerOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PlayerInclude<ExtArgs> | null
  }


  /**
   * Model Match
   */

  export type AggregateMatch = {
    _count: MatchCountAggregateOutputType | null
    _avg: MatchAvgAggregateOutputType | null
    _sum: MatchSumAggregateOutputType | null
    _min: MatchMinAggregateOutputType | null
    _max: MatchMaxAggregateOutputType | null
  }

  export type MatchAvgAggregateOutputType = {
    homeScore: number | null
    awayScore: number | null
    attendance: number | null
  }

  export type MatchSumAggregateOutputType = {
    homeScore: number | null
    awayScore: number | null
    attendance: number | null
  }

  export type MatchMinAggregateOutputType = {
    id: string | null
    homeTeamId: string | null
    awayTeamId: string | null
    homeScore: number | null
    awayScore: number | null
    stage: $Enums.MatchStage | null
    status: $Enums.MatchStatus | null
    matchDate: Date | null
    matchDatePersian: string | null
    stadium: string | null
    city: string | null
    referee: string | null
    assistant1: string | null
    assistant2: string | null
    fourthOfficial: string | null
    attendance: number | null
    weather: string | null
    description: string | null
    roundId: string | null
    createdAt: Date | null
  }

  export type MatchMaxAggregateOutputType = {
    id: string | null
    homeTeamId: string | null
    awayTeamId: string | null
    homeScore: number | null
    awayScore: number | null
    stage: $Enums.MatchStage | null
    status: $Enums.MatchStatus | null
    matchDate: Date | null
    matchDatePersian: string | null
    stadium: string | null
    city: string | null
    referee: string | null
    assistant1: string | null
    assistant2: string | null
    fourthOfficial: string | null
    attendance: number | null
    weather: string | null
    description: string | null
    roundId: string | null
    createdAt: Date | null
  }

  export type MatchCountAggregateOutputType = {
    id: number
    homeTeamId: number
    awayTeamId: number
    homeScore: number
    awayScore: number
    stage: number
    status: number
    matchDate: number
    matchDatePersian: number
    stadium: number
    city: number
    referee: number
    assistant1: number
    assistant2: number
    fourthOfficial: number
    attendance: number
    weather: number
    description: number
    roundId: number
    createdAt: number
    _all: number
  }


  export type MatchAvgAggregateInputType = {
    homeScore?: true
    awayScore?: true
    attendance?: true
  }

  export type MatchSumAggregateInputType = {
    homeScore?: true
    awayScore?: true
    attendance?: true
  }

  export type MatchMinAggregateInputType = {
    id?: true
    homeTeamId?: true
    awayTeamId?: true
    homeScore?: true
    awayScore?: true
    stage?: true
    status?: true
    matchDate?: true
    matchDatePersian?: true
    stadium?: true
    city?: true
    referee?: true
    assistant1?: true
    assistant2?: true
    fourthOfficial?: true
    attendance?: true
    weather?: true
    description?: true
    roundId?: true
    createdAt?: true
  }

  export type MatchMaxAggregateInputType = {
    id?: true
    homeTeamId?: true
    awayTeamId?: true
    homeScore?: true
    awayScore?: true
    stage?: true
    status?: true
    matchDate?: true
    matchDatePersian?: true
    stadium?: true
    city?: true
    referee?: true
    assistant1?: true
    assistant2?: true
    fourthOfficial?: true
    attendance?: true
    weather?: true
    description?: true
    roundId?: true
    createdAt?: true
  }

  export type MatchCountAggregateInputType = {
    id?: true
    homeTeamId?: true
    awayTeamId?: true
    homeScore?: true
    awayScore?: true
    stage?: true
    status?: true
    matchDate?: true
    matchDatePersian?: true
    stadium?: true
    city?: true
    referee?: true
    assistant1?: true
    assistant2?: true
    fourthOfficial?: true
    attendance?: true
    weather?: true
    description?: true
    roundId?: true
    createdAt?: true
    _all?: true
  }

  export type MatchAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Match to aggregate.
     */
    where?: MatchWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Matches to fetch.
     */
    orderBy?: MatchOrderByWithRelationInput | MatchOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: MatchWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Matches 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` Matches.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned Matches
    **/
    _count?: true | MatchCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: MatchAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: MatchSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: MatchMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: MatchMaxAggregateInputType
  }

  export type GetMatchAggregateType<T extends MatchAggregateArgs> = {
        [P in keyof T & keyof AggregateMatch]: P extends '_count' | 'count'
      ? T[P] extends true
        ? number
        : GetScalarType<T[P], AggregateMatch[P]>
      : GetScalarType<T[P], AggregateMatch[P]>
  }




  export type MatchGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: MatchWhereInput
    orderBy?: MatchOrderByWithAggregationInput | MatchOrderByWithAggregationInput[]
    by: MatchScalarFieldEnum[] | MatchScalarFieldEnum
    having?: MatchScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: MatchCountAggregateInputType | true
    _avg?: MatchAvgAggregateInputType
    _sum?: MatchSumAggregateInputType
    _min?: MatchMinAggregateInputType
    _max?: MatchMaxAggregateInputType
  }

  export type MatchGroupByOutputType = {
    id: string
    homeTeamId: string
    awayTeamId: string
    homeScore: number | null
    awayScore: number | null
    stage: $Enums.MatchStage
    status: $Enums.MatchStatus
    matchDate: Date
    matchDatePersian: string | null
    stadium: string | null
    city: string | null
    referee: string | null
    assistant1: string | null
    assistant2: string | null
    fourthOfficial: string | null
    attendance: number | null
    weather: string | null
    description: string | null
    roundId: string | null
    createdAt: Date
    _count: MatchCountAggregateOutputType | null
    _avg: MatchAvgAggregateOutputType | null
    _sum: MatchSumAggregateOutputType | null
    _min: MatchMinAggregateOutputType | null
    _max: MatchMaxAggregateOutputType | null
  }

  type GetMatchGroupByPayload<T extends MatchGroupByArgs> = Prisma.PrismaPromise<
    Array<
      PickEnumerable<MatchGroupByOutputType, T['by']> &
        {
          [P in ((keyof T) & (keyof MatchGroupByOutputType))]: P extends '_count'
            ? T[P] extends boolean
              ? number
              : GetScalarType<T[P], MatchGroupByOutputType[P]>
            : GetScalarType<T[P], MatchGroupByOutputType[P]>
        }
      >
    >


  export type MatchSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    homeTeamId?: boolean
    awayTeamId?: boolean
    homeScore?: boolean
    awayScore?: boolean
    stage?: boolean
    status?: boolean
    matchDate?: boolean
    matchDatePersian?: boolean
    stadium?: boolean
    city?: boolean
    referee?: boolean
    assistant1?: boolean
    assistant2?: boolean
    fourthOfficial?: boolean
    attendance?: boolean
    weather?: boolean
    description?: boolean
    roundId?: boolean
    createdAt?: boolean
    homeTeam?: boolean | CountryDefaultArgs<ExtArgs>
    awayTeam?: boolean | CountryDefaultArgs<ExtArgs>
    round?: boolean | Match$roundArgs<ExtArgs>
    playerStats?: boolean | Match$playerStatsArgs<ExtArgs>
    events?: boolean | Match$eventsArgs<ExtArgs>
    lineups?: boolean | Match$lineupsArgs<ExtArgs>
    _count?: boolean | MatchCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["match"]>

  export type MatchSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    homeTeamId?: boolean
    awayTeamId?: boolean
    homeScore?: boolean
    awayScore?: boolean
    stage?: boolean
    status?: boolean
    matchDate?: boolean
    matchDatePersian?: boolean
    stadium?: boolean
    city?: boolean
    referee?: boolean
    assistant1?: boolean
    assistant2?: boolean
    fourthOfficial?: boolean
    attendance?: boolean
    weather?: boolean
    description?: boolean
    roundId?: boolean
    createdAt?: boolean
    homeTeam?: boolean | CountryDefaultArgs<ExtArgs>
    awayTeam?: boolean | CountryDefaultArgs<ExtArgs>
    round?: boolean | Match$roundArgs<ExtArgs>
  }, ExtArgs["result"]["match"]>

  export type MatchSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    homeTeamId?: boolean
    awayTeamId?: boolean
    homeScore?: boolean
    awayScore?: boolean
    stage?: boolean
    status?: boolean
    matchDate?: boolean
    matchDatePersian?: boolean
    stadium?: boolean
    city?: boolean
    referee?: boolean
    assistant1?: boolean
    assistant2?: boolean
    fourthOfficial?: boolean
    attendance?: boolean
    weather?: boolean
    description?: boolean
    roundId?: boolean
    createdAt?: boolean
    homeTeam?: boolean | CountryDefaultArgs<ExtArgs>
    awayTeam?: boolean | CountryDefaultArgs<ExtArgs>
    round?: boolean | Match$roundArgs<ExtArgs>
  }, ExtArgs["result"]["match"]>

  export type MatchSelectScalar = {
    id?: boolean
    homeTeamId?: boolean
    awayTeamId?: boolean
    homeScore?: boolean
    awayScore?: boolean
    stage?: boolean
    status?: boolean
    matchDate?: boolean
    matchDatePersian?: boolean
    stadium?: boolean
    city?: boolean
    referee?: boolean
    assistant1?: boolean
    assistant2?: boolean
    fourthOfficial?: boolean
    attendance?: boolean
    weather?: boolean
    description?: boolean
    roundId?: boolean
    createdAt?: boolean
  }

  export type MatchOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "homeTeamId" | "awayTeamId" | "homeScore" | "awayScore" | "stage" | "status" | "matchDate" | "matchDatePersian" | "stadium" | "city" | "referee" | "assistant1" | "assistant2" | "fourthOfficial" | "attendance" | "weather" | "description" | "roundId" | "createdAt", ExtArgs["result"]["match"]>
  export type MatchInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    homeTeam?: boolean | CountryDefaultArgs<ExtArgs>
    awayTeam?: boolean | CountryDefaultArgs<ExtArgs>
    round?: boolean | Match$roundArgs<ExtArgs>
    playerStats?: boolean | Match$playerStatsArgs<ExtArgs>
    events?: boolean | Match$eventsArgs<ExtArgs>
    lineups?: boolean | Match$lineupsArgs<ExtArgs>
    _count?: boolean | MatchCountOutputTypeDefaultArgs<ExtArgs>
  }
  export type MatchIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    homeTeam?: boolean | CountryDefaultArgs<ExtArgs>
    awayTeam?: boolean | CountryDefaultArgs<ExtArgs>
    round?: boolean | Match$roundArgs<ExtArgs>
  }
  export type MatchIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    homeTeam?: boolean | CountryDefaultArgs<ExtArgs>
    awayTeam?: boolean | CountryDefaultArgs<ExtArgs>
    round?: boolean | Match$roundArgs<ExtArgs>
  }

  export type $MatchPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Match"
    objects: {
      homeTeam: Prisma.$CountryPayload<ExtArgs>
      awayTeam: Prisma.$CountryPayload<ExtArgs>
      round: Prisma.$RoundPayload<ExtArgs> | null
      playerStats: Prisma.$PlayerMatchStatPayload<ExtArgs>[]
      events: Prisma.$MatchEventPayload<ExtArgs>[]
      lineups: Prisma.$MatchLineupPayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      homeTeamId: string
      awayTeamId: string
      homeScore: number | null
      awayScore: number | null
      stage: $Enums.MatchStage
      status: $Enums.MatchStatus
      matchDate: Date
      matchDatePersian: string | null
      stadium: string | null
      city: string | null
      referee: string | null
      assistant1: string | null
      assistant2: string | null
      fourthOfficial: string | null
      attendance: number | null
      weather: string | null
      description: string | null
      roundId: string | null
      createdAt: Date
    }, ExtArgs["result"]["match"]>
    composites: {}
  }

  type MatchGetPayload<S extends boolean | null | undefined | MatchDefaultArgs> = $Result.GetResult<Prisma.$MatchPayload, S>

  type MatchCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
    Omit<MatchFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
      select?: MatchCountAggregateInputType | true
    }

  export interface MatchDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> {
    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['Match'], meta: { name: 'Match' } }
    /**
     * Find zero or one Match that matches the filter.
     * @param {MatchFindUniqueArgs} args - Arguments to find a Match
     * @example
     * // Get one Match
     * const match = await prisma.match.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUnique<T extends MatchFindUniqueArgs>(args: SelectSubset<T, MatchFindUniqueArgs<ExtArgs>>): Prisma__MatchClient<$Result.GetResult<Prisma.$MatchPayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find one Match that matches the filter or throw an error with `error.code='P2025'`
     * if no matches were found.
     * @param {MatchFindUniqueOrThrowArgs} args - Arguments to find a Match
     * @example
     * // Get one Match
     * const match = await prisma.match.findUniqueOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUniqueOrThrow<T extends MatchFindUniqueOrThrowArgs>(args: SelectSubset<T, MatchFindUniqueOrThrowArgs<ExtArgs>>): Prisma__MatchClient<$Result.GetResult<Prisma.$MatchPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first Match 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 {MatchFindFirstArgs} args - Arguments to find a Match
     * @example
     * // Get one Match
     * const match = await prisma.match.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends MatchFindFirstArgs>(args?: SelectSubset<T, MatchFindFirstArgs<ExtArgs>>): Prisma__MatchClient<$Result.GetResult<Prisma.$MatchPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first Match 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 {MatchFindFirstOrThrowArgs} args - Arguments to find a Match
     * @example
     * // Get one Match
     * const match = await prisma.match.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends MatchFindFirstOrThrowArgs>(args?: SelectSubset<T, MatchFindFirstOrThrowArgs<ExtArgs>>): Prisma__MatchClient<$Result.GetResult<Prisma.$MatchPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find zero or more Matches 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 {MatchFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all Matches
     * const matches = await prisma.match.findMany()
     * 
     * // Get first 10 Matches
     * const matches = await prisma.match.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const matchWithIdOnly = await prisma.match.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends MatchFindManyArgs>(args?: SelectSubset<T, MatchFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$MatchPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>

    /**
     * Create a Match.
     * @param {MatchCreateArgs} args - Arguments to create a Match.
     * @example
     * // Create one Match
     * const Match = await prisma.match.create({
     *   data: {
     *     // ... data to create a Match
     *   }
     * })
     * 
     */
    create<T extends MatchCreateArgs>(args: SelectSubset<T, MatchCreateArgs<ExtArgs>>): Prisma__MatchClient<$Result.GetResult<Prisma.$MatchPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Create many Matches.
     * @param {MatchCreateManyArgs} args - Arguments to create many Matches.
     * @example
     * // Create many Matches
     * const match = await prisma.match.createMany({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     *     
     */
    createMany<T extends MatchCreateManyArgs>(args?: SelectSubset<T, MatchCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create many Matches and returns the data saved in the database.
     * @param {MatchCreateManyAndReturnArgs} args - Arguments to create many Matches.
     * @example
     * // Create many Matches
     * const match = await prisma.match.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many Matches and only return the `id`
     * const matchWithIdOnly = await prisma.match.createManyAndReturn({
     *   select: { id: true },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    createManyAndReturn<T extends MatchCreateManyAndReturnArgs>(args?: SelectSubset<T, MatchCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$MatchPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>

    /**
     * Delete a Match.
     * @param {MatchDeleteArgs} args - Arguments to delete one Match.
     * @example
     * // Delete one Match
     * const Match = await prisma.match.delete({
     *   where: {
     *     // ... filter to delete one Match
     *   }
     * })
     * 
     */
    delete<T extends MatchDeleteArgs>(args: SelectSubset<T, MatchDeleteArgs<ExtArgs>>): Prisma__MatchClient<$Result.GetResult<Prisma.$MatchPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Update one Match.
     * @param {MatchUpdateArgs} args - Arguments to update one Match.
     * @example
     * // Update one Match
     * const match = await prisma.match.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends MatchUpdateArgs>(args: SelectSubset<T, MatchUpdateArgs<ExtArgs>>): Prisma__MatchClient<$Result.GetResult<Prisma.$MatchPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Delete zero or more Matches.
     * @param {MatchDeleteManyArgs} args - Arguments to filter Matches to delete.
     * @example
     * // Delete a few Matches
     * const { count } = await prisma.match.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
     */
    deleteMany<T extends MatchDeleteManyArgs>(args?: SelectSubset<T, MatchDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more Matches.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {MatchUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many Matches
     * const match = await prisma.match.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    updateMany<T extends MatchUpdateManyArgs>(args: SelectSubset<T, MatchUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more Matches and returns the data updated in the database.
     * @param {MatchUpdateManyAndReturnArgs} args - Arguments to update many Matches.
     * @example
     * // Update many Matches
     * const match = await prisma.match.updateManyAndReturn({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Update zero or more Matches and only return the `id`
     * const matchWithIdOnly = await prisma.match.updateManyAndReturn({
     *   select: { id: true },
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    updateManyAndReturn<T extends MatchUpdateManyAndReturnArgs>(args: SelectSubset<T, MatchUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$MatchPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>

    /**
     * Create or update one Match.
     * @param {MatchUpsertArgs} args - Arguments to update or create a Match.
     * @example
     * // Update or create a Match
     * const match = await prisma.match.upsert({
     *   create: {
     *     // ... data to create a Match
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the Match we want to update
     *   }
     * })
     */
    upsert<T extends MatchUpsertArgs>(args: SelectSubset<T, MatchUpsertArgs<ExtArgs>>): Prisma__MatchClient<$Result.GetResult<Prisma.$MatchPayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>


    /**
     * Count the number of Matches.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {MatchCountArgs} args - Arguments to filter Matches to count.
     * @example
     * // Count the number of Matches
     * const count = await prisma.match.count({
     *   where: {
     *     // ... the filter for the Matches we want to count
     *   }
     * })
    **/
    count<T extends MatchCountArgs>(
      args?: Subset<T, MatchCountArgs>,
    ): Prisma.PrismaPromise<
      T extends $Utils.Record<'select', any>
        ? T['select'] extends true
          ? number
          : GetScalarType<T['select'], MatchCountAggregateOutputType>
        : number
    >

    /**
     * Allows you to perform aggregations operations on a Match.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {MatchAggregateArgs} 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 MatchAggregateArgs>(args: Subset<T, MatchAggregateArgs>): Prisma.PrismaPromise<GetMatchAggregateType<T>>

    /**
     * Group by Match.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {MatchGroupByArgs} 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 MatchGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: MatchGroupByArgs['orderBy'] }
        : { orderBy?: MatchGroupByArgs['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, MatchGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetMatchGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the Match model
   */
  readonly fields: MatchFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for Match.
   * 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__MatchClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    homeTeam<T extends CountryDefaultArgs<ExtArgs> = {}>(args?: Subset<T, CountryDefaultArgs<ExtArgs>>): Prisma__CountryClient<$Result.GetResult<Prisma.$CountryPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
    awayTeam<T extends CountryDefaultArgs<ExtArgs> = {}>(args?: Subset<T, CountryDefaultArgs<ExtArgs>>): Prisma__CountryClient<$Result.GetResult<Prisma.$CountryPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
    round<T extends Match$roundArgs<ExtArgs> = {}>(args?: Subset<T, Match$roundArgs<ExtArgs>>): Prisma__RoundClient<$Result.GetResult<Prisma.$RoundPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
    playerStats<T extends Match$playerStatsArgs<ExtArgs> = {}>(args?: Subset<T, Match$playerStatsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$PlayerMatchStatPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    events<T extends Match$eventsArgs<ExtArgs> = {}>(args?: Subset<T, Match$eventsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$MatchEventPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    lineups<T extends Match$lineupsArgs<ExtArgs> = {}>(args?: Subset<T, Match$lineupsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$MatchLineupPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    /**
     * 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 Match model
   */
  interface MatchFieldRefs {
    readonly id: FieldRef<"Match", 'String'>
    readonly homeTeamId: FieldRef<"Match", 'String'>
    readonly awayTeamId: FieldRef<"Match", 'String'>
    readonly homeScore: FieldRef<"Match", 'Int'>
    readonly awayScore: FieldRef<"Match", 'Int'>
    readonly stage: FieldRef<"Match", 'MatchStage'>
    readonly status: FieldRef<"Match", 'MatchStatus'>
    readonly matchDate: FieldRef<"Match", 'DateTime'>
    readonly matchDatePersian: FieldRef<"Match", 'String'>
    readonly stadium: FieldRef<"Match", 'String'>
    readonly city: FieldRef<"Match", 'String'>
    readonly referee: FieldRef<"Match", 'String'>
    readonly assistant1: FieldRef<"Match", 'String'>
    readonly assistant2: FieldRef<"Match", 'String'>
    readonly fourthOfficial: FieldRef<"Match", 'String'>
    readonly attendance: FieldRef<"Match", 'Int'>
    readonly weather: FieldRef<"Match", 'String'>
    readonly description: FieldRef<"Match", 'String'>
    readonly roundId: FieldRef<"Match", 'String'>
    readonly createdAt: FieldRef<"Match", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * Match findUnique
   */
  export type MatchFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Match
     */
    select?: MatchSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Match
     */
    omit?: MatchOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MatchInclude<ExtArgs> | null
    /**
     * Filter, which Match to fetch.
     */
    where: MatchWhereUniqueInput
  }

  /**
   * Match findUniqueOrThrow
   */
  export type MatchFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Match
     */
    select?: MatchSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Match
     */
    omit?: MatchOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MatchInclude<ExtArgs> | null
    /**
     * Filter, which Match to fetch.
     */
    where: MatchWhereUniqueInput
  }

  /**
   * Match findFirst
   */
  export type MatchFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Match
     */
    select?: MatchSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Match
     */
    omit?: MatchOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MatchInclude<ExtArgs> | null
    /**
     * Filter, which Match to fetch.
     */
    where?: MatchWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Matches to fetch.
     */
    orderBy?: MatchOrderByWithRelationInput | MatchOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Matches.
     */
    cursor?: MatchWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Matches 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` Matches.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Matches.
     */
    distinct?: MatchScalarFieldEnum | MatchScalarFieldEnum[]
  }

  /**
   * Match findFirstOrThrow
   */
  export type MatchFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Match
     */
    select?: MatchSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Match
     */
    omit?: MatchOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MatchInclude<ExtArgs> | null
    /**
     * Filter, which Match to fetch.
     */
    where?: MatchWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Matches to fetch.
     */
    orderBy?: MatchOrderByWithRelationInput | MatchOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Matches.
     */
    cursor?: MatchWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Matches 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` Matches.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Matches.
     */
    distinct?: MatchScalarFieldEnum | MatchScalarFieldEnum[]
  }

  /**
   * Match findMany
   */
  export type MatchFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Match
     */
    select?: MatchSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Match
     */
    omit?: MatchOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MatchInclude<ExtArgs> | null
    /**
     * Filter, which Matches to fetch.
     */
    where?: MatchWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Matches to fetch.
     */
    orderBy?: MatchOrderByWithRelationInput | MatchOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing Matches.
     */
    cursor?: MatchWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Matches 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` Matches.
     */
    skip?: number
    distinct?: MatchScalarFieldEnum | MatchScalarFieldEnum[]
  }

  /**
   * Match create
   */
  export type MatchCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Match
     */
    select?: MatchSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Match
     */
    omit?: MatchOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MatchInclude<ExtArgs> | null
    /**
     * The data needed to create a Match.
     */
    data: XOR<MatchCreateInput, MatchUncheckedCreateInput>
  }

  /**
   * Match createMany
   */
  export type MatchCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many Matches.
     */
    data: MatchCreateManyInput | MatchCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * Match createManyAndReturn
   */
  export type MatchCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Match
     */
    select?: MatchSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the Match
     */
    omit?: MatchOmit<ExtArgs> | null
    /**
     * The data used to create many Matches.
     */
    data: MatchCreateManyInput | MatchCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MatchIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * Match update
   */
  export type MatchUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Match
     */
    select?: MatchSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Match
     */
    omit?: MatchOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MatchInclude<ExtArgs> | null
    /**
     * The data needed to update a Match.
     */
    data: XOR<MatchUpdateInput, MatchUncheckedUpdateInput>
    /**
     * Choose, which Match to update.
     */
    where: MatchWhereUniqueInput
  }

  /**
   * Match updateMany
   */
  export type MatchUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Matches.
     */
    data: XOR<MatchUpdateManyMutationInput, MatchUncheckedUpdateManyInput>
    /**
     * Filter which Matches to update
     */
    where?: MatchWhereInput
    /**
     * Limit how many Matches to update.
     */
    limit?: number
  }

  /**
   * Match updateManyAndReturn
   */
  export type MatchUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Match
     */
    select?: MatchSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the Match
     */
    omit?: MatchOmit<ExtArgs> | null
    /**
     * The data used to update Matches.
     */
    data: XOR<MatchUpdateManyMutationInput, MatchUncheckedUpdateManyInput>
    /**
     * Filter which Matches to update
     */
    where?: MatchWhereInput
    /**
     * Limit how many Matches to update.
     */
    limit?: number
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MatchIncludeUpdateManyAndReturn<ExtArgs> | null
  }

  /**
   * Match upsert
   */
  export type MatchUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Match
     */
    select?: MatchSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Match
     */
    omit?: MatchOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MatchInclude<ExtArgs> | null
    /**
     * The filter to search for the Match to update in case it exists.
     */
    where: MatchWhereUniqueInput
    /**
     * In case the Match found by the `where` argument doesn't exist, create a new Match with this data.
     */
    create: XOR<MatchCreateInput, MatchUncheckedCreateInput>
    /**
     * In case the Match was found with the provided `where` argument, update it with this data.
     */
    update: XOR<MatchUpdateInput, MatchUncheckedUpdateInput>
  }

  /**
   * Match delete
   */
  export type MatchDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Match
     */
    select?: MatchSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Match
     */
    omit?: MatchOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MatchInclude<ExtArgs> | null
    /**
     * Filter which Match to delete.
     */
    where: MatchWhereUniqueInput
  }

  /**
   * Match deleteMany
   */
  export type MatchDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Matches to delete
     */
    where?: MatchWhereInput
    /**
     * Limit how many Matches to delete.
     */
    limit?: number
  }

  /**
   * Match.round
   */
  export type Match$roundArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Round
     */
    select?: RoundSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Round
     */
    omit?: RoundOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: RoundInclude<ExtArgs> | null
    where?: RoundWhereInput
  }

  /**
   * Match.playerStats
   */
  export type Match$playerStatsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PlayerMatchStat
     */
    select?: PlayerMatchStatSelect<ExtArgs> | null
    /**
     * Omit specific fields from the PlayerMatchStat
     */
    omit?: PlayerMatchStatOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PlayerMatchStatInclude<ExtArgs> | null
    where?: PlayerMatchStatWhereInput
    orderBy?: PlayerMatchStatOrderByWithRelationInput | PlayerMatchStatOrderByWithRelationInput[]
    cursor?: PlayerMatchStatWhereUniqueInput
    take?: number
    skip?: number
    distinct?: PlayerMatchStatScalarFieldEnum | PlayerMatchStatScalarFieldEnum[]
  }

  /**
   * Match.events
   */
  export type Match$eventsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MatchEvent
     */
    select?: MatchEventSelect<ExtArgs> | null
    /**
     * Omit specific fields from the MatchEvent
     */
    omit?: MatchEventOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MatchEventInclude<ExtArgs> | null
    where?: MatchEventWhereInput
    orderBy?: MatchEventOrderByWithRelationInput | MatchEventOrderByWithRelationInput[]
    cursor?: MatchEventWhereUniqueInput
    take?: number
    skip?: number
    distinct?: MatchEventScalarFieldEnum | MatchEventScalarFieldEnum[]
  }

  /**
   * Match.lineups
   */
  export type Match$lineupsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MatchLineup
     */
    select?: MatchLineupSelect<ExtArgs> | null
    /**
     * Omit specific fields from the MatchLineup
     */
    omit?: MatchLineupOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MatchLineupInclude<ExtArgs> | null
    where?: MatchLineupWhereInput
    orderBy?: MatchLineupOrderByWithRelationInput | MatchLineupOrderByWithRelationInput[]
    cursor?: MatchLineupWhereUniqueInput
    take?: number
    skip?: number
    distinct?: MatchLineupScalarFieldEnum | MatchLineupScalarFieldEnum[]
  }

  /**
   * Match without action
   */
  export type MatchDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Match
     */
    select?: MatchSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Match
     */
    omit?: MatchOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MatchInclude<ExtArgs> | null
  }


  /**
   * Model Round
   */

  export type AggregateRound = {
    _count: RoundCountAggregateOutputType | null
    _avg: RoundAvgAggregateOutputType | null
    _sum: RoundSumAggregateOutputType | null
    _min: RoundMinAggregateOutputType | null
    _max: RoundMaxAggregateOutputType | null
  }

  export type RoundAvgAggregateOutputType = {
    number: number | null
  }

  export type RoundSumAggregateOutputType = {
    number: number | null
  }

  export type RoundMinAggregateOutputType = {
    id: string | null
    number: number | null
    name: string | null
    isActive: boolean | null
    deadline: Date | null
    createdAt: Date | null
  }

  export type RoundMaxAggregateOutputType = {
    id: string | null
    number: number | null
    name: string | null
    isActive: boolean | null
    deadline: Date | null
    createdAt: Date | null
  }

  export type RoundCountAggregateOutputType = {
    id: number
    number: number
    name: number
    isActive: number
    deadline: number
    createdAt: number
    _all: number
  }


  export type RoundAvgAggregateInputType = {
    number?: true
  }

  export type RoundSumAggregateInputType = {
    number?: true
  }

  export type RoundMinAggregateInputType = {
    id?: true
    number?: true
    name?: true
    isActive?: true
    deadline?: true
    createdAt?: true
  }

  export type RoundMaxAggregateInputType = {
    id?: true
    number?: true
    name?: true
    isActive?: true
    deadline?: true
    createdAt?: true
  }

  export type RoundCountAggregateInputType = {
    id?: true
    number?: true
    name?: true
    isActive?: true
    deadline?: true
    createdAt?: true
    _all?: true
  }

  export type RoundAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Round to aggregate.
     */
    where?: RoundWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Rounds to fetch.
     */
    orderBy?: RoundOrderByWithRelationInput | RoundOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: RoundWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Rounds 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` Rounds.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned Rounds
    **/
    _count?: true | RoundCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: RoundAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: RoundSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: RoundMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: RoundMaxAggregateInputType
  }

  export type GetRoundAggregateType<T extends RoundAggregateArgs> = {
        [P in keyof T & keyof AggregateRound]: P extends '_count' | 'count'
      ? T[P] extends true
        ? number
        : GetScalarType<T[P], AggregateRound[P]>
      : GetScalarType<T[P], AggregateRound[P]>
  }




  export type RoundGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: RoundWhereInput
    orderBy?: RoundOrderByWithAggregationInput | RoundOrderByWithAggregationInput[]
    by: RoundScalarFieldEnum[] | RoundScalarFieldEnum
    having?: RoundScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: RoundCountAggregateInputType | true
    _avg?: RoundAvgAggregateInputType
    _sum?: RoundSumAggregateInputType
    _min?: RoundMinAggregateInputType
    _max?: RoundMaxAggregateInputType
  }

  export type RoundGroupByOutputType = {
    id: string
    number: number
    name: string
    isActive: boolean
    deadline: Date
    createdAt: Date
    _count: RoundCountAggregateOutputType | null
    _avg: RoundAvgAggregateOutputType | null
    _sum: RoundSumAggregateOutputType | null
    _min: RoundMinAggregateOutputType | null
    _max: RoundMaxAggregateOutputType | null
  }

  type GetRoundGroupByPayload<T extends RoundGroupByArgs> = Prisma.PrismaPromise<
    Array<
      PickEnumerable<RoundGroupByOutputType, T['by']> &
        {
          [P in ((keyof T) & (keyof RoundGroupByOutputType))]: P extends '_count'
            ? T[P] extends boolean
              ? number
              : GetScalarType<T[P], RoundGroupByOutputType[P]>
            : GetScalarType<T[P], RoundGroupByOutputType[P]>
        }
      >
    >


  export type RoundSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    number?: boolean
    name?: boolean
    isActive?: boolean
    deadline?: boolean
    createdAt?: boolean
    matches?: boolean | Round$matchesArgs<ExtArgs>
    _count?: boolean | RoundCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["round"]>

  export type RoundSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    number?: boolean
    name?: boolean
    isActive?: boolean
    deadline?: boolean
    createdAt?: boolean
  }, ExtArgs["result"]["round"]>

  export type RoundSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    number?: boolean
    name?: boolean
    isActive?: boolean
    deadline?: boolean
    createdAt?: boolean
  }, ExtArgs["result"]["round"]>

  export type RoundSelectScalar = {
    id?: boolean
    number?: boolean
    name?: boolean
    isActive?: boolean
    deadline?: boolean
    createdAt?: boolean
  }

  export type RoundOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "number" | "name" | "isActive" | "deadline" | "createdAt", ExtArgs["result"]["round"]>
  export type RoundInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    matches?: boolean | Round$matchesArgs<ExtArgs>
    _count?: boolean | RoundCountOutputTypeDefaultArgs<ExtArgs>
  }
  export type RoundIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {}
  export type RoundIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {}

  export type $RoundPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Round"
    objects: {
      matches: Prisma.$MatchPayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      number: number
      name: string
      isActive: boolean
      deadline: Date
      createdAt: Date
    }, ExtArgs["result"]["round"]>
    composites: {}
  }

  type RoundGetPayload<S extends boolean | null | undefined | RoundDefaultArgs> = $Result.GetResult<Prisma.$RoundPayload, S>

  type RoundCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
    Omit<RoundFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
      select?: RoundCountAggregateInputType | true
    }

  export interface RoundDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> {
    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['Round'], meta: { name: 'Round' } }
    /**
     * Find zero or one Round that matches the filter.
     * @param {RoundFindUniqueArgs} args - Arguments to find a Round
     * @example
     * // Get one Round
     * const round = await prisma.round.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUnique<T extends RoundFindUniqueArgs>(args: SelectSubset<T, RoundFindUniqueArgs<ExtArgs>>): Prisma__RoundClient<$Result.GetResult<Prisma.$RoundPayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find one Round that matches the filter or throw an error with `error.code='P2025'`
     * if no matches were found.
     * @param {RoundFindUniqueOrThrowArgs} args - Arguments to find a Round
     * @example
     * // Get one Round
     * const round = await prisma.round.findUniqueOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUniqueOrThrow<T extends RoundFindUniqueOrThrowArgs>(args: SelectSubset<T, RoundFindUniqueOrThrowArgs<ExtArgs>>): Prisma__RoundClient<$Result.GetResult<Prisma.$RoundPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first Round 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 {RoundFindFirstArgs} args - Arguments to find a Round
     * @example
     * // Get one Round
     * const round = await prisma.round.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends RoundFindFirstArgs>(args?: SelectSubset<T, RoundFindFirstArgs<ExtArgs>>): Prisma__RoundClient<$Result.GetResult<Prisma.$RoundPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first Round 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 {RoundFindFirstOrThrowArgs} args - Arguments to find a Round
     * @example
     * // Get one Round
     * const round = await prisma.round.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends RoundFindFirstOrThrowArgs>(args?: SelectSubset<T, RoundFindFirstOrThrowArgs<ExtArgs>>): Prisma__RoundClient<$Result.GetResult<Prisma.$RoundPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find zero or more Rounds 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 {RoundFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all Rounds
     * const rounds = await prisma.round.findMany()
     * 
     * // Get first 10 Rounds
     * const rounds = await prisma.round.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const roundWithIdOnly = await prisma.round.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends RoundFindManyArgs>(args?: SelectSubset<T, RoundFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$RoundPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>

    /**
     * Create a Round.
     * @param {RoundCreateArgs} args - Arguments to create a Round.
     * @example
     * // Create one Round
     * const Round = await prisma.round.create({
     *   data: {
     *     // ... data to create a Round
     *   }
     * })
     * 
     */
    create<T extends RoundCreateArgs>(args: SelectSubset<T, RoundCreateArgs<ExtArgs>>): Prisma__RoundClient<$Result.GetResult<Prisma.$RoundPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Create many Rounds.
     * @param {RoundCreateManyArgs} args - Arguments to create many Rounds.
     * @example
     * // Create many Rounds
     * const round = await prisma.round.createMany({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     *     
     */
    createMany<T extends RoundCreateManyArgs>(args?: SelectSubset<T, RoundCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create many Rounds and returns the data saved in the database.
     * @param {RoundCreateManyAndReturnArgs} args - Arguments to create many Rounds.
     * @example
     * // Create many Rounds
     * const round = await prisma.round.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many Rounds and only return the `id`
     * const roundWithIdOnly = await prisma.round.createManyAndReturn({
     *   select: { id: true },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    createManyAndReturn<T extends RoundCreateManyAndReturnArgs>(args?: SelectSubset<T, RoundCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$RoundPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>

    /**
     * Delete a Round.
     * @param {RoundDeleteArgs} args - Arguments to delete one Round.
     * @example
     * // Delete one Round
     * const Round = await prisma.round.delete({
     *   where: {
     *     // ... filter to delete one Round
     *   }
     * })
     * 
     */
    delete<T extends RoundDeleteArgs>(args: SelectSubset<T, RoundDeleteArgs<ExtArgs>>): Prisma__RoundClient<$Result.GetResult<Prisma.$RoundPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Update one Round.
     * @param {RoundUpdateArgs} args - Arguments to update one Round.
     * @example
     * // Update one Round
     * const round = await prisma.round.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends RoundUpdateArgs>(args: SelectSubset<T, RoundUpdateArgs<ExtArgs>>): Prisma__RoundClient<$Result.GetResult<Prisma.$RoundPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Delete zero or more Rounds.
     * @param {RoundDeleteManyArgs} args - Arguments to filter Rounds to delete.
     * @example
     * // Delete a few Rounds
     * const { count } = await prisma.round.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
     */
    deleteMany<T extends RoundDeleteManyArgs>(args?: SelectSubset<T, RoundDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more Rounds.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {RoundUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many Rounds
     * const round = await prisma.round.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    updateMany<T extends RoundUpdateManyArgs>(args: SelectSubset<T, RoundUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more Rounds and returns the data updated in the database.
     * @param {RoundUpdateManyAndReturnArgs} args - Arguments to update many Rounds.
     * @example
     * // Update many Rounds
     * const round = await prisma.round.updateManyAndReturn({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Update zero or more Rounds and only return the `id`
     * const roundWithIdOnly = await prisma.round.updateManyAndReturn({
     *   select: { id: true },
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    updateManyAndReturn<T extends RoundUpdateManyAndReturnArgs>(args: SelectSubset<T, RoundUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$RoundPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>

    /**
     * Create or update one Round.
     * @param {RoundUpsertArgs} args - Arguments to update or create a Round.
     * @example
     * // Update or create a Round
     * const round = await prisma.round.upsert({
     *   create: {
     *     // ... data to create a Round
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the Round we want to update
     *   }
     * })
     */
    upsert<T extends RoundUpsertArgs>(args: SelectSubset<T, RoundUpsertArgs<ExtArgs>>): Prisma__RoundClient<$Result.GetResult<Prisma.$RoundPayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>


    /**
     * Count the number of Rounds.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {RoundCountArgs} args - Arguments to filter Rounds to count.
     * @example
     * // Count the number of Rounds
     * const count = await prisma.round.count({
     *   where: {
     *     // ... the filter for the Rounds we want to count
     *   }
     * })
    **/
    count<T extends RoundCountArgs>(
      args?: Subset<T, RoundCountArgs>,
    ): Prisma.PrismaPromise<
      T extends $Utils.Record<'select', any>
        ? T['select'] extends true
          ? number
          : GetScalarType<T['select'], RoundCountAggregateOutputType>
        : number
    >

    /**
     * Allows you to perform aggregations operations on a Round.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {RoundAggregateArgs} 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 RoundAggregateArgs>(args: Subset<T, RoundAggregateArgs>): Prisma.PrismaPromise<GetRoundAggregateType<T>>

    /**
     * Group by Round.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {RoundGroupByArgs} 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 RoundGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: RoundGroupByArgs['orderBy'] }
        : { orderBy?: RoundGroupByArgs['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, RoundGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetRoundGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the Round model
   */
  readonly fields: RoundFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for Round.
   * 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__RoundClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    matches<T extends Round$matchesArgs<ExtArgs> = {}>(args?: Subset<T, Round$matchesArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$MatchPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    /**
     * 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 Round model
   */
  interface RoundFieldRefs {
    readonly id: FieldRef<"Round", 'String'>
    readonly number: FieldRef<"Round", 'Int'>
    readonly name: FieldRef<"Round", 'String'>
    readonly isActive: FieldRef<"Round", 'Boolean'>
    readonly deadline: FieldRef<"Round", 'DateTime'>
    readonly createdAt: FieldRef<"Round", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * Round findUnique
   */
  export type RoundFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Round
     */
    select?: RoundSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Round
     */
    omit?: RoundOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: RoundInclude<ExtArgs> | null
    /**
     * Filter, which Round to fetch.
     */
    where: RoundWhereUniqueInput
  }

  /**
   * Round findUniqueOrThrow
   */
  export type RoundFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Round
     */
    select?: RoundSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Round
     */
    omit?: RoundOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: RoundInclude<ExtArgs> | null
    /**
     * Filter, which Round to fetch.
     */
    where: RoundWhereUniqueInput
  }

  /**
   * Round findFirst
   */
  export type RoundFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Round
     */
    select?: RoundSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Round
     */
    omit?: RoundOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: RoundInclude<ExtArgs> | null
    /**
     * Filter, which Round to fetch.
     */
    where?: RoundWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Rounds to fetch.
     */
    orderBy?: RoundOrderByWithRelationInput | RoundOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Rounds.
     */
    cursor?: RoundWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Rounds 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` Rounds.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Rounds.
     */
    distinct?: RoundScalarFieldEnum | RoundScalarFieldEnum[]
  }

  /**
   * Round findFirstOrThrow
   */
  export type RoundFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Round
     */
    select?: RoundSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Round
     */
    omit?: RoundOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: RoundInclude<ExtArgs> | null
    /**
     * Filter, which Round to fetch.
     */
    where?: RoundWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Rounds to fetch.
     */
    orderBy?: RoundOrderByWithRelationInput | RoundOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Rounds.
     */
    cursor?: RoundWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Rounds 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` Rounds.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Rounds.
     */
    distinct?: RoundScalarFieldEnum | RoundScalarFieldEnum[]
  }

  /**
   * Round findMany
   */
  export type RoundFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Round
     */
    select?: RoundSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Round
     */
    omit?: RoundOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: RoundInclude<ExtArgs> | null
    /**
     * Filter, which Rounds to fetch.
     */
    where?: RoundWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Rounds to fetch.
     */
    orderBy?: RoundOrderByWithRelationInput | RoundOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing Rounds.
     */
    cursor?: RoundWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Rounds 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` Rounds.
     */
    skip?: number
    distinct?: RoundScalarFieldEnum | RoundScalarFieldEnum[]
  }

  /**
   * Round create
   */
  export type RoundCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Round
     */
    select?: RoundSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Round
     */
    omit?: RoundOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: RoundInclude<ExtArgs> | null
    /**
     * The data needed to create a Round.
     */
    data: XOR<RoundCreateInput, RoundUncheckedCreateInput>
  }

  /**
   * Round createMany
   */
  export type RoundCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many Rounds.
     */
    data: RoundCreateManyInput | RoundCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * Round createManyAndReturn
   */
  export type RoundCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Round
     */
    select?: RoundSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the Round
     */
    omit?: RoundOmit<ExtArgs> | null
    /**
     * The data used to create many Rounds.
     */
    data: RoundCreateManyInput | RoundCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * Round update
   */
  export type RoundUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Round
     */
    select?: RoundSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Round
     */
    omit?: RoundOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: RoundInclude<ExtArgs> | null
    /**
     * The data needed to update a Round.
     */
    data: XOR<RoundUpdateInput, RoundUncheckedUpdateInput>
    /**
     * Choose, which Round to update.
     */
    where: RoundWhereUniqueInput
  }

  /**
   * Round updateMany
   */
  export type RoundUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Rounds.
     */
    data: XOR<RoundUpdateManyMutationInput, RoundUncheckedUpdateManyInput>
    /**
     * Filter which Rounds to update
     */
    where?: RoundWhereInput
    /**
     * Limit how many Rounds to update.
     */
    limit?: number
  }

  /**
   * Round updateManyAndReturn
   */
  export type RoundUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Round
     */
    select?: RoundSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the Round
     */
    omit?: RoundOmit<ExtArgs> | null
    /**
     * The data used to update Rounds.
     */
    data: XOR<RoundUpdateManyMutationInput, RoundUncheckedUpdateManyInput>
    /**
     * Filter which Rounds to update
     */
    where?: RoundWhereInput
    /**
     * Limit how many Rounds to update.
     */
    limit?: number
  }

  /**
   * Round upsert
   */
  export type RoundUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Round
     */
    select?: RoundSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Round
     */
    omit?: RoundOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: RoundInclude<ExtArgs> | null
    /**
     * The filter to search for the Round to update in case it exists.
     */
    where: RoundWhereUniqueInput
    /**
     * In case the Round found by the `where` argument doesn't exist, create a new Round with this data.
     */
    create: XOR<RoundCreateInput, RoundUncheckedCreateInput>
    /**
     * In case the Round was found with the provided `where` argument, update it with this data.
     */
    update: XOR<RoundUpdateInput, RoundUncheckedUpdateInput>
  }

  /**
   * Round delete
   */
  export type RoundDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Round
     */
    select?: RoundSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Round
     */
    omit?: RoundOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: RoundInclude<ExtArgs> | null
    /**
     * Filter which Round to delete.
     */
    where: RoundWhereUniqueInput
  }

  /**
   * Round deleteMany
   */
  export type RoundDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Rounds to delete
     */
    where?: RoundWhereInput
    /**
     * Limit how many Rounds to delete.
     */
    limit?: number
  }

  /**
   * Round.matches
   */
  export type Round$matchesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Match
     */
    select?: MatchSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Match
     */
    omit?: MatchOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MatchInclude<ExtArgs> | null
    where?: MatchWhereInput
    orderBy?: MatchOrderByWithRelationInput | MatchOrderByWithRelationInput[]
    cursor?: MatchWhereUniqueInput
    take?: number
    skip?: number
    distinct?: MatchScalarFieldEnum | MatchScalarFieldEnum[]
  }

  /**
   * Round without action
   */
  export type RoundDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Round
     */
    select?: RoundSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Round
     */
    omit?: RoundOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: RoundInclude<ExtArgs> | null
  }


  /**
   * Model Gameweek
   */

  export type AggregateGameweek = {
    _count: GameweekCountAggregateOutputType | null
    _avg: GameweekAvgAggregateOutputType | null
    _sum: GameweekSumAggregateOutputType | null
    _min: GameweekMinAggregateOutputType | null
    _max: GameweekMaxAggregateOutputType | null
  }

  export type GameweekAvgAggregateOutputType = {
    number: number | null
  }

  export type GameweekSumAggregateOutputType = {
    number: number | null
  }

  export type GameweekMinAggregateOutputType = {
    id: string | null
    number: number | null
    name: string | null
    isActive: boolean | null
    deadline: Date | null
    createdAt: Date | null
  }

  export type GameweekMaxAggregateOutputType = {
    id: string | null
    number: number | null
    name: string | null
    isActive: boolean | null
    deadline: Date | null
    createdAt: Date | null
  }

  export type GameweekCountAggregateOutputType = {
    id: number
    number: number
    name: number
    isActive: number
    deadline: number
    createdAt: number
    _all: number
  }


  export type GameweekAvgAggregateInputType = {
    number?: true
  }

  export type GameweekSumAggregateInputType = {
    number?: true
  }

  export type GameweekMinAggregateInputType = {
    id?: true
    number?: true
    name?: true
    isActive?: true
    deadline?: true
    createdAt?: true
  }

  export type GameweekMaxAggregateInputType = {
    id?: true
    number?: true
    name?: true
    isActive?: true
    deadline?: true
    createdAt?: true
  }

  export type GameweekCountAggregateInputType = {
    id?: true
    number?: true
    name?: true
    isActive?: true
    deadline?: true
    createdAt?: true
    _all?: true
  }

  export type GameweekAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Gameweek to aggregate.
     */
    where?: GameweekWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Gameweeks to fetch.
     */
    orderBy?: GameweekOrderByWithRelationInput | GameweekOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: GameweekWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Gameweeks 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` Gameweeks.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned Gameweeks
    **/
    _count?: true | GameweekCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: GameweekAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: GameweekSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: GameweekMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: GameweekMaxAggregateInputType
  }

  export type GetGameweekAggregateType<T extends GameweekAggregateArgs> = {
        [P in keyof T & keyof AggregateGameweek]: P extends '_count' | 'count'
      ? T[P] extends true
        ? number
        : GetScalarType<T[P], AggregateGameweek[P]>
      : GetScalarType<T[P], AggregateGameweek[P]>
  }




  export type GameweekGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: GameweekWhereInput
    orderBy?: GameweekOrderByWithAggregationInput | GameweekOrderByWithAggregationInput[]
    by: GameweekScalarFieldEnum[] | GameweekScalarFieldEnum
    having?: GameweekScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: GameweekCountAggregateInputType | true
    _avg?: GameweekAvgAggregateInputType
    _sum?: GameweekSumAggregateInputType
    _min?: GameweekMinAggregateInputType
    _max?: GameweekMaxAggregateInputType
  }

  export type GameweekGroupByOutputType = {
    id: string
    number: number
    name: string
    isActive: boolean
    deadline: Date
    createdAt: Date
    _count: GameweekCountAggregateOutputType | null
    _avg: GameweekAvgAggregateOutputType | null
    _sum: GameweekSumAggregateOutputType | null
    _min: GameweekMinAggregateOutputType | null
    _max: GameweekMaxAggregateOutputType | null
  }

  type GetGameweekGroupByPayload<T extends GameweekGroupByArgs> = Prisma.PrismaPromise<
    Array<
      PickEnumerable<GameweekGroupByOutputType, T['by']> &
        {
          [P in ((keyof T) & (keyof GameweekGroupByOutputType))]: P extends '_count'
            ? T[P] extends boolean
              ? number
              : GetScalarType<T[P], GameweekGroupByOutputType[P]>
            : GetScalarType<T[P], GameweekGroupByOutputType[P]>
        }
      >
    >


  export type GameweekSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    number?: boolean
    name?: boolean
    isActive?: boolean
    deadline?: boolean
    createdAt?: boolean
  }, ExtArgs["result"]["gameweek"]>

  export type GameweekSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    number?: boolean
    name?: boolean
    isActive?: boolean
    deadline?: boolean
    createdAt?: boolean
  }, ExtArgs["result"]["gameweek"]>

  export type GameweekSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    number?: boolean
    name?: boolean
    isActive?: boolean
    deadline?: boolean
    createdAt?: boolean
  }, ExtArgs["result"]["gameweek"]>

  export type GameweekSelectScalar = {
    id?: boolean
    number?: boolean
    name?: boolean
    isActive?: boolean
    deadline?: boolean
    createdAt?: boolean
  }

  export type GameweekOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "number" | "name" | "isActive" | "deadline" | "createdAt", ExtArgs["result"]["gameweek"]>

  export type $GameweekPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Gameweek"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: string
      number: number
      name: string
      isActive: boolean
      deadline: Date
      createdAt: Date
    }, ExtArgs["result"]["gameweek"]>
    composites: {}
  }

  type GameweekGetPayload<S extends boolean | null | undefined | GameweekDefaultArgs> = $Result.GetResult<Prisma.$GameweekPayload, S>

  type GameweekCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
    Omit<GameweekFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
      select?: GameweekCountAggregateInputType | true
    }

  export interface GameweekDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> {
    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['Gameweek'], meta: { name: 'Gameweek' } }
    /**
     * Find zero or one Gameweek that matches the filter.
     * @param {GameweekFindUniqueArgs} args - Arguments to find a Gameweek
     * @example
     * // Get one Gameweek
     * const gameweek = await prisma.gameweek.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUnique<T extends GameweekFindUniqueArgs>(args: SelectSubset<T, GameweekFindUniqueArgs<ExtArgs>>): Prisma__GameweekClient<$Result.GetResult<Prisma.$GameweekPayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find one Gameweek that matches the filter or throw an error with `error.code='P2025'`
     * if no matches were found.
     * @param {GameweekFindUniqueOrThrowArgs} args - Arguments to find a Gameweek
     * @example
     * // Get one Gameweek
     * const gameweek = await prisma.gameweek.findUniqueOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUniqueOrThrow<T extends GameweekFindUniqueOrThrowArgs>(args: SelectSubset<T, GameweekFindUniqueOrThrowArgs<ExtArgs>>): Prisma__GameweekClient<$Result.GetResult<Prisma.$GameweekPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first Gameweek 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 {GameweekFindFirstArgs} args - Arguments to find a Gameweek
     * @example
     * // Get one Gameweek
     * const gameweek = await prisma.gameweek.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends GameweekFindFirstArgs>(args?: SelectSubset<T, GameweekFindFirstArgs<ExtArgs>>): Prisma__GameweekClient<$Result.GetResult<Prisma.$GameweekPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first Gameweek 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 {GameweekFindFirstOrThrowArgs} args - Arguments to find a Gameweek
     * @example
     * // Get one Gameweek
     * const gameweek = await prisma.gameweek.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends GameweekFindFirstOrThrowArgs>(args?: SelectSubset<T, GameweekFindFirstOrThrowArgs<ExtArgs>>): Prisma__GameweekClient<$Result.GetResult<Prisma.$GameweekPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find zero or more Gameweeks 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 {GameweekFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all Gameweeks
     * const gameweeks = await prisma.gameweek.findMany()
     * 
     * // Get first 10 Gameweeks
     * const gameweeks = await prisma.gameweek.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const gameweekWithIdOnly = await prisma.gameweek.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends GameweekFindManyArgs>(args?: SelectSubset<T, GameweekFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$GameweekPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>

    /**
     * Create a Gameweek.
     * @param {GameweekCreateArgs} args - Arguments to create a Gameweek.
     * @example
     * // Create one Gameweek
     * const Gameweek = await prisma.gameweek.create({
     *   data: {
     *     // ... data to create a Gameweek
     *   }
     * })
     * 
     */
    create<T extends GameweekCreateArgs>(args: SelectSubset<T, GameweekCreateArgs<ExtArgs>>): Prisma__GameweekClient<$Result.GetResult<Prisma.$GameweekPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Create many Gameweeks.
     * @param {GameweekCreateManyArgs} args - Arguments to create many Gameweeks.
     * @example
     * // Create many Gameweeks
     * const gameweek = await prisma.gameweek.createMany({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     *     
     */
    createMany<T extends GameweekCreateManyArgs>(args?: SelectSubset<T, GameweekCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create many Gameweeks and returns the data saved in the database.
     * @param {GameweekCreateManyAndReturnArgs} args - Arguments to create many Gameweeks.
     * @example
     * // Create many Gameweeks
     * const gameweek = await prisma.gameweek.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many Gameweeks and only return the `id`
     * const gameweekWithIdOnly = await prisma.gameweek.createManyAndReturn({
     *   select: { id: true },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    createManyAndReturn<T extends GameweekCreateManyAndReturnArgs>(args?: SelectSubset<T, GameweekCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$GameweekPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>

    /**
     * Delete a Gameweek.
     * @param {GameweekDeleteArgs} args - Arguments to delete one Gameweek.
     * @example
     * // Delete one Gameweek
     * const Gameweek = await prisma.gameweek.delete({
     *   where: {
     *     // ... filter to delete one Gameweek
     *   }
     * })
     * 
     */
    delete<T extends GameweekDeleteArgs>(args: SelectSubset<T, GameweekDeleteArgs<ExtArgs>>): Prisma__GameweekClient<$Result.GetResult<Prisma.$GameweekPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Update one Gameweek.
     * @param {GameweekUpdateArgs} args - Arguments to update one Gameweek.
     * @example
     * // Update one Gameweek
     * const gameweek = await prisma.gameweek.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends GameweekUpdateArgs>(args: SelectSubset<T, GameweekUpdateArgs<ExtArgs>>): Prisma__GameweekClient<$Result.GetResult<Prisma.$GameweekPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Delete zero or more Gameweeks.
     * @param {GameweekDeleteManyArgs} args - Arguments to filter Gameweeks to delete.
     * @example
     * // Delete a few Gameweeks
     * const { count } = await prisma.gameweek.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
     */
    deleteMany<T extends GameweekDeleteManyArgs>(args?: SelectSubset<T, GameweekDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more Gameweeks.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {GameweekUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many Gameweeks
     * const gameweek = await prisma.gameweek.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    updateMany<T extends GameweekUpdateManyArgs>(args: SelectSubset<T, GameweekUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more Gameweeks and returns the data updated in the database.
     * @param {GameweekUpdateManyAndReturnArgs} args - Arguments to update many Gameweeks.
     * @example
     * // Update many Gameweeks
     * const gameweek = await prisma.gameweek.updateManyAndReturn({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Update zero or more Gameweeks and only return the `id`
     * const gameweekWithIdOnly = await prisma.gameweek.updateManyAndReturn({
     *   select: { id: true },
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    updateManyAndReturn<T extends GameweekUpdateManyAndReturnArgs>(args: SelectSubset<T, GameweekUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$GameweekPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>

    /**
     * Create or update one Gameweek.
     * @param {GameweekUpsertArgs} args - Arguments to update or create a Gameweek.
     * @example
     * // Update or create a Gameweek
     * const gameweek = await prisma.gameweek.upsert({
     *   create: {
     *     // ... data to create a Gameweek
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the Gameweek we want to update
     *   }
     * })
     */
    upsert<T extends GameweekUpsertArgs>(args: SelectSubset<T, GameweekUpsertArgs<ExtArgs>>): Prisma__GameweekClient<$Result.GetResult<Prisma.$GameweekPayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>


    /**
     * Count the number of Gameweeks.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {GameweekCountArgs} args - Arguments to filter Gameweeks to count.
     * @example
     * // Count the number of Gameweeks
     * const count = await prisma.gameweek.count({
     *   where: {
     *     // ... the filter for the Gameweeks we want to count
     *   }
     * })
    **/
    count<T extends GameweekCountArgs>(
      args?: Subset<T, GameweekCountArgs>,
    ): Prisma.PrismaPromise<
      T extends $Utils.Record<'select', any>
        ? T['select'] extends true
          ? number
          : GetScalarType<T['select'], GameweekCountAggregateOutputType>
        : number
    >

    /**
     * Allows you to perform aggregations operations on a Gameweek.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {GameweekAggregateArgs} 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 GameweekAggregateArgs>(args: Subset<T, GameweekAggregateArgs>): Prisma.PrismaPromise<GetGameweekAggregateType<T>>

    /**
     * Group by Gameweek.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {GameweekGroupByArgs} 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 GameweekGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: GameweekGroupByArgs['orderBy'] }
        : { orderBy?: GameweekGroupByArgs['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, GameweekGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetGameweekGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the Gameweek model
   */
  readonly fields: GameweekFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for Gameweek.
   * 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__GameweekClient<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 Gameweek model
   */
  interface GameweekFieldRefs {
    readonly id: FieldRef<"Gameweek", 'String'>
    readonly number: FieldRef<"Gameweek", 'Int'>
    readonly name: FieldRef<"Gameweek", 'String'>
    readonly isActive: FieldRef<"Gameweek", 'Boolean'>
    readonly deadline: FieldRef<"Gameweek", 'DateTime'>
    readonly createdAt: FieldRef<"Gameweek", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * Gameweek findUnique
   */
  export type GameweekFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Gameweek
     */
    select?: GameweekSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Gameweek
     */
    omit?: GameweekOmit<ExtArgs> | null
    /**
     * Filter, which Gameweek to fetch.
     */
    where: GameweekWhereUniqueInput
  }

  /**
   * Gameweek findUniqueOrThrow
   */
  export type GameweekFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Gameweek
     */
    select?: GameweekSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Gameweek
     */
    omit?: GameweekOmit<ExtArgs> | null
    /**
     * Filter, which Gameweek to fetch.
     */
    where: GameweekWhereUniqueInput
  }

  /**
   * Gameweek findFirst
   */
  export type GameweekFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Gameweek
     */
    select?: GameweekSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Gameweek
     */
    omit?: GameweekOmit<ExtArgs> | null
    /**
     * Filter, which Gameweek to fetch.
     */
    where?: GameweekWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Gameweeks to fetch.
     */
    orderBy?: GameweekOrderByWithRelationInput | GameweekOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Gameweeks.
     */
    cursor?: GameweekWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Gameweeks 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` Gameweeks.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Gameweeks.
     */
    distinct?: GameweekScalarFieldEnum | GameweekScalarFieldEnum[]
  }

  /**
   * Gameweek findFirstOrThrow
   */
  export type GameweekFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Gameweek
     */
    select?: GameweekSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Gameweek
     */
    omit?: GameweekOmit<ExtArgs> | null
    /**
     * Filter, which Gameweek to fetch.
     */
    where?: GameweekWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Gameweeks to fetch.
     */
    orderBy?: GameweekOrderByWithRelationInput | GameweekOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Gameweeks.
     */
    cursor?: GameweekWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Gameweeks 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` Gameweeks.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Gameweeks.
     */
    distinct?: GameweekScalarFieldEnum | GameweekScalarFieldEnum[]
  }

  /**
   * Gameweek findMany
   */
  export type GameweekFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Gameweek
     */
    select?: GameweekSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Gameweek
     */
    omit?: GameweekOmit<ExtArgs> | null
    /**
     * Filter, which Gameweeks to fetch.
     */
    where?: GameweekWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Gameweeks to fetch.
     */
    orderBy?: GameweekOrderByWithRelationInput | GameweekOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing Gameweeks.
     */
    cursor?: GameweekWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Gameweeks 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` Gameweeks.
     */
    skip?: number
    distinct?: GameweekScalarFieldEnum | GameweekScalarFieldEnum[]
  }

  /**
   * Gameweek create
   */
  export type GameweekCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Gameweek
     */
    select?: GameweekSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Gameweek
     */
    omit?: GameweekOmit<ExtArgs> | null
    /**
     * The data needed to create a Gameweek.
     */
    data: XOR<GameweekCreateInput, GameweekUncheckedCreateInput>
  }

  /**
   * Gameweek createMany
   */
  export type GameweekCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many Gameweeks.
     */
    data: GameweekCreateManyInput | GameweekCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * Gameweek createManyAndReturn
   */
  export type GameweekCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Gameweek
     */
    select?: GameweekSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the Gameweek
     */
    omit?: GameweekOmit<ExtArgs> | null
    /**
     * The data used to create many Gameweeks.
     */
    data: GameweekCreateManyInput | GameweekCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * Gameweek update
   */
  export type GameweekUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Gameweek
     */
    select?: GameweekSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Gameweek
     */
    omit?: GameweekOmit<ExtArgs> | null
    /**
     * The data needed to update a Gameweek.
     */
    data: XOR<GameweekUpdateInput, GameweekUncheckedUpdateInput>
    /**
     * Choose, which Gameweek to update.
     */
    where: GameweekWhereUniqueInput
  }

  /**
   * Gameweek updateMany
   */
  export type GameweekUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Gameweeks.
     */
    data: XOR<GameweekUpdateManyMutationInput, GameweekUncheckedUpdateManyInput>
    /**
     * Filter which Gameweeks to update
     */
    where?: GameweekWhereInput
    /**
     * Limit how many Gameweeks to update.
     */
    limit?: number
  }

  /**
   * Gameweek updateManyAndReturn
   */
  export type GameweekUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Gameweek
     */
    select?: GameweekSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the Gameweek
     */
    omit?: GameweekOmit<ExtArgs> | null
    /**
     * The data used to update Gameweeks.
     */
    data: XOR<GameweekUpdateManyMutationInput, GameweekUncheckedUpdateManyInput>
    /**
     * Filter which Gameweeks to update
     */
    where?: GameweekWhereInput
    /**
     * Limit how many Gameweeks to update.
     */
    limit?: number
  }

  /**
   * Gameweek upsert
   */
  export type GameweekUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Gameweek
     */
    select?: GameweekSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Gameweek
     */
    omit?: GameweekOmit<ExtArgs> | null
    /**
     * The filter to search for the Gameweek to update in case it exists.
     */
    where: GameweekWhereUniqueInput
    /**
     * In case the Gameweek found by the `where` argument doesn't exist, create a new Gameweek with this data.
     */
    create: XOR<GameweekCreateInput, GameweekUncheckedCreateInput>
    /**
     * In case the Gameweek was found with the provided `where` argument, update it with this data.
     */
    update: XOR<GameweekUpdateInput, GameweekUncheckedUpdateInput>
  }

  /**
   * Gameweek delete
   */
  export type GameweekDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Gameweek
     */
    select?: GameweekSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Gameweek
     */
    omit?: GameweekOmit<ExtArgs> | null
    /**
     * Filter which Gameweek to delete.
     */
    where: GameweekWhereUniqueInput
  }

  /**
   * Gameweek deleteMany
   */
  export type GameweekDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Gameweeks to delete
     */
    where?: GameweekWhereInput
    /**
     * Limit how many Gameweeks to delete.
     */
    limit?: number
  }

  /**
   * Gameweek without action
   */
  export type GameweekDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Gameweek
     */
    select?: GameweekSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Gameweek
     */
    omit?: GameweekOmit<ExtArgs> | null
  }


  /**
   * Model MatchEvent
   */

  export type AggregateMatchEvent = {
    _count: MatchEventCountAggregateOutputType | null
    _avg: MatchEventAvgAggregateOutputType | null
    _sum: MatchEventSumAggregateOutputType | null
    _min: MatchEventMinAggregateOutputType | null
    _max: MatchEventMaxAggregateOutputType | null
  }

  export type MatchEventAvgAggregateOutputType = {
    minute: number | null
  }

  export type MatchEventSumAggregateOutputType = {
    minute: number | null
  }

  export type MatchEventMinAggregateOutputType = {
    id: string | null
    matchId: string | null
    playerId: string | null
    type: $Enums.EventType | null
    minute: number | null
    extraInfo: string | null
    createdAt: Date | null
  }

  export type MatchEventMaxAggregateOutputType = {
    id: string | null
    matchId: string | null
    playerId: string | null
    type: $Enums.EventType | null
    minute: number | null
    extraInfo: string | null
    createdAt: Date | null
  }

  export type MatchEventCountAggregateOutputType = {
    id: number
    matchId: number
    playerId: number
    type: number
    minute: number
    extraInfo: number
    createdAt: number
    _all: number
  }


  export type MatchEventAvgAggregateInputType = {
    minute?: true
  }

  export type MatchEventSumAggregateInputType = {
    minute?: true
  }

  export type MatchEventMinAggregateInputType = {
    id?: true
    matchId?: true
    playerId?: true
    type?: true
    minute?: true
    extraInfo?: true
    createdAt?: true
  }

  export type MatchEventMaxAggregateInputType = {
    id?: true
    matchId?: true
    playerId?: true
    type?: true
    minute?: true
    extraInfo?: true
    createdAt?: true
  }

  export type MatchEventCountAggregateInputType = {
    id?: true
    matchId?: true
    playerId?: true
    type?: true
    minute?: true
    extraInfo?: true
    createdAt?: true
    _all?: true
  }

  export type MatchEventAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which MatchEvent to aggregate.
     */
    where?: MatchEventWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of MatchEvents to fetch.
     */
    orderBy?: MatchEventOrderByWithRelationInput | MatchEventOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: MatchEventWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` MatchEvents 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` MatchEvents.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned MatchEvents
    **/
    _count?: true | MatchEventCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: MatchEventAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: MatchEventSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: MatchEventMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: MatchEventMaxAggregateInputType
  }

  export type GetMatchEventAggregateType<T extends MatchEventAggregateArgs> = {
        [P in keyof T & keyof AggregateMatchEvent]: P extends '_count' | 'count'
      ? T[P] extends true
        ? number
        : GetScalarType<T[P], AggregateMatchEvent[P]>
      : GetScalarType<T[P], AggregateMatchEvent[P]>
  }




  export type MatchEventGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: MatchEventWhereInput
    orderBy?: MatchEventOrderByWithAggregationInput | MatchEventOrderByWithAggregationInput[]
    by: MatchEventScalarFieldEnum[] | MatchEventScalarFieldEnum
    having?: MatchEventScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: MatchEventCountAggregateInputType | true
    _avg?: MatchEventAvgAggregateInputType
    _sum?: MatchEventSumAggregateInputType
    _min?: MatchEventMinAggregateInputType
    _max?: MatchEventMaxAggregateInputType
  }

  export type MatchEventGroupByOutputType = {
    id: string
    matchId: string
    playerId: string
    type: $Enums.EventType
    minute: number | null
    extraInfo: string | null
    createdAt: Date
    _count: MatchEventCountAggregateOutputType | null
    _avg: MatchEventAvgAggregateOutputType | null
    _sum: MatchEventSumAggregateOutputType | null
    _min: MatchEventMinAggregateOutputType | null
    _max: MatchEventMaxAggregateOutputType | null
  }

  type GetMatchEventGroupByPayload<T extends MatchEventGroupByArgs> = Prisma.PrismaPromise<
    Array<
      PickEnumerable<MatchEventGroupByOutputType, T['by']> &
        {
          [P in ((keyof T) & (keyof MatchEventGroupByOutputType))]: P extends '_count'
            ? T[P] extends boolean
              ? number
              : GetScalarType<T[P], MatchEventGroupByOutputType[P]>
            : GetScalarType<T[P], MatchEventGroupByOutputType[P]>
        }
      >
    >


  export type MatchEventSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    matchId?: boolean
    playerId?: boolean
    type?: boolean
    minute?: boolean
    extraInfo?: boolean
    createdAt?: boolean
    match?: boolean | MatchDefaultArgs<ExtArgs>
    player?: boolean | PlayerDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["matchEvent"]>

  export type MatchEventSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    matchId?: boolean
    playerId?: boolean
    type?: boolean
    minute?: boolean
    extraInfo?: boolean
    createdAt?: boolean
    match?: boolean | MatchDefaultArgs<ExtArgs>
    player?: boolean | PlayerDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["matchEvent"]>

  export type MatchEventSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    matchId?: boolean
    playerId?: boolean
    type?: boolean
    minute?: boolean
    extraInfo?: boolean
    createdAt?: boolean
    match?: boolean | MatchDefaultArgs<ExtArgs>
    player?: boolean | PlayerDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["matchEvent"]>

  export type MatchEventSelectScalar = {
    id?: boolean
    matchId?: boolean
    playerId?: boolean
    type?: boolean
    minute?: boolean
    extraInfo?: boolean
    createdAt?: boolean
  }

  export type MatchEventOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "matchId" | "playerId" | "type" | "minute" | "extraInfo" | "createdAt", ExtArgs["result"]["matchEvent"]>
  export type MatchEventInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    match?: boolean | MatchDefaultArgs<ExtArgs>
    player?: boolean | PlayerDefaultArgs<ExtArgs>
  }
  export type MatchEventIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    match?: boolean | MatchDefaultArgs<ExtArgs>
    player?: boolean | PlayerDefaultArgs<ExtArgs>
  }
  export type MatchEventIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    match?: boolean | MatchDefaultArgs<ExtArgs>
    player?: boolean | PlayerDefaultArgs<ExtArgs>
  }

  export type $MatchEventPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "MatchEvent"
    objects: {
      match: Prisma.$MatchPayload<ExtArgs>
      player: Prisma.$PlayerPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      matchId: string
      playerId: string
      type: $Enums.EventType
      minute: number | null
      extraInfo: string | null
      createdAt: Date
    }, ExtArgs["result"]["matchEvent"]>
    composites: {}
  }

  type MatchEventGetPayload<S extends boolean | null | undefined | MatchEventDefaultArgs> = $Result.GetResult<Prisma.$MatchEventPayload, S>

  type MatchEventCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
    Omit<MatchEventFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
      select?: MatchEventCountAggregateInputType | true
    }

  export interface MatchEventDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> {
    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['MatchEvent'], meta: { name: 'MatchEvent' } }
    /**
     * Find zero or one MatchEvent that matches the filter.
     * @param {MatchEventFindUniqueArgs} args - Arguments to find a MatchEvent
     * @example
     * // Get one MatchEvent
     * const matchEvent = await prisma.matchEvent.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUnique<T extends MatchEventFindUniqueArgs>(args: SelectSubset<T, MatchEventFindUniqueArgs<ExtArgs>>): Prisma__MatchEventClient<$Result.GetResult<Prisma.$MatchEventPayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find one MatchEvent that matches the filter or throw an error with `error.code='P2025'`
     * if no matches were found.
     * @param {MatchEventFindUniqueOrThrowArgs} args - Arguments to find a MatchEvent
     * @example
     * // Get one MatchEvent
     * const matchEvent = await prisma.matchEvent.findUniqueOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUniqueOrThrow<T extends MatchEventFindUniqueOrThrowArgs>(args: SelectSubset<T, MatchEventFindUniqueOrThrowArgs<ExtArgs>>): Prisma__MatchEventClient<$Result.GetResult<Prisma.$MatchEventPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first MatchEvent 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 {MatchEventFindFirstArgs} args - Arguments to find a MatchEvent
     * @example
     * // Get one MatchEvent
     * const matchEvent = await prisma.matchEvent.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends MatchEventFindFirstArgs>(args?: SelectSubset<T, MatchEventFindFirstArgs<ExtArgs>>): Prisma__MatchEventClient<$Result.GetResult<Prisma.$MatchEventPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first MatchEvent 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 {MatchEventFindFirstOrThrowArgs} args - Arguments to find a MatchEvent
     * @example
     * // Get one MatchEvent
     * const matchEvent = await prisma.matchEvent.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends MatchEventFindFirstOrThrowArgs>(args?: SelectSubset<T, MatchEventFindFirstOrThrowArgs<ExtArgs>>): Prisma__MatchEventClient<$Result.GetResult<Prisma.$MatchEventPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find zero or more MatchEvents 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 {MatchEventFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all MatchEvents
     * const matchEvents = await prisma.matchEvent.findMany()
     * 
     * // Get first 10 MatchEvents
     * const matchEvents = await prisma.matchEvent.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const matchEventWithIdOnly = await prisma.matchEvent.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends MatchEventFindManyArgs>(args?: SelectSubset<T, MatchEventFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$MatchEventPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>

    /**
     * Create a MatchEvent.
     * @param {MatchEventCreateArgs} args - Arguments to create a MatchEvent.
     * @example
     * // Create one MatchEvent
     * const MatchEvent = await prisma.matchEvent.create({
     *   data: {
     *     // ... data to create a MatchEvent
     *   }
     * })
     * 
     */
    create<T extends MatchEventCreateArgs>(args: SelectSubset<T, MatchEventCreateArgs<ExtArgs>>): Prisma__MatchEventClient<$Result.GetResult<Prisma.$MatchEventPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Create many MatchEvents.
     * @param {MatchEventCreateManyArgs} args - Arguments to create many MatchEvents.
     * @example
     * // Create many MatchEvents
     * const matchEvent = await prisma.matchEvent.createMany({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     *     
     */
    createMany<T extends MatchEventCreateManyArgs>(args?: SelectSubset<T, MatchEventCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create many MatchEvents and returns the data saved in the database.
     * @param {MatchEventCreateManyAndReturnArgs} args - Arguments to create many MatchEvents.
     * @example
     * // Create many MatchEvents
     * const matchEvent = await prisma.matchEvent.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many MatchEvents and only return the `id`
     * const matchEventWithIdOnly = await prisma.matchEvent.createManyAndReturn({
     *   select: { id: true },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    createManyAndReturn<T extends MatchEventCreateManyAndReturnArgs>(args?: SelectSubset<T, MatchEventCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$MatchEventPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>

    /**
     * Delete a MatchEvent.
     * @param {MatchEventDeleteArgs} args - Arguments to delete one MatchEvent.
     * @example
     * // Delete one MatchEvent
     * const MatchEvent = await prisma.matchEvent.delete({
     *   where: {
     *     // ... filter to delete one MatchEvent
     *   }
     * })
     * 
     */
    delete<T extends MatchEventDeleteArgs>(args: SelectSubset<T, MatchEventDeleteArgs<ExtArgs>>): Prisma__MatchEventClient<$Result.GetResult<Prisma.$MatchEventPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Update one MatchEvent.
     * @param {MatchEventUpdateArgs} args - Arguments to update one MatchEvent.
     * @example
     * // Update one MatchEvent
     * const matchEvent = await prisma.matchEvent.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends MatchEventUpdateArgs>(args: SelectSubset<T, MatchEventUpdateArgs<ExtArgs>>): Prisma__MatchEventClient<$Result.GetResult<Prisma.$MatchEventPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Delete zero or more MatchEvents.
     * @param {MatchEventDeleteManyArgs} args - Arguments to filter MatchEvents to delete.
     * @example
     * // Delete a few MatchEvents
     * const { count } = await prisma.matchEvent.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
     */
    deleteMany<T extends MatchEventDeleteManyArgs>(args?: SelectSubset<T, MatchEventDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more MatchEvents.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {MatchEventUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many MatchEvents
     * const matchEvent = await prisma.matchEvent.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    updateMany<T extends MatchEventUpdateManyArgs>(args: SelectSubset<T, MatchEventUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more MatchEvents and returns the data updated in the database.
     * @param {MatchEventUpdateManyAndReturnArgs} args - Arguments to update many MatchEvents.
     * @example
     * // Update many MatchEvents
     * const matchEvent = await prisma.matchEvent.updateManyAndReturn({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Update zero or more MatchEvents and only return the `id`
     * const matchEventWithIdOnly = await prisma.matchEvent.updateManyAndReturn({
     *   select: { id: true },
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    updateManyAndReturn<T extends MatchEventUpdateManyAndReturnArgs>(args: SelectSubset<T, MatchEventUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$MatchEventPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>

    /**
     * Create or update one MatchEvent.
     * @param {MatchEventUpsertArgs} args - Arguments to update or create a MatchEvent.
     * @example
     * // Update or create a MatchEvent
     * const matchEvent = await prisma.matchEvent.upsert({
     *   create: {
     *     // ... data to create a MatchEvent
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the MatchEvent we want to update
     *   }
     * })
     */
    upsert<T extends MatchEventUpsertArgs>(args: SelectSubset<T, MatchEventUpsertArgs<ExtArgs>>): Prisma__MatchEventClient<$Result.GetResult<Prisma.$MatchEventPayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>


    /**
     * Count the number of MatchEvents.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {MatchEventCountArgs} args - Arguments to filter MatchEvents to count.
     * @example
     * // Count the number of MatchEvents
     * const count = await prisma.matchEvent.count({
     *   where: {
     *     // ... the filter for the MatchEvents we want to count
     *   }
     * })
    **/
    count<T extends MatchEventCountArgs>(
      args?: Subset<T, MatchEventCountArgs>,
    ): Prisma.PrismaPromise<
      T extends $Utils.Record<'select', any>
        ? T['select'] extends true
          ? number
          : GetScalarType<T['select'], MatchEventCountAggregateOutputType>
        : number
    >

    /**
     * Allows you to perform aggregations operations on a MatchEvent.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {MatchEventAggregateArgs} 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 MatchEventAggregateArgs>(args: Subset<T, MatchEventAggregateArgs>): Prisma.PrismaPromise<GetMatchEventAggregateType<T>>

    /**
     * Group by MatchEvent.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {MatchEventGroupByArgs} 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 MatchEventGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: MatchEventGroupByArgs['orderBy'] }
        : { orderBy?: MatchEventGroupByArgs['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, MatchEventGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetMatchEventGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the MatchEvent model
   */
  readonly fields: MatchEventFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for MatchEvent.
   * 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__MatchEventClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    match<T extends MatchDefaultArgs<ExtArgs> = {}>(args?: Subset<T, MatchDefaultArgs<ExtArgs>>): Prisma__MatchClient<$Result.GetResult<Prisma.$MatchPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
    player<T extends PlayerDefaultArgs<ExtArgs> = {}>(args?: Subset<T, PlayerDefaultArgs<ExtArgs>>): Prisma__PlayerClient<$Result.GetResult<Prisma.$PlayerPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
    /**
     * 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 MatchEvent model
   */
  interface MatchEventFieldRefs {
    readonly id: FieldRef<"MatchEvent", 'String'>
    readonly matchId: FieldRef<"MatchEvent", 'String'>
    readonly playerId: FieldRef<"MatchEvent", 'String'>
    readonly type: FieldRef<"MatchEvent", 'EventType'>
    readonly minute: FieldRef<"MatchEvent", 'Int'>
    readonly extraInfo: FieldRef<"MatchEvent", 'String'>
    readonly createdAt: FieldRef<"MatchEvent", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * MatchEvent findUnique
   */
  export type MatchEventFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MatchEvent
     */
    select?: MatchEventSelect<ExtArgs> | null
    /**
     * Omit specific fields from the MatchEvent
     */
    omit?: MatchEventOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MatchEventInclude<ExtArgs> | null
    /**
     * Filter, which MatchEvent to fetch.
     */
    where: MatchEventWhereUniqueInput
  }

  /**
   * MatchEvent findUniqueOrThrow
   */
  export type MatchEventFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MatchEvent
     */
    select?: MatchEventSelect<ExtArgs> | null
    /**
     * Omit specific fields from the MatchEvent
     */
    omit?: MatchEventOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MatchEventInclude<ExtArgs> | null
    /**
     * Filter, which MatchEvent to fetch.
     */
    where: MatchEventWhereUniqueInput
  }

  /**
   * MatchEvent findFirst
   */
  export type MatchEventFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MatchEvent
     */
    select?: MatchEventSelect<ExtArgs> | null
    /**
     * Omit specific fields from the MatchEvent
     */
    omit?: MatchEventOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MatchEventInclude<ExtArgs> | null
    /**
     * Filter, which MatchEvent to fetch.
     */
    where?: MatchEventWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of MatchEvents to fetch.
     */
    orderBy?: MatchEventOrderByWithRelationInput | MatchEventOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for MatchEvents.
     */
    cursor?: MatchEventWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` MatchEvents 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` MatchEvents.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of MatchEvents.
     */
    distinct?: MatchEventScalarFieldEnum | MatchEventScalarFieldEnum[]
  }

  /**
   * MatchEvent findFirstOrThrow
   */
  export type MatchEventFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MatchEvent
     */
    select?: MatchEventSelect<ExtArgs> | null
    /**
     * Omit specific fields from the MatchEvent
     */
    omit?: MatchEventOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MatchEventInclude<ExtArgs> | null
    /**
     * Filter, which MatchEvent to fetch.
     */
    where?: MatchEventWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of MatchEvents to fetch.
     */
    orderBy?: MatchEventOrderByWithRelationInput | MatchEventOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for MatchEvents.
     */
    cursor?: MatchEventWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` MatchEvents 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` MatchEvents.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of MatchEvents.
     */
    distinct?: MatchEventScalarFieldEnum | MatchEventScalarFieldEnum[]
  }

  /**
   * MatchEvent findMany
   */
  export type MatchEventFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MatchEvent
     */
    select?: MatchEventSelect<ExtArgs> | null
    /**
     * Omit specific fields from the MatchEvent
     */
    omit?: MatchEventOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MatchEventInclude<ExtArgs> | null
    /**
     * Filter, which MatchEvents to fetch.
     */
    where?: MatchEventWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of MatchEvents to fetch.
     */
    orderBy?: MatchEventOrderByWithRelationInput | MatchEventOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing MatchEvents.
     */
    cursor?: MatchEventWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` MatchEvents 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` MatchEvents.
     */
    skip?: number
    distinct?: MatchEventScalarFieldEnum | MatchEventScalarFieldEnum[]
  }

  /**
   * MatchEvent create
   */
  export type MatchEventCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MatchEvent
     */
    select?: MatchEventSelect<ExtArgs> | null
    /**
     * Omit specific fields from the MatchEvent
     */
    omit?: MatchEventOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MatchEventInclude<ExtArgs> | null
    /**
     * The data needed to create a MatchEvent.
     */
    data: XOR<MatchEventCreateInput, MatchEventUncheckedCreateInput>
  }

  /**
   * MatchEvent createMany
   */
  export type MatchEventCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many MatchEvents.
     */
    data: MatchEventCreateManyInput | MatchEventCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * MatchEvent createManyAndReturn
   */
  export type MatchEventCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MatchEvent
     */
    select?: MatchEventSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the MatchEvent
     */
    omit?: MatchEventOmit<ExtArgs> | null
    /**
     * The data used to create many MatchEvents.
     */
    data: MatchEventCreateManyInput | MatchEventCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MatchEventIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * MatchEvent update
   */
  export type MatchEventUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MatchEvent
     */
    select?: MatchEventSelect<ExtArgs> | null
    /**
     * Omit specific fields from the MatchEvent
     */
    omit?: MatchEventOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MatchEventInclude<ExtArgs> | null
    /**
     * The data needed to update a MatchEvent.
     */
    data: XOR<MatchEventUpdateInput, MatchEventUncheckedUpdateInput>
    /**
     * Choose, which MatchEvent to update.
     */
    where: MatchEventWhereUniqueInput
  }

  /**
   * MatchEvent updateMany
   */
  export type MatchEventUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update MatchEvents.
     */
    data: XOR<MatchEventUpdateManyMutationInput, MatchEventUncheckedUpdateManyInput>
    /**
     * Filter which MatchEvents to update
     */
    where?: MatchEventWhereInput
    /**
     * Limit how many MatchEvents to update.
     */
    limit?: number
  }

  /**
   * MatchEvent updateManyAndReturn
   */
  export type MatchEventUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MatchEvent
     */
    select?: MatchEventSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the MatchEvent
     */
    omit?: MatchEventOmit<ExtArgs> | null
    /**
     * The data used to update MatchEvents.
     */
    data: XOR<MatchEventUpdateManyMutationInput, MatchEventUncheckedUpdateManyInput>
    /**
     * Filter which MatchEvents to update
     */
    where?: MatchEventWhereInput
    /**
     * Limit how many MatchEvents to update.
     */
    limit?: number
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MatchEventIncludeUpdateManyAndReturn<ExtArgs> | null
  }

  /**
   * MatchEvent upsert
   */
  export type MatchEventUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MatchEvent
     */
    select?: MatchEventSelect<ExtArgs> | null
    /**
     * Omit specific fields from the MatchEvent
     */
    omit?: MatchEventOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MatchEventInclude<ExtArgs> | null
    /**
     * The filter to search for the MatchEvent to update in case it exists.
     */
    where: MatchEventWhereUniqueInput
    /**
     * In case the MatchEvent found by the `where` argument doesn't exist, create a new MatchEvent with this data.
     */
    create: XOR<MatchEventCreateInput, MatchEventUncheckedCreateInput>
    /**
     * In case the MatchEvent was found with the provided `where` argument, update it with this data.
     */
    update: XOR<MatchEventUpdateInput, MatchEventUncheckedUpdateInput>
  }

  /**
   * MatchEvent delete
   */
  export type MatchEventDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MatchEvent
     */
    select?: MatchEventSelect<ExtArgs> | null
    /**
     * Omit specific fields from the MatchEvent
     */
    omit?: MatchEventOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MatchEventInclude<ExtArgs> | null
    /**
     * Filter which MatchEvent to delete.
     */
    where: MatchEventWhereUniqueInput
  }

  /**
   * MatchEvent deleteMany
   */
  export type MatchEventDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which MatchEvents to delete
     */
    where?: MatchEventWhereInput
    /**
     * Limit how many MatchEvents to delete.
     */
    limit?: number
  }

  /**
   * MatchEvent without action
   */
  export type MatchEventDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MatchEvent
     */
    select?: MatchEventSelect<ExtArgs> | null
    /**
     * Omit specific fields from the MatchEvent
     */
    omit?: MatchEventOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MatchEventInclude<ExtArgs> | null
  }


  /**
   * Model MatchLineup
   */

  export type AggregateMatchLineup = {
    _count: MatchLineupCountAggregateOutputType | null
    _min: MatchLineupMinAggregateOutputType | null
    _max: MatchLineupMaxAggregateOutputType | null
  }

  export type MatchLineupMinAggregateOutputType = {
    id: string | null
    matchId: string | null
    countryId: string | null
    formation: string | null
  }

  export type MatchLineupMaxAggregateOutputType = {
    id: string | null
    matchId: string | null
    countryId: string | null
    formation: string | null
  }

  export type MatchLineupCountAggregateOutputType = {
    id: number
    matchId: number
    countryId: number
    formation: number
    playerIds: number
    _all: number
  }


  export type MatchLineupMinAggregateInputType = {
    id?: true
    matchId?: true
    countryId?: true
    formation?: true
  }

  export type MatchLineupMaxAggregateInputType = {
    id?: true
    matchId?: true
    countryId?: true
    formation?: true
  }

  export type MatchLineupCountAggregateInputType = {
    id?: true
    matchId?: true
    countryId?: true
    formation?: true
    playerIds?: true
    _all?: true
  }

  export type MatchLineupAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which MatchLineup to aggregate.
     */
    where?: MatchLineupWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of MatchLineups to fetch.
     */
    orderBy?: MatchLineupOrderByWithRelationInput | MatchLineupOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: MatchLineupWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` MatchLineups 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` MatchLineups.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned MatchLineups
    **/
    _count?: true | MatchLineupCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: MatchLineupMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: MatchLineupMaxAggregateInputType
  }

  export type GetMatchLineupAggregateType<T extends MatchLineupAggregateArgs> = {
        [P in keyof T & keyof AggregateMatchLineup]: P extends '_count' | 'count'
      ? T[P] extends true
        ? number
        : GetScalarType<T[P], AggregateMatchLineup[P]>
      : GetScalarType<T[P], AggregateMatchLineup[P]>
  }




  export type MatchLineupGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: MatchLineupWhereInput
    orderBy?: MatchLineupOrderByWithAggregationInput | MatchLineupOrderByWithAggregationInput[]
    by: MatchLineupScalarFieldEnum[] | MatchLineupScalarFieldEnum
    having?: MatchLineupScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: MatchLineupCountAggregateInputType | true
    _min?: MatchLineupMinAggregateInputType
    _max?: MatchLineupMaxAggregateInputType
  }

  export type MatchLineupGroupByOutputType = {
    id: string
    matchId: string
    countryId: string
    formation: string
    playerIds: string[]
    _count: MatchLineupCountAggregateOutputType | null
    _min: MatchLineupMinAggregateOutputType | null
    _max: MatchLineupMaxAggregateOutputType | null
  }

  type GetMatchLineupGroupByPayload<T extends MatchLineupGroupByArgs> = Prisma.PrismaPromise<
    Array<
      PickEnumerable<MatchLineupGroupByOutputType, T['by']> &
        {
          [P in ((keyof T) & (keyof MatchLineupGroupByOutputType))]: P extends '_count'
            ? T[P] extends boolean
              ? number
              : GetScalarType<T[P], MatchLineupGroupByOutputType[P]>
            : GetScalarType<T[P], MatchLineupGroupByOutputType[P]>
        }
      >
    >


  export type MatchLineupSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    matchId?: boolean
    countryId?: boolean
    formation?: boolean
    playerIds?: boolean
    match?: boolean | MatchDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["matchLineup"]>

  export type MatchLineupSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    matchId?: boolean
    countryId?: boolean
    formation?: boolean
    playerIds?: boolean
    match?: boolean | MatchDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["matchLineup"]>

  export type MatchLineupSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    matchId?: boolean
    countryId?: boolean
    formation?: boolean
    playerIds?: boolean
    match?: boolean | MatchDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["matchLineup"]>

  export type MatchLineupSelectScalar = {
    id?: boolean
    matchId?: boolean
    countryId?: boolean
    formation?: boolean
    playerIds?: boolean
  }

  export type MatchLineupOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "matchId" | "countryId" | "formation" | "playerIds", ExtArgs["result"]["matchLineup"]>
  export type MatchLineupInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    match?: boolean | MatchDefaultArgs<ExtArgs>
  }
  export type MatchLineupIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    match?: boolean | MatchDefaultArgs<ExtArgs>
  }
  export type MatchLineupIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    match?: boolean | MatchDefaultArgs<ExtArgs>
  }

  export type $MatchLineupPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "MatchLineup"
    objects: {
      match: Prisma.$MatchPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      matchId: string
      countryId: string
      formation: string
      playerIds: string[]
    }, ExtArgs["result"]["matchLineup"]>
    composites: {}
  }

  type MatchLineupGetPayload<S extends boolean | null | undefined | MatchLineupDefaultArgs> = $Result.GetResult<Prisma.$MatchLineupPayload, S>

  type MatchLineupCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
    Omit<MatchLineupFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
      select?: MatchLineupCountAggregateInputType | true
    }

  export interface MatchLineupDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> {
    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['MatchLineup'], meta: { name: 'MatchLineup' } }
    /**
     * Find zero or one MatchLineup that matches the filter.
     * @param {MatchLineupFindUniqueArgs} args - Arguments to find a MatchLineup
     * @example
     * // Get one MatchLineup
     * const matchLineup = await prisma.matchLineup.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUnique<T extends MatchLineupFindUniqueArgs>(args: SelectSubset<T, MatchLineupFindUniqueArgs<ExtArgs>>): Prisma__MatchLineupClient<$Result.GetResult<Prisma.$MatchLineupPayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find one MatchLineup that matches the filter or throw an error with `error.code='P2025'`
     * if no matches were found.
     * @param {MatchLineupFindUniqueOrThrowArgs} args - Arguments to find a MatchLineup
     * @example
     * // Get one MatchLineup
     * const matchLineup = await prisma.matchLineup.findUniqueOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUniqueOrThrow<T extends MatchLineupFindUniqueOrThrowArgs>(args: SelectSubset<T, MatchLineupFindUniqueOrThrowArgs<ExtArgs>>): Prisma__MatchLineupClient<$Result.GetResult<Prisma.$MatchLineupPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first MatchLineup 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 {MatchLineupFindFirstArgs} args - Arguments to find a MatchLineup
     * @example
     * // Get one MatchLineup
     * const matchLineup = await prisma.matchLineup.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends MatchLineupFindFirstArgs>(args?: SelectSubset<T, MatchLineupFindFirstArgs<ExtArgs>>): Prisma__MatchLineupClient<$Result.GetResult<Prisma.$MatchLineupPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first MatchLineup 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 {MatchLineupFindFirstOrThrowArgs} args - Arguments to find a MatchLineup
     * @example
     * // Get one MatchLineup
     * const matchLineup = await prisma.matchLineup.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends MatchLineupFindFirstOrThrowArgs>(args?: SelectSubset<T, MatchLineupFindFirstOrThrowArgs<ExtArgs>>): Prisma__MatchLineupClient<$Result.GetResult<Prisma.$MatchLineupPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find zero or more MatchLineups 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 {MatchLineupFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all MatchLineups
     * const matchLineups = await prisma.matchLineup.findMany()
     * 
     * // Get first 10 MatchLineups
     * const matchLineups = await prisma.matchLineup.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const matchLineupWithIdOnly = await prisma.matchLineup.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends MatchLineupFindManyArgs>(args?: SelectSubset<T, MatchLineupFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$MatchLineupPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>

    /**
     * Create a MatchLineup.
     * @param {MatchLineupCreateArgs} args - Arguments to create a MatchLineup.
     * @example
     * // Create one MatchLineup
     * const MatchLineup = await prisma.matchLineup.create({
     *   data: {
     *     // ... data to create a MatchLineup
     *   }
     * })
     * 
     */
    create<T extends MatchLineupCreateArgs>(args: SelectSubset<T, MatchLineupCreateArgs<ExtArgs>>): Prisma__MatchLineupClient<$Result.GetResult<Prisma.$MatchLineupPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Create many MatchLineups.
     * @param {MatchLineupCreateManyArgs} args - Arguments to create many MatchLineups.
     * @example
     * // Create many MatchLineups
     * const matchLineup = await prisma.matchLineup.createMany({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     *     
     */
    createMany<T extends MatchLineupCreateManyArgs>(args?: SelectSubset<T, MatchLineupCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create many MatchLineups and returns the data saved in the database.
     * @param {MatchLineupCreateManyAndReturnArgs} args - Arguments to create many MatchLineups.
     * @example
     * // Create many MatchLineups
     * const matchLineup = await prisma.matchLineup.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many MatchLineups and only return the `id`
     * const matchLineupWithIdOnly = await prisma.matchLineup.createManyAndReturn({
     *   select: { id: true },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    createManyAndReturn<T extends MatchLineupCreateManyAndReturnArgs>(args?: SelectSubset<T, MatchLineupCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$MatchLineupPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>

    /**
     * Delete a MatchLineup.
     * @param {MatchLineupDeleteArgs} args - Arguments to delete one MatchLineup.
     * @example
     * // Delete one MatchLineup
     * const MatchLineup = await prisma.matchLineup.delete({
     *   where: {
     *     // ... filter to delete one MatchLineup
     *   }
     * })
     * 
     */
    delete<T extends MatchLineupDeleteArgs>(args: SelectSubset<T, MatchLineupDeleteArgs<ExtArgs>>): Prisma__MatchLineupClient<$Result.GetResult<Prisma.$MatchLineupPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Update one MatchLineup.
     * @param {MatchLineupUpdateArgs} args - Arguments to update one MatchLineup.
     * @example
     * // Update one MatchLineup
     * const matchLineup = await prisma.matchLineup.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends MatchLineupUpdateArgs>(args: SelectSubset<T, MatchLineupUpdateArgs<ExtArgs>>): Prisma__MatchLineupClient<$Result.GetResult<Prisma.$MatchLineupPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Delete zero or more MatchLineups.
     * @param {MatchLineupDeleteManyArgs} args - Arguments to filter MatchLineups to delete.
     * @example
     * // Delete a few MatchLineups
     * const { count } = await prisma.matchLineup.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
     */
    deleteMany<T extends MatchLineupDeleteManyArgs>(args?: SelectSubset<T, MatchLineupDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more MatchLineups.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {MatchLineupUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many MatchLineups
     * const matchLineup = await prisma.matchLineup.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    updateMany<T extends MatchLineupUpdateManyArgs>(args: SelectSubset<T, MatchLineupUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more MatchLineups and returns the data updated in the database.
     * @param {MatchLineupUpdateManyAndReturnArgs} args - Arguments to update many MatchLineups.
     * @example
     * // Update many MatchLineups
     * const matchLineup = await prisma.matchLineup.updateManyAndReturn({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Update zero or more MatchLineups and only return the `id`
     * const matchLineupWithIdOnly = await prisma.matchLineup.updateManyAndReturn({
     *   select: { id: true },
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    updateManyAndReturn<T extends MatchLineupUpdateManyAndReturnArgs>(args: SelectSubset<T, MatchLineupUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$MatchLineupPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>

    /**
     * Create or update one MatchLineup.
     * @param {MatchLineupUpsertArgs} args - Arguments to update or create a MatchLineup.
     * @example
     * // Update or create a MatchLineup
     * const matchLineup = await prisma.matchLineup.upsert({
     *   create: {
     *     // ... data to create a MatchLineup
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the MatchLineup we want to update
     *   }
     * })
     */
    upsert<T extends MatchLineupUpsertArgs>(args: SelectSubset<T, MatchLineupUpsertArgs<ExtArgs>>): Prisma__MatchLineupClient<$Result.GetResult<Prisma.$MatchLineupPayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>


    /**
     * Count the number of MatchLineups.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {MatchLineupCountArgs} args - Arguments to filter MatchLineups to count.
     * @example
     * // Count the number of MatchLineups
     * const count = await prisma.matchLineup.count({
     *   where: {
     *     // ... the filter for the MatchLineups we want to count
     *   }
     * })
    **/
    count<T extends MatchLineupCountArgs>(
      args?: Subset<T, MatchLineupCountArgs>,
    ): Prisma.PrismaPromise<
      T extends $Utils.Record<'select', any>
        ? T['select'] extends true
          ? number
          : GetScalarType<T['select'], MatchLineupCountAggregateOutputType>
        : number
    >

    /**
     * Allows you to perform aggregations operations on a MatchLineup.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {MatchLineupAggregateArgs} 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 MatchLineupAggregateArgs>(args: Subset<T, MatchLineupAggregateArgs>): Prisma.PrismaPromise<GetMatchLineupAggregateType<T>>

    /**
     * Group by MatchLineup.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {MatchLineupGroupByArgs} 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 MatchLineupGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: MatchLineupGroupByArgs['orderBy'] }
        : { orderBy?: MatchLineupGroupByArgs['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, MatchLineupGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetMatchLineupGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the MatchLineup model
   */
  readonly fields: MatchLineupFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for MatchLineup.
   * 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__MatchLineupClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    match<T extends MatchDefaultArgs<ExtArgs> = {}>(args?: Subset<T, MatchDefaultArgs<ExtArgs>>): Prisma__MatchClient<$Result.GetResult<Prisma.$MatchPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
    /**
     * 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 MatchLineup model
   */
  interface MatchLineupFieldRefs {
    readonly id: FieldRef<"MatchLineup", 'String'>
    readonly matchId: FieldRef<"MatchLineup", 'String'>
    readonly countryId: FieldRef<"MatchLineup", 'String'>
    readonly formation: FieldRef<"MatchLineup", 'String'>
    readonly playerIds: FieldRef<"MatchLineup", 'String[]'>
  }
    

  // Custom InputTypes
  /**
   * MatchLineup findUnique
   */
  export type MatchLineupFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MatchLineup
     */
    select?: MatchLineupSelect<ExtArgs> | null
    /**
     * Omit specific fields from the MatchLineup
     */
    omit?: MatchLineupOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MatchLineupInclude<ExtArgs> | null
    /**
     * Filter, which MatchLineup to fetch.
     */
    where: MatchLineupWhereUniqueInput
  }

  /**
   * MatchLineup findUniqueOrThrow
   */
  export type MatchLineupFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MatchLineup
     */
    select?: MatchLineupSelect<ExtArgs> | null
    /**
     * Omit specific fields from the MatchLineup
     */
    omit?: MatchLineupOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MatchLineupInclude<ExtArgs> | null
    /**
     * Filter, which MatchLineup to fetch.
     */
    where: MatchLineupWhereUniqueInput
  }

  /**
   * MatchLineup findFirst
   */
  export type MatchLineupFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MatchLineup
     */
    select?: MatchLineupSelect<ExtArgs> | null
    /**
     * Omit specific fields from the MatchLineup
     */
    omit?: MatchLineupOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MatchLineupInclude<ExtArgs> | null
    /**
     * Filter, which MatchLineup to fetch.
     */
    where?: MatchLineupWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of MatchLineups to fetch.
     */
    orderBy?: MatchLineupOrderByWithRelationInput | MatchLineupOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for MatchLineups.
     */
    cursor?: MatchLineupWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` MatchLineups 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` MatchLineups.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of MatchLineups.
     */
    distinct?: MatchLineupScalarFieldEnum | MatchLineupScalarFieldEnum[]
  }

  /**
   * MatchLineup findFirstOrThrow
   */
  export type MatchLineupFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MatchLineup
     */
    select?: MatchLineupSelect<ExtArgs> | null
    /**
     * Omit specific fields from the MatchLineup
     */
    omit?: MatchLineupOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MatchLineupInclude<ExtArgs> | null
    /**
     * Filter, which MatchLineup to fetch.
     */
    where?: MatchLineupWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of MatchLineups to fetch.
     */
    orderBy?: MatchLineupOrderByWithRelationInput | MatchLineupOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for MatchLineups.
     */
    cursor?: MatchLineupWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` MatchLineups 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` MatchLineups.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of MatchLineups.
     */
    distinct?: MatchLineupScalarFieldEnum | MatchLineupScalarFieldEnum[]
  }

  /**
   * MatchLineup findMany
   */
  export type MatchLineupFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MatchLineup
     */
    select?: MatchLineupSelect<ExtArgs> | null
    /**
     * Omit specific fields from the MatchLineup
     */
    omit?: MatchLineupOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MatchLineupInclude<ExtArgs> | null
    /**
     * Filter, which MatchLineups to fetch.
     */
    where?: MatchLineupWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of MatchLineups to fetch.
     */
    orderBy?: MatchLineupOrderByWithRelationInput | MatchLineupOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing MatchLineups.
     */
    cursor?: MatchLineupWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` MatchLineups 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` MatchLineups.
     */
    skip?: number
    distinct?: MatchLineupScalarFieldEnum | MatchLineupScalarFieldEnum[]
  }

  /**
   * MatchLineup create
   */
  export type MatchLineupCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MatchLineup
     */
    select?: MatchLineupSelect<ExtArgs> | null
    /**
     * Omit specific fields from the MatchLineup
     */
    omit?: MatchLineupOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MatchLineupInclude<ExtArgs> | null
    /**
     * The data needed to create a MatchLineup.
     */
    data: XOR<MatchLineupCreateInput, MatchLineupUncheckedCreateInput>
  }

  /**
   * MatchLineup createMany
   */
  export type MatchLineupCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many MatchLineups.
     */
    data: MatchLineupCreateManyInput | MatchLineupCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * MatchLineup createManyAndReturn
   */
  export type MatchLineupCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MatchLineup
     */
    select?: MatchLineupSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the MatchLineup
     */
    omit?: MatchLineupOmit<ExtArgs> | null
    /**
     * The data used to create many MatchLineups.
     */
    data: MatchLineupCreateManyInput | MatchLineupCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MatchLineupIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * MatchLineup update
   */
  export type MatchLineupUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MatchLineup
     */
    select?: MatchLineupSelect<ExtArgs> | null
    /**
     * Omit specific fields from the MatchLineup
     */
    omit?: MatchLineupOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MatchLineupInclude<ExtArgs> | null
    /**
     * The data needed to update a MatchLineup.
     */
    data: XOR<MatchLineupUpdateInput, MatchLineupUncheckedUpdateInput>
    /**
     * Choose, which MatchLineup to update.
     */
    where: MatchLineupWhereUniqueInput
  }

  /**
   * MatchLineup updateMany
   */
  export type MatchLineupUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update MatchLineups.
     */
    data: XOR<MatchLineupUpdateManyMutationInput, MatchLineupUncheckedUpdateManyInput>
    /**
     * Filter which MatchLineups to update
     */
    where?: MatchLineupWhereInput
    /**
     * Limit how many MatchLineups to update.
     */
    limit?: number
  }

  /**
   * MatchLineup updateManyAndReturn
   */
  export type MatchLineupUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MatchLineup
     */
    select?: MatchLineupSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the MatchLineup
     */
    omit?: MatchLineupOmit<ExtArgs> | null
    /**
     * The data used to update MatchLineups.
     */
    data: XOR<MatchLineupUpdateManyMutationInput, MatchLineupUncheckedUpdateManyInput>
    /**
     * Filter which MatchLineups to update
     */
    where?: MatchLineupWhereInput
    /**
     * Limit how many MatchLineups to update.
     */
    limit?: number
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MatchLineupIncludeUpdateManyAndReturn<ExtArgs> | null
  }

  /**
   * MatchLineup upsert
   */
  export type MatchLineupUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MatchLineup
     */
    select?: MatchLineupSelect<ExtArgs> | null
    /**
     * Omit specific fields from the MatchLineup
     */
    omit?: MatchLineupOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MatchLineupInclude<ExtArgs> | null
    /**
     * The filter to search for the MatchLineup to update in case it exists.
     */
    where: MatchLineupWhereUniqueInput
    /**
     * In case the MatchLineup found by the `where` argument doesn't exist, create a new MatchLineup with this data.
     */
    create: XOR<MatchLineupCreateInput, MatchLineupUncheckedCreateInput>
    /**
     * In case the MatchLineup was found with the provided `where` argument, update it with this data.
     */
    update: XOR<MatchLineupUpdateInput, MatchLineupUncheckedUpdateInput>
  }

  /**
   * MatchLineup delete
   */
  export type MatchLineupDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MatchLineup
     */
    select?: MatchLineupSelect<ExtArgs> | null
    /**
     * Omit specific fields from the MatchLineup
     */
    omit?: MatchLineupOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MatchLineupInclude<ExtArgs> | null
    /**
     * Filter which MatchLineup to delete.
     */
    where: MatchLineupWhereUniqueInput
  }

  /**
   * MatchLineup deleteMany
   */
  export type MatchLineupDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which MatchLineups to delete
     */
    where?: MatchLineupWhereInput
    /**
     * Limit how many MatchLineups to delete.
     */
    limit?: number
  }

  /**
   * MatchLineup without action
   */
  export type MatchLineupDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MatchLineup
     */
    select?: MatchLineupSelect<ExtArgs> | null
    /**
     * Omit specific fields from the MatchLineup
     */
    omit?: MatchLineupOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MatchLineupInclude<ExtArgs> | null
  }


  /**
   * Model PlayerMatchStat
   */

  export type AggregatePlayerMatchStat = {
    _count: PlayerMatchStatCountAggregateOutputType | null
    _avg: PlayerMatchStatAvgAggregateOutputType | null
    _sum: PlayerMatchStatSumAggregateOutputType | null
    _min: PlayerMatchStatMinAggregateOutputType | null
    _max: PlayerMatchStatMaxAggregateOutputType | null
  }

  export type PlayerMatchStatAvgAggregateOutputType = {
    goals: number | null
    assists: number | null
    yellowCards: number | null
    redCards: number | null
    minutesPlayed: number | null
    penaltySaved: number | null
    penaltyMissed: number | null
    ownGoals: number | null
    extraTimeBonus: number | null
    points: number | null
  }

  export type PlayerMatchStatSumAggregateOutputType = {
    goals: number | null
    assists: number | null
    yellowCards: number | null
    redCards: number | null
    minutesPlayed: number | null
    penaltySaved: number | null
    penaltyMissed: number | null
    ownGoals: number | null
    extraTimeBonus: number | null
    points: number | null
  }

  export type PlayerMatchStatMinAggregateOutputType = {
    id: string | null
    playerId: string | null
    matchId: string | null
    goals: number | null
    assists: number | null
    yellowCards: number | null
    redCards: number | null
    minutesPlayed: number | null
    cleanSheet: boolean | null
    penaltySaved: number | null
    penaltyMissed: number | null
    ownGoals: number | null
    isMotm: boolean | null
    extraTimeBonus: number | null
    points: number | null
  }

  export type PlayerMatchStatMaxAggregateOutputType = {
    id: string | null
    playerId: string | null
    matchId: string | null
    goals: number | null
    assists: number | null
    yellowCards: number | null
    redCards: number | null
    minutesPlayed: number | null
    cleanSheet: boolean | null
    penaltySaved: number | null
    penaltyMissed: number | null
    ownGoals: number | null
    isMotm: boolean | null
    extraTimeBonus: number | null
    points: number | null
  }

  export type PlayerMatchStatCountAggregateOutputType = {
    id: number
    playerId: number
    matchId: number
    goals: number
    assists: number
    yellowCards: number
    redCards: number
    minutesPlayed: number
    cleanSheet: number
    penaltySaved: number
    penaltyMissed: number
    ownGoals: number
    isMotm: number
    extraTimeBonus: number
    points: number
    _all: number
  }


  export type PlayerMatchStatAvgAggregateInputType = {
    goals?: true
    assists?: true
    yellowCards?: true
    redCards?: true
    minutesPlayed?: true
    penaltySaved?: true
    penaltyMissed?: true
    ownGoals?: true
    extraTimeBonus?: true
    points?: true
  }

  export type PlayerMatchStatSumAggregateInputType = {
    goals?: true
    assists?: true
    yellowCards?: true
    redCards?: true
    minutesPlayed?: true
    penaltySaved?: true
    penaltyMissed?: true
    ownGoals?: true
    extraTimeBonus?: true
    points?: true
  }

  export type PlayerMatchStatMinAggregateInputType = {
    id?: true
    playerId?: true
    matchId?: true
    goals?: true
    assists?: true
    yellowCards?: true
    redCards?: true
    minutesPlayed?: true
    cleanSheet?: true
    penaltySaved?: true
    penaltyMissed?: true
    ownGoals?: true
    isMotm?: true
    extraTimeBonus?: true
    points?: true
  }

  export type PlayerMatchStatMaxAggregateInputType = {
    id?: true
    playerId?: true
    matchId?: true
    goals?: true
    assists?: true
    yellowCards?: true
    redCards?: true
    minutesPlayed?: true
    cleanSheet?: true
    penaltySaved?: true
    penaltyMissed?: true
    ownGoals?: true
    isMotm?: true
    extraTimeBonus?: true
    points?: true
  }

  export type PlayerMatchStatCountAggregateInputType = {
    id?: true
    playerId?: true
    matchId?: true
    goals?: true
    assists?: true
    yellowCards?: true
    redCards?: true
    minutesPlayed?: true
    cleanSheet?: true
    penaltySaved?: true
    penaltyMissed?: true
    ownGoals?: true
    isMotm?: true
    extraTimeBonus?: true
    points?: true
    _all?: true
  }

  export type PlayerMatchStatAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which PlayerMatchStat to aggregate.
     */
    where?: PlayerMatchStatWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of PlayerMatchStats to fetch.
     */
    orderBy?: PlayerMatchStatOrderByWithRelationInput | PlayerMatchStatOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: PlayerMatchStatWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` PlayerMatchStats 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` PlayerMatchStats.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned PlayerMatchStats
    **/
    _count?: true | PlayerMatchStatCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: PlayerMatchStatAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: PlayerMatchStatSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: PlayerMatchStatMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: PlayerMatchStatMaxAggregateInputType
  }

  export type GetPlayerMatchStatAggregateType<T extends PlayerMatchStatAggregateArgs> = {
        [P in keyof T & keyof AggregatePlayerMatchStat]: P extends '_count' | 'count'
      ? T[P] extends true
        ? number
        : GetScalarType<T[P], AggregatePlayerMatchStat[P]>
      : GetScalarType<T[P], AggregatePlayerMatchStat[P]>
  }




  export type PlayerMatchStatGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: PlayerMatchStatWhereInput
    orderBy?: PlayerMatchStatOrderByWithAggregationInput | PlayerMatchStatOrderByWithAggregationInput[]
    by: PlayerMatchStatScalarFieldEnum[] | PlayerMatchStatScalarFieldEnum
    having?: PlayerMatchStatScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: PlayerMatchStatCountAggregateInputType | true
    _avg?: PlayerMatchStatAvgAggregateInputType
    _sum?: PlayerMatchStatSumAggregateInputType
    _min?: PlayerMatchStatMinAggregateInputType
    _max?: PlayerMatchStatMaxAggregateInputType
  }

  export type PlayerMatchStatGroupByOutputType = {
    id: string
    playerId: string
    matchId: string
    goals: number
    assists: number
    yellowCards: number
    redCards: number
    minutesPlayed: number
    cleanSheet: boolean
    penaltySaved: number
    penaltyMissed: number
    ownGoals: number
    isMotm: boolean
    extraTimeBonus: number
    points: number
    _count: PlayerMatchStatCountAggregateOutputType | null
    _avg: PlayerMatchStatAvgAggregateOutputType | null
    _sum: PlayerMatchStatSumAggregateOutputType | null
    _min: PlayerMatchStatMinAggregateOutputType | null
    _max: PlayerMatchStatMaxAggregateOutputType | null
  }

  type GetPlayerMatchStatGroupByPayload<T extends PlayerMatchStatGroupByArgs> = Prisma.PrismaPromise<
    Array<
      PickEnumerable<PlayerMatchStatGroupByOutputType, T['by']> &
        {
          [P in ((keyof T) & (keyof PlayerMatchStatGroupByOutputType))]: P extends '_count'
            ? T[P] extends boolean
              ? number
              : GetScalarType<T[P], PlayerMatchStatGroupByOutputType[P]>
            : GetScalarType<T[P], PlayerMatchStatGroupByOutputType[P]>
        }
      >
    >


  export type PlayerMatchStatSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    playerId?: boolean
    matchId?: boolean
    goals?: boolean
    assists?: boolean
    yellowCards?: boolean
    redCards?: boolean
    minutesPlayed?: boolean
    cleanSheet?: boolean
    penaltySaved?: boolean
    penaltyMissed?: boolean
    ownGoals?: boolean
    isMotm?: boolean
    extraTimeBonus?: boolean
    points?: boolean
    player?: boolean | PlayerDefaultArgs<ExtArgs>
    match?: boolean | MatchDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["playerMatchStat"]>

  export type PlayerMatchStatSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    playerId?: boolean
    matchId?: boolean
    goals?: boolean
    assists?: boolean
    yellowCards?: boolean
    redCards?: boolean
    minutesPlayed?: boolean
    cleanSheet?: boolean
    penaltySaved?: boolean
    penaltyMissed?: boolean
    ownGoals?: boolean
    isMotm?: boolean
    extraTimeBonus?: boolean
    points?: boolean
    player?: boolean | PlayerDefaultArgs<ExtArgs>
    match?: boolean | MatchDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["playerMatchStat"]>

  export type PlayerMatchStatSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    playerId?: boolean
    matchId?: boolean
    goals?: boolean
    assists?: boolean
    yellowCards?: boolean
    redCards?: boolean
    minutesPlayed?: boolean
    cleanSheet?: boolean
    penaltySaved?: boolean
    penaltyMissed?: boolean
    ownGoals?: boolean
    isMotm?: boolean
    extraTimeBonus?: boolean
    points?: boolean
    player?: boolean | PlayerDefaultArgs<ExtArgs>
    match?: boolean | MatchDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["playerMatchStat"]>

  export type PlayerMatchStatSelectScalar = {
    id?: boolean
    playerId?: boolean
    matchId?: boolean
    goals?: boolean
    assists?: boolean
    yellowCards?: boolean
    redCards?: boolean
    minutesPlayed?: boolean
    cleanSheet?: boolean
    penaltySaved?: boolean
    penaltyMissed?: boolean
    ownGoals?: boolean
    isMotm?: boolean
    extraTimeBonus?: boolean
    points?: boolean
  }

  export type PlayerMatchStatOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "playerId" | "matchId" | "goals" | "assists" | "yellowCards" | "redCards" | "minutesPlayed" | "cleanSheet" | "penaltySaved" | "penaltyMissed" | "ownGoals" | "isMotm" | "extraTimeBonus" | "points", ExtArgs["result"]["playerMatchStat"]>
  export type PlayerMatchStatInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    player?: boolean | PlayerDefaultArgs<ExtArgs>
    match?: boolean | MatchDefaultArgs<ExtArgs>
  }
  export type PlayerMatchStatIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    player?: boolean | PlayerDefaultArgs<ExtArgs>
    match?: boolean | MatchDefaultArgs<ExtArgs>
  }
  export type PlayerMatchStatIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    player?: boolean | PlayerDefaultArgs<ExtArgs>
    match?: boolean | MatchDefaultArgs<ExtArgs>
  }

  export type $PlayerMatchStatPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "PlayerMatchStat"
    objects: {
      player: Prisma.$PlayerPayload<ExtArgs>
      match: Prisma.$MatchPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      playerId: string
      matchId: string
      goals: number
      assists: number
      yellowCards: number
      redCards: number
      minutesPlayed: number
      cleanSheet: boolean
      penaltySaved: number
      penaltyMissed: number
      ownGoals: number
      isMotm: boolean
      extraTimeBonus: number
      points: number
    }, ExtArgs["result"]["playerMatchStat"]>
    composites: {}
  }

  type PlayerMatchStatGetPayload<S extends boolean | null | undefined | PlayerMatchStatDefaultArgs> = $Result.GetResult<Prisma.$PlayerMatchStatPayload, S>

  type PlayerMatchStatCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
    Omit<PlayerMatchStatFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
      select?: PlayerMatchStatCountAggregateInputType | true
    }

  export interface PlayerMatchStatDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> {
    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['PlayerMatchStat'], meta: { name: 'PlayerMatchStat' } }
    /**
     * Find zero or one PlayerMatchStat that matches the filter.
     * @param {PlayerMatchStatFindUniqueArgs} args - Arguments to find a PlayerMatchStat
     * @example
     * // Get one PlayerMatchStat
     * const playerMatchStat = await prisma.playerMatchStat.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUnique<T extends PlayerMatchStatFindUniqueArgs>(args: SelectSubset<T, PlayerMatchStatFindUniqueArgs<ExtArgs>>): Prisma__PlayerMatchStatClient<$Result.GetResult<Prisma.$PlayerMatchStatPayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find one PlayerMatchStat that matches the filter or throw an error with `error.code='P2025'`
     * if no matches were found.
     * @param {PlayerMatchStatFindUniqueOrThrowArgs} args - Arguments to find a PlayerMatchStat
     * @example
     * // Get one PlayerMatchStat
     * const playerMatchStat = await prisma.playerMatchStat.findUniqueOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUniqueOrThrow<T extends PlayerMatchStatFindUniqueOrThrowArgs>(args: SelectSubset<T, PlayerMatchStatFindUniqueOrThrowArgs<ExtArgs>>): Prisma__PlayerMatchStatClient<$Result.GetResult<Prisma.$PlayerMatchStatPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first PlayerMatchStat 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 {PlayerMatchStatFindFirstArgs} args - Arguments to find a PlayerMatchStat
     * @example
     * // Get one PlayerMatchStat
     * const playerMatchStat = await prisma.playerMatchStat.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends PlayerMatchStatFindFirstArgs>(args?: SelectSubset<T, PlayerMatchStatFindFirstArgs<ExtArgs>>): Prisma__PlayerMatchStatClient<$Result.GetResult<Prisma.$PlayerMatchStatPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first PlayerMatchStat 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 {PlayerMatchStatFindFirstOrThrowArgs} args - Arguments to find a PlayerMatchStat
     * @example
     * // Get one PlayerMatchStat
     * const playerMatchStat = await prisma.playerMatchStat.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends PlayerMatchStatFindFirstOrThrowArgs>(args?: SelectSubset<T, PlayerMatchStatFindFirstOrThrowArgs<ExtArgs>>): Prisma__PlayerMatchStatClient<$Result.GetResult<Prisma.$PlayerMatchStatPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find zero or more PlayerMatchStats 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 {PlayerMatchStatFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all PlayerMatchStats
     * const playerMatchStats = await prisma.playerMatchStat.findMany()
     * 
     * // Get first 10 PlayerMatchStats
     * const playerMatchStats = await prisma.playerMatchStat.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const playerMatchStatWithIdOnly = await prisma.playerMatchStat.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends PlayerMatchStatFindManyArgs>(args?: SelectSubset<T, PlayerMatchStatFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$PlayerMatchStatPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>

    /**
     * Create a PlayerMatchStat.
     * @param {PlayerMatchStatCreateArgs} args - Arguments to create a PlayerMatchStat.
     * @example
     * // Create one PlayerMatchStat
     * const PlayerMatchStat = await prisma.playerMatchStat.create({
     *   data: {
     *     // ... data to create a PlayerMatchStat
     *   }
     * })
     * 
     */
    create<T extends PlayerMatchStatCreateArgs>(args: SelectSubset<T, PlayerMatchStatCreateArgs<ExtArgs>>): Prisma__PlayerMatchStatClient<$Result.GetResult<Prisma.$PlayerMatchStatPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Create many PlayerMatchStats.
     * @param {PlayerMatchStatCreateManyArgs} args - Arguments to create many PlayerMatchStats.
     * @example
     * // Create many PlayerMatchStats
     * const playerMatchStat = await prisma.playerMatchStat.createMany({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     *     
     */
    createMany<T extends PlayerMatchStatCreateManyArgs>(args?: SelectSubset<T, PlayerMatchStatCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create many PlayerMatchStats and returns the data saved in the database.
     * @param {PlayerMatchStatCreateManyAndReturnArgs} args - Arguments to create many PlayerMatchStats.
     * @example
     * // Create many PlayerMatchStats
     * const playerMatchStat = await prisma.playerMatchStat.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many PlayerMatchStats and only return the `id`
     * const playerMatchStatWithIdOnly = await prisma.playerMatchStat.createManyAndReturn({
     *   select: { id: true },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    createManyAndReturn<T extends PlayerMatchStatCreateManyAndReturnArgs>(args?: SelectSubset<T, PlayerMatchStatCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$PlayerMatchStatPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>

    /**
     * Delete a PlayerMatchStat.
     * @param {PlayerMatchStatDeleteArgs} args - Arguments to delete one PlayerMatchStat.
     * @example
     * // Delete one PlayerMatchStat
     * const PlayerMatchStat = await prisma.playerMatchStat.delete({
     *   where: {
     *     // ... filter to delete one PlayerMatchStat
     *   }
     * })
     * 
     */
    delete<T extends PlayerMatchStatDeleteArgs>(args: SelectSubset<T, PlayerMatchStatDeleteArgs<ExtArgs>>): Prisma__PlayerMatchStatClient<$Result.GetResult<Prisma.$PlayerMatchStatPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Update one PlayerMatchStat.
     * @param {PlayerMatchStatUpdateArgs} args - Arguments to update one PlayerMatchStat.
     * @example
     * // Update one PlayerMatchStat
     * const playerMatchStat = await prisma.playerMatchStat.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends PlayerMatchStatUpdateArgs>(args: SelectSubset<T, PlayerMatchStatUpdateArgs<ExtArgs>>): Prisma__PlayerMatchStatClient<$Result.GetResult<Prisma.$PlayerMatchStatPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Delete zero or more PlayerMatchStats.
     * @param {PlayerMatchStatDeleteManyArgs} args - Arguments to filter PlayerMatchStats to delete.
     * @example
     * // Delete a few PlayerMatchStats
     * const { count } = await prisma.playerMatchStat.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
     */
    deleteMany<T extends PlayerMatchStatDeleteManyArgs>(args?: SelectSubset<T, PlayerMatchStatDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more PlayerMatchStats.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {PlayerMatchStatUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many PlayerMatchStats
     * const playerMatchStat = await prisma.playerMatchStat.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    updateMany<T extends PlayerMatchStatUpdateManyArgs>(args: SelectSubset<T, PlayerMatchStatUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more PlayerMatchStats and returns the data updated in the database.
     * @param {PlayerMatchStatUpdateManyAndReturnArgs} args - Arguments to update many PlayerMatchStats.
     * @example
     * // Update many PlayerMatchStats
     * const playerMatchStat = await prisma.playerMatchStat.updateManyAndReturn({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Update zero or more PlayerMatchStats and only return the `id`
     * const playerMatchStatWithIdOnly = await prisma.playerMatchStat.updateManyAndReturn({
     *   select: { id: true },
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    updateManyAndReturn<T extends PlayerMatchStatUpdateManyAndReturnArgs>(args: SelectSubset<T, PlayerMatchStatUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$PlayerMatchStatPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>

    /**
     * Create or update one PlayerMatchStat.
     * @param {PlayerMatchStatUpsertArgs} args - Arguments to update or create a PlayerMatchStat.
     * @example
     * // Update or create a PlayerMatchStat
     * const playerMatchStat = await prisma.playerMatchStat.upsert({
     *   create: {
     *     // ... data to create a PlayerMatchStat
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the PlayerMatchStat we want to update
     *   }
     * })
     */
    upsert<T extends PlayerMatchStatUpsertArgs>(args: SelectSubset<T, PlayerMatchStatUpsertArgs<ExtArgs>>): Prisma__PlayerMatchStatClient<$Result.GetResult<Prisma.$PlayerMatchStatPayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>


    /**
     * Count the number of PlayerMatchStats.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {PlayerMatchStatCountArgs} args - Arguments to filter PlayerMatchStats to count.
     * @example
     * // Count the number of PlayerMatchStats
     * const count = await prisma.playerMatchStat.count({
     *   where: {
     *     // ... the filter for the PlayerMatchStats we want to count
     *   }
     * })
    **/
    count<T extends PlayerMatchStatCountArgs>(
      args?: Subset<T, PlayerMatchStatCountArgs>,
    ): Prisma.PrismaPromise<
      T extends $Utils.Record<'select', any>
        ? T['select'] extends true
          ? number
          : GetScalarType<T['select'], PlayerMatchStatCountAggregateOutputType>
        : number
    >

    /**
     * Allows you to perform aggregations operations on a PlayerMatchStat.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {PlayerMatchStatAggregateArgs} 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 PlayerMatchStatAggregateArgs>(args: Subset<T, PlayerMatchStatAggregateArgs>): Prisma.PrismaPromise<GetPlayerMatchStatAggregateType<T>>

    /**
     * Group by PlayerMatchStat.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {PlayerMatchStatGroupByArgs} 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 PlayerMatchStatGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: PlayerMatchStatGroupByArgs['orderBy'] }
        : { orderBy?: PlayerMatchStatGroupByArgs['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, PlayerMatchStatGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetPlayerMatchStatGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the PlayerMatchStat model
   */
  readonly fields: PlayerMatchStatFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for PlayerMatchStat.
   * 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__PlayerMatchStatClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    player<T extends PlayerDefaultArgs<ExtArgs> = {}>(args?: Subset<T, PlayerDefaultArgs<ExtArgs>>): Prisma__PlayerClient<$Result.GetResult<Prisma.$PlayerPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
    match<T extends MatchDefaultArgs<ExtArgs> = {}>(args?: Subset<T, MatchDefaultArgs<ExtArgs>>): Prisma__MatchClient<$Result.GetResult<Prisma.$MatchPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
    /**
     * 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 PlayerMatchStat model
   */
  interface PlayerMatchStatFieldRefs {
    readonly id: FieldRef<"PlayerMatchStat", 'String'>
    readonly playerId: FieldRef<"PlayerMatchStat", 'String'>
    readonly matchId: FieldRef<"PlayerMatchStat", 'String'>
    readonly goals: FieldRef<"PlayerMatchStat", 'Int'>
    readonly assists: FieldRef<"PlayerMatchStat", 'Int'>
    readonly yellowCards: FieldRef<"PlayerMatchStat", 'Int'>
    readonly redCards: FieldRef<"PlayerMatchStat", 'Int'>
    readonly minutesPlayed: FieldRef<"PlayerMatchStat", 'Int'>
    readonly cleanSheet: FieldRef<"PlayerMatchStat", 'Boolean'>
    readonly penaltySaved: FieldRef<"PlayerMatchStat", 'Int'>
    readonly penaltyMissed: FieldRef<"PlayerMatchStat", 'Int'>
    readonly ownGoals: FieldRef<"PlayerMatchStat", 'Int'>
    readonly isMotm: FieldRef<"PlayerMatchStat", 'Boolean'>
    readonly extraTimeBonus: FieldRef<"PlayerMatchStat", 'Int'>
    readonly points: FieldRef<"PlayerMatchStat", 'Int'>
  }
    

  // Custom InputTypes
  /**
   * PlayerMatchStat findUnique
   */
  export type PlayerMatchStatFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PlayerMatchStat
     */
    select?: PlayerMatchStatSelect<ExtArgs> | null
    /**
     * Omit specific fields from the PlayerMatchStat
     */
    omit?: PlayerMatchStatOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PlayerMatchStatInclude<ExtArgs> | null
    /**
     * Filter, which PlayerMatchStat to fetch.
     */
    where: PlayerMatchStatWhereUniqueInput
  }

  /**
   * PlayerMatchStat findUniqueOrThrow
   */
  export type PlayerMatchStatFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PlayerMatchStat
     */
    select?: PlayerMatchStatSelect<ExtArgs> | null
    /**
     * Omit specific fields from the PlayerMatchStat
     */
    omit?: PlayerMatchStatOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PlayerMatchStatInclude<ExtArgs> | null
    /**
     * Filter, which PlayerMatchStat to fetch.
     */
    where: PlayerMatchStatWhereUniqueInput
  }

  /**
   * PlayerMatchStat findFirst
   */
  export type PlayerMatchStatFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PlayerMatchStat
     */
    select?: PlayerMatchStatSelect<ExtArgs> | null
    /**
     * Omit specific fields from the PlayerMatchStat
     */
    omit?: PlayerMatchStatOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PlayerMatchStatInclude<ExtArgs> | null
    /**
     * Filter, which PlayerMatchStat to fetch.
     */
    where?: PlayerMatchStatWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of PlayerMatchStats to fetch.
     */
    orderBy?: PlayerMatchStatOrderByWithRelationInput | PlayerMatchStatOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for PlayerMatchStats.
     */
    cursor?: PlayerMatchStatWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` PlayerMatchStats 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` PlayerMatchStats.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of PlayerMatchStats.
     */
    distinct?: PlayerMatchStatScalarFieldEnum | PlayerMatchStatScalarFieldEnum[]
  }

  /**
   * PlayerMatchStat findFirstOrThrow
   */
  export type PlayerMatchStatFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PlayerMatchStat
     */
    select?: PlayerMatchStatSelect<ExtArgs> | null
    /**
     * Omit specific fields from the PlayerMatchStat
     */
    omit?: PlayerMatchStatOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PlayerMatchStatInclude<ExtArgs> | null
    /**
     * Filter, which PlayerMatchStat to fetch.
     */
    where?: PlayerMatchStatWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of PlayerMatchStats to fetch.
     */
    orderBy?: PlayerMatchStatOrderByWithRelationInput | PlayerMatchStatOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for PlayerMatchStats.
     */
    cursor?: PlayerMatchStatWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` PlayerMatchStats 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` PlayerMatchStats.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of PlayerMatchStats.
     */
    distinct?: PlayerMatchStatScalarFieldEnum | PlayerMatchStatScalarFieldEnum[]
  }

  /**
   * PlayerMatchStat findMany
   */
  export type PlayerMatchStatFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PlayerMatchStat
     */
    select?: PlayerMatchStatSelect<ExtArgs> | null
    /**
     * Omit specific fields from the PlayerMatchStat
     */
    omit?: PlayerMatchStatOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PlayerMatchStatInclude<ExtArgs> | null
    /**
     * Filter, which PlayerMatchStats to fetch.
     */
    where?: PlayerMatchStatWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of PlayerMatchStats to fetch.
     */
    orderBy?: PlayerMatchStatOrderByWithRelationInput | PlayerMatchStatOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing PlayerMatchStats.
     */
    cursor?: PlayerMatchStatWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` PlayerMatchStats 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` PlayerMatchStats.
     */
    skip?: number
    distinct?: PlayerMatchStatScalarFieldEnum | PlayerMatchStatScalarFieldEnum[]
  }

  /**
   * PlayerMatchStat create
   */
  export type PlayerMatchStatCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PlayerMatchStat
     */
    select?: PlayerMatchStatSelect<ExtArgs> | null
    /**
     * Omit specific fields from the PlayerMatchStat
     */
    omit?: PlayerMatchStatOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PlayerMatchStatInclude<ExtArgs> | null
    /**
     * The data needed to create a PlayerMatchStat.
     */
    data: XOR<PlayerMatchStatCreateInput, PlayerMatchStatUncheckedCreateInput>
  }

  /**
   * PlayerMatchStat createMany
   */
  export type PlayerMatchStatCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many PlayerMatchStats.
     */
    data: PlayerMatchStatCreateManyInput | PlayerMatchStatCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * PlayerMatchStat createManyAndReturn
   */
  export type PlayerMatchStatCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PlayerMatchStat
     */
    select?: PlayerMatchStatSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the PlayerMatchStat
     */
    omit?: PlayerMatchStatOmit<ExtArgs> | null
    /**
     * The data used to create many PlayerMatchStats.
     */
    data: PlayerMatchStatCreateManyInput | PlayerMatchStatCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PlayerMatchStatIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * PlayerMatchStat update
   */
  export type PlayerMatchStatUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PlayerMatchStat
     */
    select?: PlayerMatchStatSelect<ExtArgs> | null
    /**
     * Omit specific fields from the PlayerMatchStat
     */
    omit?: PlayerMatchStatOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PlayerMatchStatInclude<ExtArgs> | null
    /**
     * The data needed to update a PlayerMatchStat.
     */
    data: XOR<PlayerMatchStatUpdateInput, PlayerMatchStatUncheckedUpdateInput>
    /**
     * Choose, which PlayerMatchStat to update.
     */
    where: PlayerMatchStatWhereUniqueInput
  }

  /**
   * PlayerMatchStat updateMany
   */
  export type PlayerMatchStatUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update PlayerMatchStats.
     */
    data: XOR<PlayerMatchStatUpdateManyMutationInput, PlayerMatchStatUncheckedUpdateManyInput>
    /**
     * Filter which PlayerMatchStats to update
     */
    where?: PlayerMatchStatWhereInput
    /**
     * Limit how many PlayerMatchStats to update.
     */
    limit?: number
  }

  /**
   * PlayerMatchStat updateManyAndReturn
   */
  export type PlayerMatchStatUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PlayerMatchStat
     */
    select?: PlayerMatchStatSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the PlayerMatchStat
     */
    omit?: PlayerMatchStatOmit<ExtArgs> | null
    /**
     * The data used to update PlayerMatchStats.
     */
    data: XOR<PlayerMatchStatUpdateManyMutationInput, PlayerMatchStatUncheckedUpdateManyInput>
    /**
     * Filter which PlayerMatchStats to update
     */
    where?: PlayerMatchStatWhereInput
    /**
     * Limit how many PlayerMatchStats to update.
     */
    limit?: number
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PlayerMatchStatIncludeUpdateManyAndReturn<ExtArgs> | null
  }

  /**
   * PlayerMatchStat upsert
   */
  export type PlayerMatchStatUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PlayerMatchStat
     */
    select?: PlayerMatchStatSelect<ExtArgs> | null
    /**
     * Omit specific fields from the PlayerMatchStat
     */
    omit?: PlayerMatchStatOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PlayerMatchStatInclude<ExtArgs> | null
    /**
     * The filter to search for the PlayerMatchStat to update in case it exists.
     */
    where: PlayerMatchStatWhereUniqueInput
    /**
     * In case the PlayerMatchStat found by the `where` argument doesn't exist, create a new PlayerMatchStat with this data.
     */
    create: XOR<PlayerMatchStatCreateInput, PlayerMatchStatUncheckedCreateInput>
    /**
     * In case the PlayerMatchStat was found with the provided `where` argument, update it with this data.
     */
    update: XOR<PlayerMatchStatUpdateInput, PlayerMatchStatUncheckedUpdateInput>
  }

  /**
   * PlayerMatchStat delete
   */
  export type PlayerMatchStatDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PlayerMatchStat
     */
    select?: PlayerMatchStatSelect<ExtArgs> | null
    /**
     * Omit specific fields from the PlayerMatchStat
     */
    omit?: PlayerMatchStatOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PlayerMatchStatInclude<ExtArgs> | null
    /**
     * Filter which PlayerMatchStat to delete.
     */
    where: PlayerMatchStatWhereUniqueInput
  }

  /**
   * PlayerMatchStat deleteMany
   */
  export type PlayerMatchStatDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which PlayerMatchStats to delete
     */
    where?: PlayerMatchStatWhereInput
    /**
     * Limit how many PlayerMatchStats to delete.
     */
    limit?: number
  }

  /**
   * PlayerMatchStat without action
   */
  export type PlayerMatchStatDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PlayerMatchStat
     */
    select?: PlayerMatchStatSelect<ExtArgs> | null
    /**
     * Omit specific fields from the PlayerMatchStat
     */
    omit?: PlayerMatchStatOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PlayerMatchStatInclude<ExtArgs> | null
  }


  /**
   * Model ScoringRule
   */

  export type AggregateScoringRule = {
    _count: ScoringRuleCountAggregateOutputType | null
    _avg: ScoringRuleAvgAggregateOutputType | null
    _sum: ScoringRuleSumAggregateOutputType | null
    _min: ScoringRuleMinAggregateOutputType | null
    _max: ScoringRuleMaxAggregateOutputType | null
  }

  export type ScoringRuleAvgAggregateOutputType = {
    points: number | null
  }

  export type ScoringRuleSumAggregateOutputType = {
    points: number | null
  }

  export type ScoringRuleMinAggregateOutputType = {
    id: string | null
    position: $Enums.Position | null
    eventType: $Enums.EventType | null
    points: number | null
    updatedAt: Date | null
    updatedBy: string | null
  }

  export type ScoringRuleMaxAggregateOutputType = {
    id: string | null
    position: $Enums.Position | null
    eventType: $Enums.EventType | null
    points: number | null
    updatedAt: Date | null
    updatedBy: string | null
  }

  export type ScoringRuleCountAggregateOutputType = {
    id: number
    position: number
    eventType: number
    points: number
    updatedAt: number
    updatedBy: number
    _all: number
  }


  export type ScoringRuleAvgAggregateInputType = {
    points?: true
  }

  export type ScoringRuleSumAggregateInputType = {
    points?: true
  }

  export type ScoringRuleMinAggregateInputType = {
    id?: true
    position?: true
    eventType?: true
    points?: true
    updatedAt?: true
    updatedBy?: true
  }

  export type ScoringRuleMaxAggregateInputType = {
    id?: true
    position?: true
    eventType?: true
    points?: true
    updatedAt?: true
    updatedBy?: true
  }

  export type ScoringRuleCountAggregateInputType = {
    id?: true
    position?: true
    eventType?: true
    points?: true
    updatedAt?: true
    updatedBy?: true
    _all?: true
  }

  export type ScoringRuleAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which ScoringRule to aggregate.
     */
    where?: ScoringRuleWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of ScoringRules to fetch.
     */
    orderBy?: ScoringRuleOrderByWithRelationInput | ScoringRuleOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: ScoringRuleWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` ScoringRules 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` ScoringRules.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned ScoringRules
    **/
    _count?: true | ScoringRuleCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: ScoringRuleAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: ScoringRuleSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: ScoringRuleMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: ScoringRuleMaxAggregateInputType
  }

  export type GetScoringRuleAggregateType<T extends ScoringRuleAggregateArgs> = {
        [P in keyof T & keyof AggregateScoringRule]: P extends '_count' | 'count'
      ? T[P] extends true
        ? number
        : GetScalarType<T[P], AggregateScoringRule[P]>
      : GetScalarType<T[P], AggregateScoringRule[P]>
  }




  export type ScoringRuleGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: ScoringRuleWhereInput
    orderBy?: ScoringRuleOrderByWithAggregationInput | ScoringRuleOrderByWithAggregationInput[]
    by: ScoringRuleScalarFieldEnum[] | ScoringRuleScalarFieldEnum
    having?: ScoringRuleScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: ScoringRuleCountAggregateInputType | true
    _avg?: ScoringRuleAvgAggregateInputType
    _sum?: ScoringRuleSumAggregateInputType
    _min?: ScoringRuleMinAggregateInputType
    _max?: ScoringRuleMaxAggregateInputType
  }

  export type ScoringRuleGroupByOutputType = {
    id: string
    position: $Enums.Position
    eventType: $Enums.EventType
    points: number
    updatedAt: Date
    updatedBy: string | null
    _count: ScoringRuleCountAggregateOutputType | null
    _avg: ScoringRuleAvgAggregateOutputType | null
    _sum: ScoringRuleSumAggregateOutputType | null
    _min: ScoringRuleMinAggregateOutputType | null
    _max: ScoringRuleMaxAggregateOutputType | null
  }

  type GetScoringRuleGroupByPayload<T extends ScoringRuleGroupByArgs> = Prisma.PrismaPromise<
    Array<
      PickEnumerable<ScoringRuleGroupByOutputType, T['by']> &
        {
          [P in ((keyof T) & (keyof ScoringRuleGroupByOutputType))]: P extends '_count'
            ? T[P] extends boolean
              ? number
              : GetScalarType<T[P], ScoringRuleGroupByOutputType[P]>
            : GetScalarType<T[P], ScoringRuleGroupByOutputType[P]>
        }
      >
    >


  export type ScoringRuleSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    position?: boolean
    eventType?: boolean
    points?: boolean
    updatedAt?: boolean
    updatedBy?: boolean
  }, ExtArgs["result"]["scoringRule"]>

  export type ScoringRuleSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    position?: boolean
    eventType?: boolean
    points?: boolean
    updatedAt?: boolean
    updatedBy?: boolean
  }, ExtArgs["result"]["scoringRule"]>

  export type ScoringRuleSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    position?: boolean
    eventType?: boolean
    points?: boolean
    updatedAt?: boolean
    updatedBy?: boolean
  }, ExtArgs["result"]["scoringRule"]>

  export type ScoringRuleSelectScalar = {
    id?: boolean
    position?: boolean
    eventType?: boolean
    points?: boolean
    updatedAt?: boolean
    updatedBy?: boolean
  }

  export type ScoringRuleOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "position" | "eventType" | "points" | "updatedAt" | "updatedBy", ExtArgs["result"]["scoringRule"]>

  export type $ScoringRulePayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "ScoringRule"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: string
      position: $Enums.Position
      eventType: $Enums.EventType
      points: number
      updatedAt: Date
      updatedBy: string | null
    }, ExtArgs["result"]["scoringRule"]>
    composites: {}
  }

  type ScoringRuleGetPayload<S extends boolean | null | undefined | ScoringRuleDefaultArgs> = $Result.GetResult<Prisma.$ScoringRulePayload, S>

  type ScoringRuleCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
    Omit<ScoringRuleFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
      select?: ScoringRuleCountAggregateInputType | true
    }

  export interface ScoringRuleDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> {
    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['ScoringRule'], meta: { name: 'ScoringRule' } }
    /**
     * Find zero or one ScoringRule that matches the filter.
     * @param {ScoringRuleFindUniqueArgs} args - Arguments to find a ScoringRule
     * @example
     * // Get one ScoringRule
     * const scoringRule = await prisma.scoringRule.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUnique<T extends ScoringRuleFindUniqueArgs>(args: SelectSubset<T, ScoringRuleFindUniqueArgs<ExtArgs>>): Prisma__ScoringRuleClient<$Result.GetResult<Prisma.$ScoringRulePayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find one ScoringRule that matches the filter or throw an error with `error.code='P2025'`
     * if no matches were found.
     * @param {ScoringRuleFindUniqueOrThrowArgs} args - Arguments to find a ScoringRule
     * @example
     * // Get one ScoringRule
     * const scoringRule = await prisma.scoringRule.findUniqueOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUniqueOrThrow<T extends ScoringRuleFindUniqueOrThrowArgs>(args: SelectSubset<T, ScoringRuleFindUniqueOrThrowArgs<ExtArgs>>): Prisma__ScoringRuleClient<$Result.GetResult<Prisma.$ScoringRulePayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first ScoringRule 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 {ScoringRuleFindFirstArgs} args - Arguments to find a ScoringRule
     * @example
     * // Get one ScoringRule
     * const scoringRule = await prisma.scoringRule.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends ScoringRuleFindFirstArgs>(args?: SelectSubset<T, ScoringRuleFindFirstArgs<ExtArgs>>): Prisma__ScoringRuleClient<$Result.GetResult<Prisma.$ScoringRulePayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first ScoringRule 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 {ScoringRuleFindFirstOrThrowArgs} args - Arguments to find a ScoringRule
     * @example
     * // Get one ScoringRule
     * const scoringRule = await prisma.scoringRule.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends ScoringRuleFindFirstOrThrowArgs>(args?: SelectSubset<T, ScoringRuleFindFirstOrThrowArgs<ExtArgs>>): Prisma__ScoringRuleClient<$Result.GetResult<Prisma.$ScoringRulePayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find zero or more ScoringRules 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 {ScoringRuleFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all ScoringRules
     * const scoringRules = await prisma.scoringRule.findMany()
     * 
     * // Get first 10 ScoringRules
     * const scoringRules = await prisma.scoringRule.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const scoringRuleWithIdOnly = await prisma.scoringRule.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends ScoringRuleFindManyArgs>(args?: SelectSubset<T, ScoringRuleFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ScoringRulePayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>

    /**
     * Create a ScoringRule.
     * @param {ScoringRuleCreateArgs} args - Arguments to create a ScoringRule.
     * @example
     * // Create one ScoringRule
     * const ScoringRule = await prisma.scoringRule.create({
     *   data: {
     *     // ... data to create a ScoringRule
     *   }
     * })
     * 
     */
    create<T extends ScoringRuleCreateArgs>(args: SelectSubset<T, ScoringRuleCreateArgs<ExtArgs>>): Prisma__ScoringRuleClient<$Result.GetResult<Prisma.$ScoringRulePayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Create many ScoringRules.
     * @param {ScoringRuleCreateManyArgs} args - Arguments to create many ScoringRules.
     * @example
     * // Create many ScoringRules
     * const scoringRule = await prisma.scoringRule.createMany({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     *     
     */
    createMany<T extends ScoringRuleCreateManyArgs>(args?: SelectSubset<T, ScoringRuleCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create many ScoringRules and returns the data saved in the database.
     * @param {ScoringRuleCreateManyAndReturnArgs} args - Arguments to create many ScoringRules.
     * @example
     * // Create many ScoringRules
     * const scoringRule = await prisma.scoringRule.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many ScoringRules and only return the `id`
     * const scoringRuleWithIdOnly = await prisma.scoringRule.createManyAndReturn({
     *   select: { id: true },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    createManyAndReturn<T extends ScoringRuleCreateManyAndReturnArgs>(args?: SelectSubset<T, ScoringRuleCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ScoringRulePayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>

    /**
     * Delete a ScoringRule.
     * @param {ScoringRuleDeleteArgs} args - Arguments to delete one ScoringRule.
     * @example
     * // Delete one ScoringRule
     * const ScoringRule = await prisma.scoringRule.delete({
     *   where: {
     *     // ... filter to delete one ScoringRule
     *   }
     * })
     * 
     */
    delete<T extends ScoringRuleDeleteArgs>(args: SelectSubset<T, ScoringRuleDeleteArgs<ExtArgs>>): Prisma__ScoringRuleClient<$Result.GetResult<Prisma.$ScoringRulePayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Update one ScoringRule.
     * @param {ScoringRuleUpdateArgs} args - Arguments to update one ScoringRule.
     * @example
     * // Update one ScoringRule
     * const scoringRule = await prisma.scoringRule.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends ScoringRuleUpdateArgs>(args: SelectSubset<T, ScoringRuleUpdateArgs<ExtArgs>>): Prisma__ScoringRuleClient<$Result.GetResult<Prisma.$ScoringRulePayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Delete zero or more ScoringRules.
     * @param {ScoringRuleDeleteManyArgs} args - Arguments to filter ScoringRules to delete.
     * @example
     * // Delete a few ScoringRules
     * const { count } = await prisma.scoringRule.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
     */
    deleteMany<T extends ScoringRuleDeleteManyArgs>(args?: SelectSubset<T, ScoringRuleDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more ScoringRules.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {ScoringRuleUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many ScoringRules
     * const scoringRule = await prisma.scoringRule.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    updateMany<T extends ScoringRuleUpdateManyArgs>(args: SelectSubset<T, ScoringRuleUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more ScoringRules and returns the data updated in the database.
     * @param {ScoringRuleUpdateManyAndReturnArgs} args - Arguments to update many ScoringRules.
     * @example
     * // Update many ScoringRules
     * const scoringRule = await prisma.scoringRule.updateManyAndReturn({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Update zero or more ScoringRules and only return the `id`
     * const scoringRuleWithIdOnly = await prisma.scoringRule.updateManyAndReturn({
     *   select: { id: true },
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    updateManyAndReturn<T extends ScoringRuleUpdateManyAndReturnArgs>(args: SelectSubset<T, ScoringRuleUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ScoringRulePayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>

    /**
     * Create or update one ScoringRule.
     * @param {ScoringRuleUpsertArgs} args - Arguments to update or create a ScoringRule.
     * @example
     * // Update or create a ScoringRule
     * const scoringRule = await prisma.scoringRule.upsert({
     *   create: {
     *     // ... data to create a ScoringRule
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the ScoringRule we want to update
     *   }
     * })
     */
    upsert<T extends ScoringRuleUpsertArgs>(args: SelectSubset<T, ScoringRuleUpsertArgs<ExtArgs>>): Prisma__ScoringRuleClient<$Result.GetResult<Prisma.$ScoringRulePayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>


    /**
     * Count the number of ScoringRules.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {ScoringRuleCountArgs} args - Arguments to filter ScoringRules to count.
     * @example
     * // Count the number of ScoringRules
     * const count = await prisma.scoringRule.count({
     *   where: {
     *     // ... the filter for the ScoringRules we want to count
     *   }
     * })
    **/
    count<T extends ScoringRuleCountArgs>(
      args?: Subset<T, ScoringRuleCountArgs>,
    ): Prisma.PrismaPromise<
      T extends $Utils.Record<'select', any>
        ? T['select'] extends true
          ? number
          : GetScalarType<T['select'], ScoringRuleCountAggregateOutputType>
        : number
    >

    /**
     * Allows you to perform aggregations operations on a ScoringRule.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {ScoringRuleAggregateArgs} 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 ScoringRuleAggregateArgs>(args: Subset<T, ScoringRuleAggregateArgs>): Prisma.PrismaPromise<GetScoringRuleAggregateType<T>>

    /**
     * Group by ScoringRule.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {ScoringRuleGroupByArgs} 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 ScoringRuleGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: ScoringRuleGroupByArgs['orderBy'] }
        : { orderBy?: ScoringRuleGroupByArgs['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, ScoringRuleGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetScoringRuleGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the ScoringRule model
   */
  readonly fields: ScoringRuleFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for ScoringRule.
   * 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__ScoringRuleClient<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 ScoringRule model
   */
  interface ScoringRuleFieldRefs {
    readonly id: FieldRef<"ScoringRule", 'String'>
    readonly position: FieldRef<"ScoringRule", 'Position'>
    readonly eventType: FieldRef<"ScoringRule", 'EventType'>
    readonly points: FieldRef<"ScoringRule", 'Int'>
    readonly updatedAt: FieldRef<"ScoringRule", 'DateTime'>
    readonly updatedBy: FieldRef<"ScoringRule", 'String'>
  }
    

  // Custom InputTypes
  /**
   * ScoringRule findUnique
   */
  export type ScoringRuleFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ScoringRule
     */
    select?: ScoringRuleSelect<ExtArgs> | null
    /**
     * Omit specific fields from the ScoringRule
     */
    omit?: ScoringRuleOmit<ExtArgs> | null
    /**
     * Filter, which ScoringRule to fetch.
     */
    where: ScoringRuleWhereUniqueInput
  }

  /**
   * ScoringRule findUniqueOrThrow
   */
  export type ScoringRuleFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ScoringRule
     */
    select?: ScoringRuleSelect<ExtArgs> | null
    /**
     * Omit specific fields from the ScoringRule
     */
    omit?: ScoringRuleOmit<ExtArgs> | null
    /**
     * Filter, which ScoringRule to fetch.
     */
    where: ScoringRuleWhereUniqueInput
  }

  /**
   * ScoringRule findFirst
   */
  export type ScoringRuleFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ScoringRule
     */
    select?: ScoringRuleSelect<ExtArgs> | null
    /**
     * Omit specific fields from the ScoringRule
     */
    omit?: ScoringRuleOmit<ExtArgs> | null
    /**
     * Filter, which ScoringRule to fetch.
     */
    where?: ScoringRuleWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of ScoringRules to fetch.
     */
    orderBy?: ScoringRuleOrderByWithRelationInput | ScoringRuleOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for ScoringRules.
     */
    cursor?: ScoringRuleWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` ScoringRules 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` ScoringRules.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of ScoringRules.
     */
    distinct?: ScoringRuleScalarFieldEnum | ScoringRuleScalarFieldEnum[]
  }

  /**
   * ScoringRule findFirstOrThrow
   */
  export type ScoringRuleFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ScoringRule
     */
    select?: ScoringRuleSelect<ExtArgs> | null
    /**
     * Omit specific fields from the ScoringRule
     */
    omit?: ScoringRuleOmit<ExtArgs> | null
    /**
     * Filter, which ScoringRule to fetch.
     */
    where?: ScoringRuleWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of ScoringRules to fetch.
     */
    orderBy?: ScoringRuleOrderByWithRelationInput | ScoringRuleOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for ScoringRules.
     */
    cursor?: ScoringRuleWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` ScoringRules 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` ScoringRules.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of ScoringRules.
     */
    distinct?: ScoringRuleScalarFieldEnum | ScoringRuleScalarFieldEnum[]
  }

  /**
   * ScoringRule findMany
   */
  export type ScoringRuleFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ScoringRule
     */
    select?: ScoringRuleSelect<ExtArgs> | null
    /**
     * Omit specific fields from the ScoringRule
     */
    omit?: ScoringRuleOmit<ExtArgs> | null
    /**
     * Filter, which ScoringRules to fetch.
     */
    where?: ScoringRuleWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of ScoringRules to fetch.
     */
    orderBy?: ScoringRuleOrderByWithRelationInput | ScoringRuleOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing ScoringRules.
     */
    cursor?: ScoringRuleWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` ScoringRules 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` ScoringRules.
     */
    skip?: number
    distinct?: ScoringRuleScalarFieldEnum | ScoringRuleScalarFieldEnum[]
  }

  /**
   * ScoringRule create
   */
  export type ScoringRuleCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ScoringRule
     */
    select?: ScoringRuleSelect<ExtArgs> | null
    /**
     * Omit specific fields from the ScoringRule
     */
    omit?: ScoringRuleOmit<ExtArgs> | null
    /**
     * The data needed to create a ScoringRule.
     */
    data: XOR<ScoringRuleCreateInput, ScoringRuleUncheckedCreateInput>
  }

  /**
   * ScoringRule createMany
   */
  export type ScoringRuleCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many ScoringRules.
     */
    data: ScoringRuleCreateManyInput | ScoringRuleCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * ScoringRule createManyAndReturn
   */
  export type ScoringRuleCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ScoringRule
     */
    select?: ScoringRuleSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the ScoringRule
     */
    omit?: ScoringRuleOmit<ExtArgs> | null
    /**
     * The data used to create many ScoringRules.
     */
    data: ScoringRuleCreateManyInput | ScoringRuleCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * ScoringRule update
   */
  export type ScoringRuleUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ScoringRule
     */
    select?: ScoringRuleSelect<ExtArgs> | null
    /**
     * Omit specific fields from the ScoringRule
     */
    omit?: ScoringRuleOmit<ExtArgs> | null
    /**
     * The data needed to update a ScoringRule.
     */
    data: XOR<ScoringRuleUpdateInput, ScoringRuleUncheckedUpdateInput>
    /**
     * Choose, which ScoringRule to update.
     */
    where: ScoringRuleWhereUniqueInput
  }

  /**
   * ScoringRule updateMany
   */
  export type ScoringRuleUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update ScoringRules.
     */
    data: XOR<ScoringRuleUpdateManyMutationInput, ScoringRuleUncheckedUpdateManyInput>
    /**
     * Filter which ScoringRules to update
     */
    where?: ScoringRuleWhereInput
    /**
     * Limit how many ScoringRules to update.
     */
    limit?: number
  }

  /**
   * ScoringRule updateManyAndReturn
   */
  export type ScoringRuleUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ScoringRule
     */
    select?: ScoringRuleSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the ScoringRule
     */
    omit?: ScoringRuleOmit<ExtArgs> | null
    /**
     * The data used to update ScoringRules.
     */
    data: XOR<ScoringRuleUpdateManyMutationInput, ScoringRuleUncheckedUpdateManyInput>
    /**
     * Filter which ScoringRules to update
     */
    where?: ScoringRuleWhereInput
    /**
     * Limit how many ScoringRules to update.
     */
    limit?: number
  }

  /**
   * ScoringRule upsert
   */
  export type ScoringRuleUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ScoringRule
     */
    select?: ScoringRuleSelect<ExtArgs> | null
    /**
     * Omit specific fields from the ScoringRule
     */
    omit?: ScoringRuleOmit<ExtArgs> | null
    /**
     * The filter to search for the ScoringRule to update in case it exists.
     */
    where: ScoringRuleWhereUniqueInput
    /**
     * In case the ScoringRule found by the `where` argument doesn't exist, create a new ScoringRule with this data.
     */
    create: XOR<ScoringRuleCreateInput, ScoringRuleUncheckedCreateInput>
    /**
     * In case the ScoringRule was found with the provided `where` argument, update it with this data.
     */
    update: XOR<ScoringRuleUpdateInput, ScoringRuleUncheckedUpdateInput>
  }

  /**
   * ScoringRule delete
   */
  export type ScoringRuleDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ScoringRule
     */
    select?: ScoringRuleSelect<ExtArgs> | null
    /**
     * Omit specific fields from the ScoringRule
     */
    omit?: ScoringRuleOmit<ExtArgs> | null
    /**
     * Filter which ScoringRule to delete.
     */
    where: ScoringRuleWhereUniqueInput
  }

  /**
   * ScoringRule deleteMany
   */
  export type ScoringRuleDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which ScoringRules to delete
     */
    where?: ScoringRuleWhereInput
    /**
     * Limit how many ScoringRules to delete.
     */
    limit?: number
  }

  /**
   * ScoringRule without action
   */
  export type ScoringRuleDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ScoringRule
     */
    select?: ScoringRuleSelect<ExtArgs> | null
    /**
     * Omit specific fields from the ScoringRule
     */
    omit?: ScoringRuleOmit<ExtArgs> | null
  }


  /**
   * Model User
   */

  export type AggregateUser = {
    _count: UserCountAggregateOutputType | null
    _min: UserMinAggregateOutputType | null
    _max: UserMaxAggregateOutputType | null
  }

  export type UserMinAggregateOutputType = {
    id: string | null
    name: string | null
    email: string | null
    phone: string | null
    password: string | null
    role: $Enums.Role | null
    createdAt: Date | null
  }

  export type UserMaxAggregateOutputType = {
    id: string | null
    name: string | null
    email: string | null
    phone: string | null
    password: string | null
    role: $Enums.Role | null
    createdAt: Date | null
  }

  export type UserCountAggregateOutputType = {
    id: number
    name: number
    email: number
    phone: number
    password: number
    role: number
    createdAt: number
    _all: number
  }


  export type UserMinAggregateInputType = {
    id?: true
    name?: true
    email?: true
    phone?: true
    password?: true
    role?: true
    createdAt?: true
  }

  export type UserMaxAggregateInputType = {
    id?: true
    name?: true
    email?: true
    phone?: true
    password?: true
    role?: true
    createdAt?: true
  }

  export type UserCountAggregateInputType = {
    id?: true
    name?: true
    email?: true
    phone?: true
    password?: true
    role?: true
    createdAt?: 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 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 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 = {
    id: string
    name: string | null
    email: string
    phone: string | null
    password: string
    role: $Enums.Role
    createdAt: Date
    _count: UserCountAggregateOutputType | null
    _min: UserMinAggregateOutputType | null
    _max: UserMaxAggregateOutputType | null
  }

  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 UserSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
    email?: boolean
    phone?: boolean
    password?: boolean
    role?: boolean
    createdAt?: boolean
    team?: boolean | User$teamArgs<ExtArgs>
    sessions?: boolean | User$sessionsArgs<ExtArgs>
    payments?: boolean | User$paymentsArgs<ExtArgs>
    quizSubmissions?: boolean | User$quizSubmissionsArgs<ExtArgs>
    goldenCards?: boolean | User$goldenCardsArgs<ExtArgs>
    _count?: boolean | UserCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["user"]>

  export type UserSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
    email?: boolean
    phone?: boolean
    password?: boolean
    role?: boolean
    createdAt?: boolean
  }, ExtArgs["result"]["user"]>

  export type UserSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
    email?: boolean
    phone?: boolean
    password?: boolean
    role?: boolean
    createdAt?: boolean
  }, ExtArgs["result"]["user"]>

  export type UserSelectScalar = {
    id?: boolean
    name?: boolean
    email?: boolean
    phone?: boolean
    password?: boolean
    role?: boolean
    createdAt?: boolean
  }

  export type UserOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "name" | "email" | "phone" | "password" | "role" | "createdAt", ExtArgs["result"]["user"]>
  export type UserInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    team?: boolean | User$teamArgs<ExtArgs>
    sessions?: boolean | User$sessionsArgs<ExtArgs>
    payments?: boolean | User$paymentsArgs<ExtArgs>
    quizSubmissions?: boolean | User$quizSubmissionsArgs<ExtArgs>
    goldenCards?: boolean | User$goldenCardsArgs<ExtArgs>
    _count?: boolean | UserCountOutputTypeDefaultArgs<ExtArgs>
  }
  export type UserIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {}
  export type UserIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {}

  export type $UserPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "User"
    objects: {
      team: Prisma.$TeamPayload<ExtArgs> | null
      sessions: Prisma.$SessionPayload<ExtArgs>[]
      payments: Prisma.$PaymentPayload<ExtArgs>[]
      quizSubmissions: Prisma.$QuizSubmissionPayload<ExtArgs>[]
      goldenCards: Prisma.$GoldenCardPayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      name: string | null
      email: string
      phone: string | null
      password: string
      role: $Enums.Role
      createdAt: 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 `id`
     * const userWithIdOnly = await prisma.user.findMany({ select: { id: 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>

    /**
     * Create many Users and returns the data saved in the database.
     * @param {UserCreateManyAndReturnArgs} args - Arguments to create many Users.
     * @example
     * // Create many Users
     * const user = await prisma.user.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many Users and only return the `id`
     * const userWithIdOnly = await prisma.user.createManyAndReturn({
     *   select: { id: true },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    createManyAndReturn<T extends UserCreateManyAndReturnArgs>(args?: SelectSubset<T, UserCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>

    /**
     * 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>

    /**
     * Update zero or more Users and returns the data updated in the database.
     * @param {UserUpdateManyAndReturnArgs} args - Arguments to update many Users.
     * @example
     * // Update many Users
     * const user = await prisma.user.updateManyAndReturn({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Update zero or more Users and only return the `id`
     * const userWithIdOnly = await prisma.user.updateManyAndReturn({
     *   select: { id: true },
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    updateManyAndReturn<T extends UserUpdateManyAndReturnArgs>(args: SelectSubset<T, UserUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>

    /**
     * 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>


    /**
     * 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"
    team<T extends User$teamArgs<ExtArgs> = {}>(args?: Subset<T, User$teamArgs<ExtArgs>>): Prisma__TeamClient<$Result.GetResult<Prisma.$TeamPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
    sessions<T extends User$sessionsArgs<ExtArgs> = {}>(args?: Subset<T, User$sessionsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$SessionPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    payments<T extends User$paymentsArgs<ExtArgs> = {}>(args?: Subset<T, User$paymentsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$PaymentPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    quizSubmissions<T extends User$quizSubmissionsArgs<ExtArgs> = {}>(args?: Subset<T, User$quizSubmissionsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$QuizSubmissionPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    goldenCards<T extends User$goldenCardsArgs<ExtArgs> = {}>(args?: Subset<T, User$goldenCardsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$GoldenCardPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    /**
     * 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 id: FieldRef<"User", 'String'>
    readonly name: FieldRef<"User", 'String'>
    readonly email: FieldRef<"User", 'String'>
    readonly phone: FieldRef<"User", 'String'>
    readonly password: FieldRef<"User", 'String'>
    readonly role: FieldRef<"User", 'Role'>
    readonly createdAt: 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
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserInclude<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
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserInclude<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
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserInclude<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
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserInclude<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
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserInclude<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
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserInclude<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[]
    skipDuplicates?: boolean
  }

  /**
   * User createManyAndReturn
   */
  export type UserCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the User
     */
    select?: UserSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the User
     */
    omit?: UserOmit<ExtArgs> | null
    /**
     * The data used to create many Users.
     */
    data: UserCreateManyInput | UserCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * 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
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserInclude<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 updateManyAndReturn
   */
  export type UserUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the User
     */
    select?: UserSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the User
     */
    omit?: UserOmit<ExtArgs> | null
    /**
     * 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
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserInclude<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
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserInclude<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.team
   */
  export type User$teamArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Team
     */
    select?: TeamSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Team
     */
    omit?: TeamOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TeamInclude<ExtArgs> | null
    where?: TeamWhereInput
  }

  /**
   * User.sessions
   */
  export type User$sessionsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Session
     */
    select?: SessionSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Session
     */
    omit?: SessionOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SessionInclude<ExtArgs> | null
    where?: SessionWhereInput
    orderBy?: SessionOrderByWithRelationInput | SessionOrderByWithRelationInput[]
    cursor?: SessionWhereUniqueInput
    take?: number
    skip?: number
    distinct?: SessionScalarFieldEnum | SessionScalarFieldEnum[]
  }

  /**
   * User.payments
   */
  export type User$paymentsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Payment
     */
    select?: PaymentSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Payment
     */
    omit?: PaymentOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PaymentInclude<ExtArgs> | null
    where?: PaymentWhereInput
    orderBy?: PaymentOrderByWithRelationInput | PaymentOrderByWithRelationInput[]
    cursor?: PaymentWhereUniqueInput
    take?: number
    skip?: number
    distinct?: PaymentScalarFieldEnum | PaymentScalarFieldEnum[]
  }

  /**
   * User.quizSubmissions
   */
  export type User$quizSubmissionsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the QuizSubmission
     */
    select?: QuizSubmissionSelect<ExtArgs> | null
    /**
     * Omit specific fields from the QuizSubmission
     */
    omit?: QuizSubmissionOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: QuizSubmissionInclude<ExtArgs> | null
    where?: QuizSubmissionWhereInput
    orderBy?: QuizSubmissionOrderByWithRelationInput | QuizSubmissionOrderByWithRelationInput[]
    cursor?: QuizSubmissionWhereUniqueInput
    take?: number
    skip?: number
    distinct?: QuizSubmissionScalarFieldEnum | QuizSubmissionScalarFieldEnum[]
  }

  /**
   * User.goldenCards
   */
  export type User$goldenCardsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the GoldenCard
     */
    select?: GoldenCardSelect<ExtArgs> | null
    /**
     * Omit specific fields from the GoldenCard
     */
    omit?: GoldenCardOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: GoldenCardInclude<ExtArgs> | null
    where?: GoldenCardWhereInput
    orderBy?: GoldenCardOrderByWithRelationInput | GoldenCardOrderByWithRelationInput[]
    cursor?: GoldenCardWhereUniqueInput
    take?: number
    skip?: number
    distinct?: GoldenCardScalarFieldEnum | GoldenCardScalarFieldEnum[]
  }

  /**
   * 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
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserInclude<ExtArgs> | null
  }


  /**
   * Model LoginOtp
   */

  export type AggregateLoginOtp = {
    _count: LoginOtpCountAggregateOutputType | null
    _avg: LoginOtpAvgAggregateOutputType | null
    _sum: LoginOtpSumAggregateOutputType | null
    _min: LoginOtpMinAggregateOutputType | null
    _max: LoginOtpMaxAggregateOutputType | null
  }

  export type LoginOtpAvgAggregateOutputType = {
    attempts: number | null
  }

  export type LoginOtpSumAggregateOutputType = {
    attempts: number | null
  }

  export type LoginOtpMinAggregateOutputType = {
    id: string | null
    phone: string | null
    codeHash: string | null
    attempts: number | null
    expiresAt: Date | null
    consumedAt: Date | null
    createdAt: Date | null
  }

  export type LoginOtpMaxAggregateOutputType = {
    id: string | null
    phone: string | null
    codeHash: string | null
    attempts: number | null
    expiresAt: Date | null
    consumedAt: Date | null
    createdAt: Date | null
  }

  export type LoginOtpCountAggregateOutputType = {
    id: number
    phone: number
    codeHash: number
    attempts: number
    expiresAt: number
    consumedAt: number
    createdAt: number
    _all: number
  }


  export type LoginOtpAvgAggregateInputType = {
    attempts?: true
  }

  export type LoginOtpSumAggregateInputType = {
    attempts?: true
  }

  export type LoginOtpMinAggregateInputType = {
    id?: true
    phone?: true
    codeHash?: true
    attempts?: true
    expiresAt?: true
    consumedAt?: true
    createdAt?: true
  }

  export type LoginOtpMaxAggregateInputType = {
    id?: true
    phone?: true
    codeHash?: true
    attempts?: true
    expiresAt?: true
    consumedAt?: true
    createdAt?: true
  }

  export type LoginOtpCountAggregateInputType = {
    id?: true
    phone?: true
    codeHash?: true
    attempts?: true
    expiresAt?: true
    consumedAt?: true
    createdAt?: true
    _all?: true
  }

  export type LoginOtpAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which LoginOtp to aggregate.
     */
    where?: LoginOtpWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of LoginOtps to fetch.
     */
    orderBy?: LoginOtpOrderByWithRelationInput | LoginOtpOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: LoginOtpWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` LoginOtps 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` LoginOtps.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned LoginOtps
    **/
    _count?: true | LoginOtpCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: LoginOtpAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: LoginOtpSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: LoginOtpMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: LoginOtpMaxAggregateInputType
  }

  export type GetLoginOtpAggregateType<T extends LoginOtpAggregateArgs> = {
        [P in keyof T & keyof AggregateLoginOtp]: P extends '_count' | 'count'
      ? T[P] extends true
        ? number
        : GetScalarType<T[P], AggregateLoginOtp[P]>
      : GetScalarType<T[P], AggregateLoginOtp[P]>
  }




  export type LoginOtpGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: LoginOtpWhereInput
    orderBy?: LoginOtpOrderByWithAggregationInput | LoginOtpOrderByWithAggregationInput[]
    by: LoginOtpScalarFieldEnum[] | LoginOtpScalarFieldEnum
    having?: LoginOtpScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: LoginOtpCountAggregateInputType | true
    _avg?: LoginOtpAvgAggregateInputType
    _sum?: LoginOtpSumAggregateInputType
    _min?: LoginOtpMinAggregateInputType
    _max?: LoginOtpMaxAggregateInputType
  }

  export type LoginOtpGroupByOutputType = {
    id: string
    phone: string
    codeHash: string
    attempts: number
    expiresAt: Date
    consumedAt: Date | null
    createdAt: Date
    _count: LoginOtpCountAggregateOutputType | null
    _avg: LoginOtpAvgAggregateOutputType | null
    _sum: LoginOtpSumAggregateOutputType | null
    _min: LoginOtpMinAggregateOutputType | null
    _max: LoginOtpMaxAggregateOutputType | null
  }

  type GetLoginOtpGroupByPayload<T extends LoginOtpGroupByArgs> = Prisma.PrismaPromise<
    Array<
      PickEnumerable<LoginOtpGroupByOutputType, T['by']> &
        {
          [P in ((keyof T) & (keyof LoginOtpGroupByOutputType))]: P extends '_count'
            ? T[P] extends boolean
              ? number
              : GetScalarType<T[P], LoginOtpGroupByOutputType[P]>
            : GetScalarType<T[P], LoginOtpGroupByOutputType[P]>
        }
      >
    >


  export type LoginOtpSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    phone?: boolean
    codeHash?: boolean
    attempts?: boolean
    expiresAt?: boolean
    consumedAt?: boolean
    createdAt?: boolean
  }, ExtArgs["result"]["loginOtp"]>

  export type LoginOtpSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    phone?: boolean
    codeHash?: boolean
    attempts?: boolean
    expiresAt?: boolean
    consumedAt?: boolean
    createdAt?: boolean
  }, ExtArgs["result"]["loginOtp"]>

  export type LoginOtpSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    phone?: boolean
    codeHash?: boolean
    attempts?: boolean
    expiresAt?: boolean
    consumedAt?: boolean
    createdAt?: boolean
  }, ExtArgs["result"]["loginOtp"]>

  export type LoginOtpSelectScalar = {
    id?: boolean
    phone?: boolean
    codeHash?: boolean
    attempts?: boolean
    expiresAt?: boolean
    consumedAt?: boolean
    createdAt?: boolean
  }

  export type LoginOtpOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "phone" | "codeHash" | "attempts" | "expiresAt" | "consumedAt" | "createdAt", ExtArgs["result"]["loginOtp"]>

  export type $LoginOtpPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "LoginOtp"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: string
      phone: string
      codeHash: string
      attempts: number
      expiresAt: Date
      consumedAt: Date | null
      createdAt: Date
    }, ExtArgs["result"]["loginOtp"]>
    composites: {}
  }

  type LoginOtpGetPayload<S extends boolean | null | undefined | LoginOtpDefaultArgs> = $Result.GetResult<Prisma.$LoginOtpPayload, S>

  type LoginOtpCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
    Omit<LoginOtpFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
      select?: LoginOtpCountAggregateInputType | true
    }

  export interface LoginOtpDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> {
    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['LoginOtp'], meta: { name: 'LoginOtp' } }
    /**
     * Find zero or one LoginOtp that matches the filter.
     * @param {LoginOtpFindUniqueArgs} args - Arguments to find a LoginOtp
     * @example
     * // Get one LoginOtp
     * const loginOtp = await prisma.loginOtp.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUnique<T extends LoginOtpFindUniqueArgs>(args: SelectSubset<T, LoginOtpFindUniqueArgs<ExtArgs>>): Prisma__LoginOtpClient<$Result.GetResult<Prisma.$LoginOtpPayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find one LoginOtp that matches the filter or throw an error with `error.code='P2025'`
     * if no matches were found.
     * @param {LoginOtpFindUniqueOrThrowArgs} args - Arguments to find a LoginOtp
     * @example
     * // Get one LoginOtp
     * const loginOtp = await prisma.loginOtp.findUniqueOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUniqueOrThrow<T extends LoginOtpFindUniqueOrThrowArgs>(args: SelectSubset<T, LoginOtpFindUniqueOrThrowArgs<ExtArgs>>): Prisma__LoginOtpClient<$Result.GetResult<Prisma.$LoginOtpPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first LoginOtp 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 {LoginOtpFindFirstArgs} args - Arguments to find a LoginOtp
     * @example
     * // Get one LoginOtp
     * const loginOtp = await prisma.loginOtp.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends LoginOtpFindFirstArgs>(args?: SelectSubset<T, LoginOtpFindFirstArgs<ExtArgs>>): Prisma__LoginOtpClient<$Result.GetResult<Prisma.$LoginOtpPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first LoginOtp 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 {LoginOtpFindFirstOrThrowArgs} args - Arguments to find a LoginOtp
     * @example
     * // Get one LoginOtp
     * const loginOtp = await prisma.loginOtp.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends LoginOtpFindFirstOrThrowArgs>(args?: SelectSubset<T, LoginOtpFindFirstOrThrowArgs<ExtArgs>>): Prisma__LoginOtpClient<$Result.GetResult<Prisma.$LoginOtpPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find zero or more LoginOtps 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 {LoginOtpFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all LoginOtps
     * const loginOtps = await prisma.loginOtp.findMany()
     * 
     * // Get first 10 LoginOtps
     * const loginOtps = await prisma.loginOtp.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const loginOtpWithIdOnly = await prisma.loginOtp.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends LoginOtpFindManyArgs>(args?: SelectSubset<T, LoginOtpFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$LoginOtpPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>

    /**
     * Create a LoginOtp.
     * @param {LoginOtpCreateArgs} args - Arguments to create a LoginOtp.
     * @example
     * // Create one LoginOtp
     * const LoginOtp = await prisma.loginOtp.create({
     *   data: {
     *     // ... data to create a LoginOtp
     *   }
     * })
     * 
     */
    create<T extends LoginOtpCreateArgs>(args: SelectSubset<T, LoginOtpCreateArgs<ExtArgs>>): Prisma__LoginOtpClient<$Result.GetResult<Prisma.$LoginOtpPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Create many LoginOtps.
     * @param {LoginOtpCreateManyArgs} args - Arguments to create many LoginOtps.
     * @example
     * // Create many LoginOtps
     * const loginOtp = await prisma.loginOtp.createMany({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     *     
     */
    createMany<T extends LoginOtpCreateManyArgs>(args?: SelectSubset<T, LoginOtpCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create many LoginOtps and returns the data saved in the database.
     * @param {LoginOtpCreateManyAndReturnArgs} args - Arguments to create many LoginOtps.
     * @example
     * // Create many LoginOtps
     * const loginOtp = await prisma.loginOtp.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many LoginOtps and only return the `id`
     * const loginOtpWithIdOnly = await prisma.loginOtp.createManyAndReturn({
     *   select: { id: true },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    createManyAndReturn<T extends LoginOtpCreateManyAndReturnArgs>(args?: SelectSubset<T, LoginOtpCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$LoginOtpPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>

    /**
     * Delete a LoginOtp.
     * @param {LoginOtpDeleteArgs} args - Arguments to delete one LoginOtp.
     * @example
     * // Delete one LoginOtp
     * const LoginOtp = await prisma.loginOtp.delete({
     *   where: {
     *     // ... filter to delete one LoginOtp
     *   }
     * })
     * 
     */
    delete<T extends LoginOtpDeleteArgs>(args: SelectSubset<T, LoginOtpDeleteArgs<ExtArgs>>): Prisma__LoginOtpClient<$Result.GetResult<Prisma.$LoginOtpPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Update one LoginOtp.
     * @param {LoginOtpUpdateArgs} args - Arguments to update one LoginOtp.
     * @example
     * // Update one LoginOtp
     * const loginOtp = await prisma.loginOtp.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends LoginOtpUpdateArgs>(args: SelectSubset<T, LoginOtpUpdateArgs<ExtArgs>>): Prisma__LoginOtpClient<$Result.GetResult<Prisma.$LoginOtpPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Delete zero or more LoginOtps.
     * @param {LoginOtpDeleteManyArgs} args - Arguments to filter LoginOtps to delete.
     * @example
     * // Delete a few LoginOtps
     * const { count } = await prisma.loginOtp.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
     */
    deleteMany<T extends LoginOtpDeleteManyArgs>(args?: SelectSubset<T, LoginOtpDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more LoginOtps.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {LoginOtpUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many LoginOtps
     * const loginOtp = await prisma.loginOtp.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    updateMany<T extends LoginOtpUpdateManyArgs>(args: SelectSubset<T, LoginOtpUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more LoginOtps and returns the data updated in the database.
     * @param {LoginOtpUpdateManyAndReturnArgs} args - Arguments to update many LoginOtps.
     * @example
     * // Update many LoginOtps
     * const loginOtp = await prisma.loginOtp.updateManyAndReturn({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Update zero or more LoginOtps and only return the `id`
     * const loginOtpWithIdOnly = await prisma.loginOtp.updateManyAndReturn({
     *   select: { id: true },
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    updateManyAndReturn<T extends LoginOtpUpdateManyAndReturnArgs>(args: SelectSubset<T, LoginOtpUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$LoginOtpPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>

    /**
     * Create or update one LoginOtp.
     * @param {LoginOtpUpsertArgs} args - Arguments to update or create a LoginOtp.
     * @example
     * // Update or create a LoginOtp
     * const loginOtp = await prisma.loginOtp.upsert({
     *   create: {
     *     // ... data to create a LoginOtp
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the LoginOtp we want to update
     *   }
     * })
     */
    upsert<T extends LoginOtpUpsertArgs>(args: SelectSubset<T, LoginOtpUpsertArgs<ExtArgs>>): Prisma__LoginOtpClient<$Result.GetResult<Prisma.$LoginOtpPayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>


    /**
     * Count the number of LoginOtps.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {LoginOtpCountArgs} args - Arguments to filter LoginOtps to count.
     * @example
     * // Count the number of LoginOtps
     * const count = await prisma.loginOtp.count({
     *   where: {
     *     // ... the filter for the LoginOtps we want to count
     *   }
     * })
    **/
    count<T extends LoginOtpCountArgs>(
      args?: Subset<T, LoginOtpCountArgs>,
    ): Prisma.PrismaPromise<
      T extends $Utils.Record<'select', any>
        ? T['select'] extends true
          ? number
          : GetScalarType<T['select'], LoginOtpCountAggregateOutputType>
        : number
    >

    /**
     * Allows you to perform aggregations operations on a LoginOtp.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {LoginOtpAggregateArgs} 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 LoginOtpAggregateArgs>(args: Subset<T, LoginOtpAggregateArgs>): Prisma.PrismaPromise<GetLoginOtpAggregateType<T>>

    /**
     * Group by LoginOtp.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {LoginOtpGroupByArgs} 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 LoginOtpGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: LoginOtpGroupByArgs['orderBy'] }
        : { orderBy?: LoginOtpGroupByArgs['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, LoginOtpGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetLoginOtpGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the LoginOtp model
   */
  readonly fields: LoginOtpFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for LoginOtp.
   * 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__LoginOtpClient<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 LoginOtp model
   */
  interface LoginOtpFieldRefs {
    readonly id: FieldRef<"LoginOtp", 'String'>
    readonly phone: FieldRef<"LoginOtp", 'String'>
    readonly codeHash: FieldRef<"LoginOtp", 'String'>
    readonly attempts: FieldRef<"LoginOtp", 'Int'>
    readonly expiresAt: FieldRef<"LoginOtp", 'DateTime'>
    readonly consumedAt: FieldRef<"LoginOtp", 'DateTime'>
    readonly createdAt: FieldRef<"LoginOtp", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * LoginOtp findUnique
   */
  export type LoginOtpFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the LoginOtp
     */
    select?: LoginOtpSelect<ExtArgs> | null
    /**
     * Omit specific fields from the LoginOtp
     */
    omit?: LoginOtpOmit<ExtArgs> | null
    /**
     * Filter, which LoginOtp to fetch.
     */
    where: LoginOtpWhereUniqueInput
  }

  /**
   * LoginOtp findUniqueOrThrow
   */
  export type LoginOtpFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the LoginOtp
     */
    select?: LoginOtpSelect<ExtArgs> | null
    /**
     * Omit specific fields from the LoginOtp
     */
    omit?: LoginOtpOmit<ExtArgs> | null
    /**
     * Filter, which LoginOtp to fetch.
     */
    where: LoginOtpWhereUniqueInput
  }

  /**
   * LoginOtp findFirst
   */
  export type LoginOtpFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the LoginOtp
     */
    select?: LoginOtpSelect<ExtArgs> | null
    /**
     * Omit specific fields from the LoginOtp
     */
    omit?: LoginOtpOmit<ExtArgs> | null
    /**
     * Filter, which LoginOtp to fetch.
     */
    where?: LoginOtpWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of LoginOtps to fetch.
     */
    orderBy?: LoginOtpOrderByWithRelationInput | LoginOtpOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for LoginOtps.
     */
    cursor?: LoginOtpWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` LoginOtps 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` LoginOtps.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of LoginOtps.
     */
    distinct?: LoginOtpScalarFieldEnum | LoginOtpScalarFieldEnum[]
  }

  /**
   * LoginOtp findFirstOrThrow
   */
  export type LoginOtpFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the LoginOtp
     */
    select?: LoginOtpSelect<ExtArgs> | null
    /**
     * Omit specific fields from the LoginOtp
     */
    omit?: LoginOtpOmit<ExtArgs> | null
    /**
     * Filter, which LoginOtp to fetch.
     */
    where?: LoginOtpWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of LoginOtps to fetch.
     */
    orderBy?: LoginOtpOrderByWithRelationInput | LoginOtpOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for LoginOtps.
     */
    cursor?: LoginOtpWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` LoginOtps 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` LoginOtps.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of LoginOtps.
     */
    distinct?: LoginOtpScalarFieldEnum | LoginOtpScalarFieldEnum[]
  }

  /**
   * LoginOtp findMany
   */
  export type LoginOtpFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the LoginOtp
     */
    select?: LoginOtpSelect<ExtArgs> | null
    /**
     * Omit specific fields from the LoginOtp
     */
    omit?: LoginOtpOmit<ExtArgs> | null
    /**
     * Filter, which LoginOtps to fetch.
     */
    where?: LoginOtpWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of LoginOtps to fetch.
     */
    orderBy?: LoginOtpOrderByWithRelationInput | LoginOtpOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing LoginOtps.
     */
    cursor?: LoginOtpWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` LoginOtps 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` LoginOtps.
     */
    skip?: number
    distinct?: LoginOtpScalarFieldEnum | LoginOtpScalarFieldEnum[]
  }

  /**
   * LoginOtp create
   */
  export type LoginOtpCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the LoginOtp
     */
    select?: LoginOtpSelect<ExtArgs> | null
    /**
     * Omit specific fields from the LoginOtp
     */
    omit?: LoginOtpOmit<ExtArgs> | null
    /**
     * The data needed to create a LoginOtp.
     */
    data: XOR<LoginOtpCreateInput, LoginOtpUncheckedCreateInput>
  }

  /**
   * LoginOtp createMany
   */
  export type LoginOtpCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many LoginOtps.
     */
    data: LoginOtpCreateManyInput | LoginOtpCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * LoginOtp createManyAndReturn
   */
  export type LoginOtpCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the LoginOtp
     */
    select?: LoginOtpSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the LoginOtp
     */
    omit?: LoginOtpOmit<ExtArgs> | null
    /**
     * The data used to create many LoginOtps.
     */
    data: LoginOtpCreateManyInput | LoginOtpCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * LoginOtp update
   */
  export type LoginOtpUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the LoginOtp
     */
    select?: LoginOtpSelect<ExtArgs> | null
    /**
     * Omit specific fields from the LoginOtp
     */
    omit?: LoginOtpOmit<ExtArgs> | null
    /**
     * The data needed to update a LoginOtp.
     */
    data: XOR<LoginOtpUpdateInput, LoginOtpUncheckedUpdateInput>
    /**
     * Choose, which LoginOtp to update.
     */
    where: LoginOtpWhereUniqueInput
  }

  /**
   * LoginOtp updateMany
   */
  export type LoginOtpUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update LoginOtps.
     */
    data: XOR<LoginOtpUpdateManyMutationInput, LoginOtpUncheckedUpdateManyInput>
    /**
     * Filter which LoginOtps to update
     */
    where?: LoginOtpWhereInput
    /**
     * Limit how many LoginOtps to update.
     */
    limit?: number
  }

  /**
   * LoginOtp updateManyAndReturn
   */
  export type LoginOtpUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the LoginOtp
     */
    select?: LoginOtpSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the LoginOtp
     */
    omit?: LoginOtpOmit<ExtArgs> | null
    /**
     * The data used to update LoginOtps.
     */
    data: XOR<LoginOtpUpdateManyMutationInput, LoginOtpUncheckedUpdateManyInput>
    /**
     * Filter which LoginOtps to update
     */
    where?: LoginOtpWhereInput
    /**
     * Limit how many LoginOtps to update.
     */
    limit?: number
  }

  /**
   * LoginOtp upsert
   */
  export type LoginOtpUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the LoginOtp
     */
    select?: LoginOtpSelect<ExtArgs> | null
    /**
     * Omit specific fields from the LoginOtp
     */
    omit?: LoginOtpOmit<ExtArgs> | null
    /**
     * The filter to search for the LoginOtp to update in case it exists.
     */
    where: LoginOtpWhereUniqueInput
    /**
     * In case the LoginOtp found by the `where` argument doesn't exist, create a new LoginOtp with this data.
     */
    create: XOR<LoginOtpCreateInput, LoginOtpUncheckedCreateInput>
    /**
     * In case the LoginOtp was found with the provided `where` argument, update it with this data.
     */
    update: XOR<LoginOtpUpdateInput, LoginOtpUncheckedUpdateInput>
  }

  /**
   * LoginOtp delete
   */
  export type LoginOtpDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the LoginOtp
     */
    select?: LoginOtpSelect<ExtArgs> | null
    /**
     * Omit specific fields from the LoginOtp
     */
    omit?: LoginOtpOmit<ExtArgs> | null
    /**
     * Filter which LoginOtp to delete.
     */
    where: LoginOtpWhereUniqueInput
  }

  /**
   * LoginOtp deleteMany
   */
  export type LoginOtpDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which LoginOtps to delete
     */
    where?: LoginOtpWhereInput
    /**
     * Limit how many LoginOtps to delete.
     */
    limit?: number
  }

  /**
   * LoginOtp without action
   */
  export type LoginOtpDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the LoginOtp
     */
    select?: LoginOtpSelect<ExtArgs> | null
    /**
     * Omit specific fields from the LoginOtp
     */
    omit?: LoginOtpOmit<ExtArgs> | null
  }


  /**
   * Model FantasyNews
   */

  export type AggregateFantasyNews = {
    _count: FantasyNewsCountAggregateOutputType | null
    _min: FantasyNewsMinAggregateOutputType | null
    _max: FantasyNewsMaxAggregateOutputType | null
  }

  export type FantasyNewsMinAggregateOutputType = {
    id: string | null
    icon: string | null
    title: string | null
    description: string | null
    newsTime: Date | null
    createdAt: Date | null
    updatedAt: Date | null
  }

  export type FantasyNewsMaxAggregateOutputType = {
    id: string | null
    icon: string | null
    title: string | null
    description: string | null
    newsTime: Date | null
    createdAt: Date | null
    updatedAt: Date | null
  }

  export type FantasyNewsCountAggregateOutputType = {
    id: number
    icon: number
    title: number
    description: number
    newsTime: number
    createdAt: number
    updatedAt: number
    _all: number
  }


  export type FantasyNewsMinAggregateInputType = {
    id?: true
    icon?: true
    title?: true
    description?: true
    newsTime?: true
    createdAt?: true
    updatedAt?: true
  }

  export type FantasyNewsMaxAggregateInputType = {
    id?: true
    icon?: true
    title?: true
    description?: true
    newsTime?: true
    createdAt?: true
    updatedAt?: true
  }

  export type FantasyNewsCountAggregateInputType = {
    id?: true
    icon?: true
    title?: true
    description?: true
    newsTime?: true
    createdAt?: true
    updatedAt?: true
    _all?: true
  }

  export type FantasyNewsAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which FantasyNews to aggregate.
     */
    where?: FantasyNewsWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of FantasyNews to fetch.
     */
    orderBy?: FantasyNewsOrderByWithRelationInput | FantasyNewsOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: FantasyNewsWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` FantasyNews 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` FantasyNews.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned FantasyNews
    **/
    _count?: true | FantasyNewsCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: FantasyNewsMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: FantasyNewsMaxAggregateInputType
  }

  export type GetFantasyNewsAggregateType<T extends FantasyNewsAggregateArgs> = {
        [P in keyof T & keyof AggregateFantasyNews]: P extends '_count' | 'count'
      ? T[P] extends true
        ? number
        : GetScalarType<T[P], AggregateFantasyNews[P]>
      : GetScalarType<T[P], AggregateFantasyNews[P]>
  }




  export type FantasyNewsGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: FantasyNewsWhereInput
    orderBy?: FantasyNewsOrderByWithAggregationInput | FantasyNewsOrderByWithAggregationInput[]
    by: FantasyNewsScalarFieldEnum[] | FantasyNewsScalarFieldEnum
    having?: FantasyNewsScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: FantasyNewsCountAggregateInputType | true
    _min?: FantasyNewsMinAggregateInputType
    _max?: FantasyNewsMaxAggregateInputType
  }

  export type FantasyNewsGroupByOutputType = {
    id: string
    icon: string
    title: string
    description: string
    newsTime: Date
    createdAt: Date
    updatedAt: Date
    _count: FantasyNewsCountAggregateOutputType | null
    _min: FantasyNewsMinAggregateOutputType | null
    _max: FantasyNewsMaxAggregateOutputType | null
  }

  type GetFantasyNewsGroupByPayload<T extends FantasyNewsGroupByArgs> = Prisma.PrismaPromise<
    Array<
      PickEnumerable<FantasyNewsGroupByOutputType, T['by']> &
        {
          [P in ((keyof T) & (keyof FantasyNewsGroupByOutputType))]: P extends '_count'
            ? T[P] extends boolean
              ? number
              : GetScalarType<T[P], FantasyNewsGroupByOutputType[P]>
            : GetScalarType<T[P], FantasyNewsGroupByOutputType[P]>
        }
      >
    >


  export type FantasyNewsSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    icon?: boolean
    title?: boolean
    description?: boolean
    newsTime?: boolean
    createdAt?: boolean
    updatedAt?: boolean
  }, ExtArgs["result"]["fantasyNews"]>

  export type FantasyNewsSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    icon?: boolean
    title?: boolean
    description?: boolean
    newsTime?: boolean
    createdAt?: boolean
    updatedAt?: boolean
  }, ExtArgs["result"]["fantasyNews"]>

  export type FantasyNewsSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    icon?: boolean
    title?: boolean
    description?: boolean
    newsTime?: boolean
    createdAt?: boolean
    updatedAt?: boolean
  }, ExtArgs["result"]["fantasyNews"]>

  export type FantasyNewsSelectScalar = {
    id?: boolean
    icon?: boolean
    title?: boolean
    description?: boolean
    newsTime?: boolean
    createdAt?: boolean
    updatedAt?: boolean
  }

  export type FantasyNewsOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "icon" | "title" | "description" | "newsTime" | "createdAt" | "updatedAt", ExtArgs["result"]["fantasyNews"]>

  export type $FantasyNewsPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "FantasyNews"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: string
      icon: string
      title: string
      description: string
      newsTime: Date
      createdAt: Date
      updatedAt: Date
    }, ExtArgs["result"]["fantasyNews"]>
    composites: {}
  }

  type FantasyNewsGetPayload<S extends boolean | null | undefined | FantasyNewsDefaultArgs> = $Result.GetResult<Prisma.$FantasyNewsPayload, S>

  type FantasyNewsCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
    Omit<FantasyNewsFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
      select?: FantasyNewsCountAggregateInputType | true
    }

  export interface FantasyNewsDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> {
    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['FantasyNews'], meta: { name: 'FantasyNews' } }
    /**
     * Find zero or one FantasyNews that matches the filter.
     * @param {FantasyNewsFindUniqueArgs} args - Arguments to find a FantasyNews
     * @example
     * // Get one FantasyNews
     * const fantasyNews = await prisma.fantasyNews.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUnique<T extends FantasyNewsFindUniqueArgs>(args: SelectSubset<T, FantasyNewsFindUniqueArgs<ExtArgs>>): Prisma__FantasyNewsClient<$Result.GetResult<Prisma.$FantasyNewsPayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find one FantasyNews that matches the filter or throw an error with `error.code='P2025'`
     * if no matches were found.
     * @param {FantasyNewsFindUniqueOrThrowArgs} args - Arguments to find a FantasyNews
     * @example
     * // Get one FantasyNews
     * const fantasyNews = await prisma.fantasyNews.findUniqueOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUniqueOrThrow<T extends FantasyNewsFindUniqueOrThrowArgs>(args: SelectSubset<T, FantasyNewsFindUniqueOrThrowArgs<ExtArgs>>): Prisma__FantasyNewsClient<$Result.GetResult<Prisma.$FantasyNewsPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first FantasyNews 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 {FantasyNewsFindFirstArgs} args - Arguments to find a FantasyNews
     * @example
     * // Get one FantasyNews
     * const fantasyNews = await prisma.fantasyNews.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends FantasyNewsFindFirstArgs>(args?: SelectSubset<T, FantasyNewsFindFirstArgs<ExtArgs>>): Prisma__FantasyNewsClient<$Result.GetResult<Prisma.$FantasyNewsPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first FantasyNews 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 {FantasyNewsFindFirstOrThrowArgs} args - Arguments to find a FantasyNews
     * @example
     * // Get one FantasyNews
     * const fantasyNews = await prisma.fantasyNews.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends FantasyNewsFindFirstOrThrowArgs>(args?: SelectSubset<T, FantasyNewsFindFirstOrThrowArgs<ExtArgs>>): Prisma__FantasyNewsClient<$Result.GetResult<Prisma.$FantasyNewsPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find zero or more FantasyNews 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 {FantasyNewsFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all FantasyNews
     * const fantasyNews = await prisma.fantasyNews.findMany()
     * 
     * // Get first 10 FantasyNews
     * const fantasyNews = await prisma.fantasyNews.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const fantasyNewsWithIdOnly = await prisma.fantasyNews.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends FantasyNewsFindManyArgs>(args?: SelectSubset<T, FantasyNewsFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$FantasyNewsPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>

    /**
     * Create a FantasyNews.
     * @param {FantasyNewsCreateArgs} args - Arguments to create a FantasyNews.
     * @example
     * // Create one FantasyNews
     * const FantasyNews = await prisma.fantasyNews.create({
     *   data: {
     *     // ... data to create a FantasyNews
     *   }
     * })
     * 
     */
    create<T extends FantasyNewsCreateArgs>(args: SelectSubset<T, FantasyNewsCreateArgs<ExtArgs>>): Prisma__FantasyNewsClient<$Result.GetResult<Prisma.$FantasyNewsPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Create many FantasyNews.
     * @param {FantasyNewsCreateManyArgs} args - Arguments to create many FantasyNews.
     * @example
     * // Create many FantasyNews
     * const fantasyNews = await prisma.fantasyNews.createMany({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     *     
     */
    createMany<T extends FantasyNewsCreateManyArgs>(args?: SelectSubset<T, FantasyNewsCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create many FantasyNews and returns the data saved in the database.
     * @param {FantasyNewsCreateManyAndReturnArgs} args - Arguments to create many FantasyNews.
     * @example
     * // Create many FantasyNews
     * const fantasyNews = await prisma.fantasyNews.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many FantasyNews and only return the `id`
     * const fantasyNewsWithIdOnly = await prisma.fantasyNews.createManyAndReturn({
     *   select: { id: true },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    createManyAndReturn<T extends FantasyNewsCreateManyAndReturnArgs>(args?: SelectSubset<T, FantasyNewsCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$FantasyNewsPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>

    /**
     * Delete a FantasyNews.
     * @param {FantasyNewsDeleteArgs} args - Arguments to delete one FantasyNews.
     * @example
     * // Delete one FantasyNews
     * const FantasyNews = await prisma.fantasyNews.delete({
     *   where: {
     *     // ... filter to delete one FantasyNews
     *   }
     * })
     * 
     */
    delete<T extends FantasyNewsDeleteArgs>(args: SelectSubset<T, FantasyNewsDeleteArgs<ExtArgs>>): Prisma__FantasyNewsClient<$Result.GetResult<Prisma.$FantasyNewsPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Update one FantasyNews.
     * @param {FantasyNewsUpdateArgs} args - Arguments to update one FantasyNews.
     * @example
     * // Update one FantasyNews
     * const fantasyNews = await prisma.fantasyNews.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends FantasyNewsUpdateArgs>(args: SelectSubset<T, FantasyNewsUpdateArgs<ExtArgs>>): Prisma__FantasyNewsClient<$Result.GetResult<Prisma.$FantasyNewsPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Delete zero or more FantasyNews.
     * @param {FantasyNewsDeleteManyArgs} args - Arguments to filter FantasyNews to delete.
     * @example
     * // Delete a few FantasyNews
     * const { count } = await prisma.fantasyNews.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
     */
    deleteMany<T extends FantasyNewsDeleteManyArgs>(args?: SelectSubset<T, FantasyNewsDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more FantasyNews.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {FantasyNewsUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many FantasyNews
     * const fantasyNews = await prisma.fantasyNews.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    updateMany<T extends FantasyNewsUpdateManyArgs>(args: SelectSubset<T, FantasyNewsUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more FantasyNews and returns the data updated in the database.
     * @param {FantasyNewsUpdateManyAndReturnArgs} args - Arguments to update many FantasyNews.
     * @example
     * // Update many FantasyNews
     * const fantasyNews = await prisma.fantasyNews.updateManyAndReturn({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Update zero or more FantasyNews and only return the `id`
     * const fantasyNewsWithIdOnly = await prisma.fantasyNews.updateManyAndReturn({
     *   select: { id: true },
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    updateManyAndReturn<T extends FantasyNewsUpdateManyAndReturnArgs>(args: SelectSubset<T, FantasyNewsUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$FantasyNewsPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>

    /**
     * Create or update one FantasyNews.
     * @param {FantasyNewsUpsertArgs} args - Arguments to update or create a FantasyNews.
     * @example
     * // Update or create a FantasyNews
     * const fantasyNews = await prisma.fantasyNews.upsert({
     *   create: {
     *     // ... data to create a FantasyNews
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the FantasyNews we want to update
     *   }
     * })
     */
    upsert<T extends FantasyNewsUpsertArgs>(args: SelectSubset<T, FantasyNewsUpsertArgs<ExtArgs>>): Prisma__FantasyNewsClient<$Result.GetResult<Prisma.$FantasyNewsPayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>


    /**
     * Count the number of FantasyNews.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {FantasyNewsCountArgs} args - Arguments to filter FantasyNews to count.
     * @example
     * // Count the number of FantasyNews
     * const count = await prisma.fantasyNews.count({
     *   where: {
     *     // ... the filter for the FantasyNews we want to count
     *   }
     * })
    **/
    count<T extends FantasyNewsCountArgs>(
      args?: Subset<T, FantasyNewsCountArgs>,
    ): Prisma.PrismaPromise<
      T extends $Utils.Record<'select', any>
        ? T['select'] extends true
          ? number
          : GetScalarType<T['select'], FantasyNewsCountAggregateOutputType>
        : number
    >

    /**
     * Allows you to perform aggregations operations on a FantasyNews.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {FantasyNewsAggregateArgs} 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 FantasyNewsAggregateArgs>(args: Subset<T, FantasyNewsAggregateArgs>): Prisma.PrismaPromise<GetFantasyNewsAggregateType<T>>

    /**
     * Group by FantasyNews.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {FantasyNewsGroupByArgs} 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 FantasyNewsGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: FantasyNewsGroupByArgs['orderBy'] }
        : { orderBy?: FantasyNewsGroupByArgs['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, FantasyNewsGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetFantasyNewsGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the FantasyNews model
   */
  readonly fields: FantasyNewsFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for FantasyNews.
   * 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__FantasyNewsClient<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 FantasyNews model
   */
  interface FantasyNewsFieldRefs {
    readonly id: FieldRef<"FantasyNews", 'String'>
    readonly icon: FieldRef<"FantasyNews", 'String'>
    readonly title: FieldRef<"FantasyNews", 'String'>
    readonly description: FieldRef<"FantasyNews", 'String'>
    readonly newsTime: FieldRef<"FantasyNews", 'DateTime'>
    readonly createdAt: FieldRef<"FantasyNews", 'DateTime'>
    readonly updatedAt: FieldRef<"FantasyNews", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * FantasyNews findUnique
   */
  export type FantasyNewsFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the FantasyNews
     */
    select?: FantasyNewsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the FantasyNews
     */
    omit?: FantasyNewsOmit<ExtArgs> | null
    /**
     * Filter, which FantasyNews to fetch.
     */
    where: FantasyNewsWhereUniqueInput
  }

  /**
   * FantasyNews findUniqueOrThrow
   */
  export type FantasyNewsFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the FantasyNews
     */
    select?: FantasyNewsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the FantasyNews
     */
    omit?: FantasyNewsOmit<ExtArgs> | null
    /**
     * Filter, which FantasyNews to fetch.
     */
    where: FantasyNewsWhereUniqueInput
  }

  /**
   * FantasyNews findFirst
   */
  export type FantasyNewsFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the FantasyNews
     */
    select?: FantasyNewsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the FantasyNews
     */
    omit?: FantasyNewsOmit<ExtArgs> | null
    /**
     * Filter, which FantasyNews to fetch.
     */
    where?: FantasyNewsWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of FantasyNews to fetch.
     */
    orderBy?: FantasyNewsOrderByWithRelationInput | FantasyNewsOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for FantasyNews.
     */
    cursor?: FantasyNewsWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` FantasyNews 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` FantasyNews.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of FantasyNews.
     */
    distinct?: FantasyNewsScalarFieldEnum | FantasyNewsScalarFieldEnum[]
  }

  /**
   * FantasyNews findFirstOrThrow
   */
  export type FantasyNewsFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the FantasyNews
     */
    select?: FantasyNewsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the FantasyNews
     */
    omit?: FantasyNewsOmit<ExtArgs> | null
    /**
     * Filter, which FantasyNews to fetch.
     */
    where?: FantasyNewsWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of FantasyNews to fetch.
     */
    orderBy?: FantasyNewsOrderByWithRelationInput | FantasyNewsOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for FantasyNews.
     */
    cursor?: FantasyNewsWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` FantasyNews 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` FantasyNews.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of FantasyNews.
     */
    distinct?: FantasyNewsScalarFieldEnum | FantasyNewsScalarFieldEnum[]
  }

  /**
   * FantasyNews findMany
   */
  export type FantasyNewsFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the FantasyNews
     */
    select?: FantasyNewsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the FantasyNews
     */
    omit?: FantasyNewsOmit<ExtArgs> | null
    /**
     * Filter, which FantasyNews to fetch.
     */
    where?: FantasyNewsWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of FantasyNews to fetch.
     */
    orderBy?: FantasyNewsOrderByWithRelationInput | FantasyNewsOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing FantasyNews.
     */
    cursor?: FantasyNewsWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` FantasyNews 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` FantasyNews.
     */
    skip?: number
    distinct?: FantasyNewsScalarFieldEnum | FantasyNewsScalarFieldEnum[]
  }

  /**
   * FantasyNews create
   */
  export type FantasyNewsCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the FantasyNews
     */
    select?: FantasyNewsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the FantasyNews
     */
    omit?: FantasyNewsOmit<ExtArgs> | null
    /**
     * The data needed to create a FantasyNews.
     */
    data: XOR<FantasyNewsCreateInput, FantasyNewsUncheckedCreateInput>
  }

  /**
   * FantasyNews createMany
   */
  export type FantasyNewsCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many FantasyNews.
     */
    data: FantasyNewsCreateManyInput | FantasyNewsCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * FantasyNews createManyAndReturn
   */
  export type FantasyNewsCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the FantasyNews
     */
    select?: FantasyNewsSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the FantasyNews
     */
    omit?: FantasyNewsOmit<ExtArgs> | null
    /**
     * The data used to create many FantasyNews.
     */
    data: FantasyNewsCreateManyInput | FantasyNewsCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * FantasyNews update
   */
  export type FantasyNewsUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the FantasyNews
     */
    select?: FantasyNewsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the FantasyNews
     */
    omit?: FantasyNewsOmit<ExtArgs> | null
    /**
     * The data needed to update a FantasyNews.
     */
    data: XOR<FantasyNewsUpdateInput, FantasyNewsUncheckedUpdateInput>
    /**
     * Choose, which FantasyNews to update.
     */
    where: FantasyNewsWhereUniqueInput
  }

  /**
   * FantasyNews updateMany
   */
  export type FantasyNewsUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update FantasyNews.
     */
    data: XOR<FantasyNewsUpdateManyMutationInput, FantasyNewsUncheckedUpdateManyInput>
    /**
     * Filter which FantasyNews to update
     */
    where?: FantasyNewsWhereInput
    /**
     * Limit how many FantasyNews to update.
     */
    limit?: number
  }

  /**
   * FantasyNews updateManyAndReturn
   */
  export type FantasyNewsUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the FantasyNews
     */
    select?: FantasyNewsSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the FantasyNews
     */
    omit?: FantasyNewsOmit<ExtArgs> | null
    /**
     * The data used to update FantasyNews.
     */
    data: XOR<FantasyNewsUpdateManyMutationInput, FantasyNewsUncheckedUpdateManyInput>
    /**
     * Filter which FantasyNews to update
     */
    where?: FantasyNewsWhereInput
    /**
     * Limit how many FantasyNews to update.
     */
    limit?: number
  }

  /**
   * FantasyNews upsert
   */
  export type FantasyNewsUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the FantasyNews
     */
    select?: FantasyNewsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the FantasyNews
     */
    omit?: FantasyNewsOmit<ExtArgs> | null
    /**
     * The filter to search for the FantasyNews to update in case it exists.
     */
    where: FantasyNewsWhereUniqueInput
    /**
     * In case the FantasyNews found by the `where` argument doesn't exist, create a new FantasyNews with this data.
     */
    create: XOR<FantasyNewsCreateInput, FantasyNewsUncheckedCreateInput>
    /**
     * In case the FantasyNews was found with the provided `where` argument, update it with this data.
     */
    update: XOR<FantasyNewsUpdateInput, FantasyNewsUncheckedUpdateInput>
  }

  /**
   * FantasyNews delete
   */
  export type FantasyNewsDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the FantasyNews
     */
    select?: FantasyNewsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the FantasyNews
     */
    omit?: FantasyNewsOmit<ExtArgs> | null
    /**
     * Filter which FantasyNews to delete.
     */
    where: FantasyNewsWhereUniqueInput
  }

  /**
   * FantasyNews deleteMany
   */
  export type FantasyNewsDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which FantasyNews to delete
     */
    where?: FantasyNewsWhereInput
    /**
     * Limit how many FantasyNews to delete.
     */
    limit?: number
  }

  /**
   * FantasyNews without action
   */
  export type FantasyNewsDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the FantasyNews
     */
    select?: FantasyNewsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the FantasyNews
     */
    omit?: FantasyNewsOmit<ExtArgs> | null
  }


  /**
   * Model DailyQuiz
   */

  export type AggregateDailyQuiz = {
    _count: DailyQuizCountAggregateOutputType | null
    _avg: DailyQuizAvgAggregateOutputType | null
    _sum: DailyQuizSumAggregateOutputType | null
    _min: DailyQuizMinAggregateOutputType | null
    _max: DailyQuizMaxAggregateOutputType | null
  }

  export type DailyQuizAvgAggregateOutputType = {
    goldWinnersCount: number | null
    silverWinnersCount: number | null
    bronzeWinnersCount: number | null
    goldMinCorrect: number | null
    silverMinCorrect: number | null
    bronzeMinCorrect: number | null
  }

  export type DailyQuizSumAggregateOutputType = {
    goldWinnersCount: number | null
    silverWinnersCount: number | null
    bronzeWinnersCount: number | null
    goldMinCorrect: number | null
    silverMinCorrect: number | null
    bronzeMinCorrect: number | null
  }

  export type DailyQuizMinAggregateOutputType = {
    id: string | null
    date: Date | null
    windowStart: Date | null
    windowEnd: Date | null
    goldWinnersCount: number | null
    silverWinnersCount: number | null
    bronzeWinnersCount: number | null
    goldMinCorrect: number | null
    silverMinCorrect: number | null
    bronzeMinCorrect: number | null
    isProcessed: boolean | null
    createdAt: Date | null
  }

  export type DailyQuizMaxAggregateOutputType = {
    id: string | null
    date: Date | null
    windowStart: Date | null
    windowEnd: Date | null
    goldWinnersCount: number | null
    silverWinnersCount: number | null
    bronzeWinnersCount: number | null
    goldMinCorrect: number | null
    silverMinCorrect: number | null
    bronzeMinCorrect: number | null
    isProcessed: boolean | null
    createdAt: Date | null
  }

  export type DailyQuizCountAggregateOutputType = {
    id: number
    date: number
    windowStart: number
    windowEnd: number
    goldWinnersCount: number
    silverWinnersCount: number
    bronzeWinnersCount: number
    goldMinCorrect: number
    silverMinCorrect: number
    bronzeMinCorrect: number
    isProcessed: number
    createdAt: number
    _all: number
  }


  export type DailyQuizAvgAggregateInputType = {
    goldWinnersCount?: true
    silverWinnersCount?: true
    bronzeWinnersCount?: true
    goldMinCorrect?: true
    silverMinCorrect?: true
    bronzeMinCorrect?: true
  }

  export type DailyQuizSumAggregateInputType = {
    goldWinnersCount?: true
    silverWinnersCount?: true
    bronzeWinnersCount?: true
    goldMinCorrect?: true
    silverMinCorrect?: true
    bronzeMinCorrect?: true
  }

  export type DailyQuizMinAggregateInputType = {
    id?: true
    date?: true
    windowStart?: true
    windowEnd?: true
    goldWinnersCount?: true
    silverWinnersCount?: true
    bronzeWinnersCount?: true
    goldMinCorrect?: true
    silverMinCorrect?: true
    bronzeMinCorrect?: true
    isProcessed?: true
    createdAt?: true
  }

  export type DailyQuizMaxAggregateInputType = {
    id?: true
    date?: true
    windowStart?: true
    windowEnd?: true
    goldWinnersCount?: true
    silverWinnersCount?: true
    bronzeWinnersCount?: true
    goldMinCorrect?: true
    silverMinCorrect?: true
    bronzeMinCorrect?: true
    isProcessed?: true
    createdAt?: true
  }

  export type DailyQuizCountAggregateInputType = {
    id?: true
    date?: true
    windowStart?: true
    windowEnd?: true
    goldWinnersCount?: true
    silverWinnersCount?: true
    bronzeWinnersCount?: true
    goldMinCorrect?: true
    silverMinCorrect?: true
    bronzeMinCorrect?: true
    isProcessed?: true
    createdAt?: true
    _all?: true
  }

  export type DailyQuizAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which DailyQuiz to aggregate.
     */
    where?: DailyQuizWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of DailyQuizs to fetch.
     */
    orderBy?: DailyQuizOrderByWithRelationInput | DailyQuizOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: DailyQuizWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` DailyQuizs 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` DailyQuizs.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned DailyQuizs
    **/
    _count?: true | DailyQuizCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: DailyQuizAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: DailyQuizSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: DailyQuizMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: DailyQuizMaxAggregateInputType
  }

  export type GetDailyQuizAggregateType<T extends DailyQuizAggregateArgs> = {
        [P in keyof T & keyof AggregateDailyQuiz]: P extends '_count' | 'count'
      ? T[P] extends true
        ? number
        : GetScalarType<T[P], AggregateDailyQuiz[P]>
      : GetScalarType<T[P], AggregateDailyQuiz[P]>
  }




  export type DailyQuizGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: DailyQuizWhereInput
    orderBy?: DailyQuizOrderByWithAggregationInput | DailyQuizOrderByWithAggregationInput[]
    by: DailyQuizScalarFieldEnum[] | DailyQuizScalarFieldEnum
    having?: DailyQuizScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: DailyQuizCountAggregateInputType | true
    _avg?: DailyQuizAvgAggregateInputType
    _sum?: DailyQuizSumAggregateInputType
    _min?: DailyQuizMinAggregateInputType
    _max?: DailyQuizMaxAggregateInputType
  }

  export type DailyQuizGroupByOutputType = {
    id: string
    date: Date
    windowStart: Date
    windowEnd: Date
    goldWinnersCount: number
    silverWinnersCount: number
    bronzeWinnersCount: number
    goldMinCorrect: number | null
    silverMinCorrect: number | null
    bronzeMinCorrect: number | null
    isProcessed: boolean
    createdAt: Date
    _count: DailyQuizCountAggregateOutputType | null
    _avg: DailyQuizAvgAggregateOutputType | null
    _sum: DailyQuizSumAggregateOutputType | null
    _min: DailyQuizMinAggregateOutputType | null
    _max: DailyQuizMaxAggregateOutputType | null
  }

  type GetDailyQuizGroupByPayload<T extends DailyQuizGroupByArgs> = Prisma.PrismaPromise<
    Array<
      PickEnumerable<DailyQuizGroupByOutputType, T['by']> &
        {
          [P in ((keyof T) & (keyof DailyQuizGroupByOutputType))]: P extends '_count'
            ? T[P] extends boolean
              ? number
              : GetScalarType<T[P], DailyQuizGroupByOutputType[P]>
            : GetScalarType<T[P], DailyQuizGroupByOutputType[P]>
        }
      >
    >


  export type DailyQuizSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    date?: boolean
    windowStart?: boolean
    windowEnd?: boolean
    goldWinnersCount?: boolean
    silverWinnersCount?: boolean
    bronzeWinnersCount?: boolean
    goldMinCorrect?: boolean
    silverMinCorrect?: boolean
    bronzeMinCorrect?: boolean
    isProcessed?: boolean
    createdAt?: boolean
    questions?: boolean | DailyQuiz$questionsArgs<ExtArgs>
    submissions?: boolean | DailyQuiz$submissionsArgs<ExtArgs>
    awardedCards?: boolean | DailyQuiz$awardedCardsArgs<ExtArgs>
    _count?: boolean | DailyQuizCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["dailyQuiz"]>

  export type DailyQuizSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    date?: boolean
    windowStart?: boolean
    windowEnd?: boolean
    goldWinnersCount?: boolean
    silverWinnersCount?: boolean
    bronzeWinnersCount?: boolean
    goldMinCorrect?: boolean
    silverMinCorrect?: boolean
    bronzeMinCorrect?: boolean
    isProcessed?: boolean
    createdAt?: boolean
  }, ExtArgs["result"]["dailyQuiz"]>

  export type DailyQuizSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    date?: boolean
    windowStart?: boolean
    windowEnd?: boolean
    goldWinnersCount?: boolean
    silverWinnersCount?: boolean
    bronzeWinnersCount?: boolean
    goldMinCorrect?: boolean
    silverMinCorrect?: boolean
    bronzeMinCorrect?: boolean
    isProcessed?: boolean
    createdAt?: boolean
  }, ExtArgs["result"]["dailyQuiz"]>

  export type DailyQuizSelectScalar = {
    id?: boolean
    date?: boolean
    windowStart?: boolean
    windowEnd?: boolean
    goldWinnersCount?: boolean
    silverWinnersCount?: boolean
    bronzeWinnersCount?: boolean
    goldMinCorrect?: boolean
    silverMinCorrect?: boolean
    bronzeMinCorrect?: boolean
    isProcessed?: boolean
    createdAt?: boolean
  }

  export type DailyQuizOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "date" | "windowStart" | "windowEnd" | "goldWinnersCount" | "silverWinnersCount" | "bronzeWinnersCount" | "goldMinCorrect" | "silverMinCorrect" | "bronzeMinCorrect" | "isProcessed" | "createdAt", ExtArgs["result"]["dailyQuiz"]>
  export type DailyQuizInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    questions?: boolean | DailyQuiz$questionsArgs<ExtArgs>
    submissions?: boolean | DailyQuiz$submissionsArgs<ExtArgs>
    awardedCards?: boolean | DailyQuiz$awardedCardsArgs<ExtArgs>
    _count?: boolean | DailyQuizCountOutputTypeDefaultArgs<ExtArgs>
  }
  export type DailyQuizIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {}
  export type DailyQuizIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {}

  export type $DailyQuizPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "DailyQuiz"
    objects: {
      questions: Prisma.$QuizQuestionPayload<ExtArgs>[]
      submissions: Prisma.$QuizSubmissionPayload<ExtArgs>[]
      awardedCards: Prisma.$GoldenCardPayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      date: Date
      windowStart: Date
      windowEnd: Date
      goldWinnersCount: number
      silverWinnersCount: number
      bronzeWinnersCount: number
      goldMinCorrect: number | null
      silverMinCorrect: number | null
      bronzeMinCorrect: number | null
      isProcessed: boolean
      createdAt: Date
    }, ExtArgs["result"]["dailyQuiz"]>
    composites: {}
  }

  type DailyQuizGetPayload<S extends boolean | null | undefined | DailyQuizDefaultArgs> = $Result.GetResult<Prisma.$DailyQuizPayload, S>

  type DailyQuizCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
    Omit<DailyQuizFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
      select?: DailyQuizCountAggregateInputType | true
    }

  export interface DailyQuizDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> {
    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['DailyQuiz'], meta: { name: 'DailyQuiz' } }
    /**
     * Find zero or one DailyQuiz that matches the filter.
     * @param {DailyQuizFindUniqueArgs} args - Arguments to find a DailyQuiz
     * @example
     * // Get one DailyQuiz
     * const dailyQuiz = await prisma.dailyQuiz.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUnique<T extends DailyQuizFindUniqueArgs>(args: SelectSubset<T, DailyQuizFindUniqueArgs<ExtArgs>>): Prisma__DailyQuizClient<$Result.GetResult<Prisma.$DailyQuizPayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find one DailyQuiz that matches the filter or throw an error with `error.code='P2025'`
     * if no matches were found.
     * @param {DailyQuizFindUniqueOrThrowArgs} args - Arguments to find a DailyQuiz
     * @example
     * // Get one DailyQuiz
     * const dailyQuiz = await prisma.dailyQuiz.findUniqueOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUniqueOrThrow<T extends DailyQuizFindUniqueOrThrowArgs>(args: SelectSubset<T, DailyQuizFindUniqueOrThrowArgs<ExtArgs>>): Prisma__DailyQuizClient<$Result.GetResult<Prisma.$DailyQuizPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first DailyQuiz 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 {DailyQuizFindFirstArgs} args - Arguments to find a DailyQuiz
     * @example
     * // Get one DailyQuiz
     * const dailyQuiz = await prisma.dailyQuiz.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends DailyQuizFindFirstArgs>(args?: SelectSubset<T, DailyQuizFindFirstArgs<ExtArgs>>): Prisma__DailyQuizClient<$Result.GetResult<Prisma.$DailyQuizPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first DailyQuiz 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 {DailyQuizFindFirstOrThrowArgs} args - Arguments to find a DailyQuiz
     * @example
     * // Get one DailyQuiz
     * const dailyQuiz = await prisma.dailyQuiz.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends DailyQuizFindFirstOrThrowArgs>(args?: SelectSubset<T, DailyQuizFindFirstOrThrowArgs<ExtArgs>>): Prisma__DailyQuizClient<$Result.GetResult<Prisma.$DailyQuizPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find zero or more DailyQuizs 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 {DailyQuizFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all DailyQuizs
     * const dailyQuizs = await prisma.dailyQuiz.findMany()
     * 
     * // Get first 10 DailyQuizs
     * const dailyQuizs = await prisma.dailyQuiz.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const dailyQuizWithIdOnly = await prisma.dailyQuiz.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends DailyQuizFindManyArgs>(args?: SelectSubset<T, DailyQuizFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$DailyQuizPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>

    /**
     * Create a DailyQuiz.
     * @param {DailyQuizCreateArgs} args - Arguments to create a DailyQuiz.
     * @example
     * // Create one DailyQuiz
     * const DailyQuiz = await prisma.dailyQuiz.create({
     *   data: {
     *     // ... data to create a DailyQuiz
     *   }
     * })
     * 
     */
    create<T extends DailyQuizCreateArgs>(args: SelectSubset<T, DailyQuizCreateArgs<ExtArgs>>): Prisma__DailyQuizClient<$Result.GetResult<Prisma.$DailyQuizPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Create many DailyQuizs.
     * @param {DailyQuizCreateManyArgs} args - Arguments to create many DailyQuizs.
     * @example
     * // Create many DailyQuizs
     * const dailyQuiz = await prisma.dailyQuiz.createMany({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     *     
     */
    createMany<T extends DailyQuizCreateManyArgs>(args?: SelectSubset<T, DailyQuizCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create many DailyQuizs and returns the data saved in the database.
     * @param {DailyQuizCreateManyAndReturnArgs} args - Arguments to create many DailyQuizs.
     * @example
     * // Create many DailyQuizs
     * const dailyQuiz = await prisma.dailyQuiz.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many DailyQuizs and only return the `id`
     * const dailyQuizWithIdOnly = await prisma.dailyQuiz.createManyAndReturn({
     *   select: { id: true },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    createManyAndReturn<T extends DailyQuizCreateManyAndReturnArgs>(args?: SelectSubset<T, DailyQuizCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$DailyQuizPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>

    /**
     * Delete a DailyQuiz.
     * @param {DailyQuizDeleteArgs} args - Arguments to delete one DailyQuiz.
     * @example
     * // Delete one DailyQuiz
     * const DailyQuiz = await prisma.dailyQuiz.delete({
     *   where: {
     *     // ... filter to delete one DailyQuiz
     *   }
     * })
     * 
     */
    delete<T extends DailyQuizDeleteArgs>(args: SelectSubset<T, DailyQuizDeleteArgs<ExtArgs>>): Prisma__DailyQuizClient<$Result.GetResult<Prisma.$DailyQuizPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Update one DailyQuiz.
     * @param {DailyQuizUpdateArgs} args - Arguments to update one DailyQuiz.
     * @example
     * // Update one DailyQuiz
     * const dailyQuiz = await prisma.dailyQuiz.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends DailyQuizUpdateArgs>(args: SelectSubset<T, DailyQuizUpdateArgs<ExtArgs>>): Prisma__DailyQuizClient<$Result.GetResult<Prisma.$DailyQuizPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Delete zero or more DailyQuizs.
     * @param {DailyQuizDeleteManyArgs} args - Arguments to filter DailyQuizs to delete.
     * @example
     * // Delete a few DailyQuizs
     * const { count } = await prisma.dailyQuiz.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
     */
    deleteMany<T extends DailyQuizDeleteManyArgs>(args?: SelectSubset<T, DailyQuizDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more DailyQuizs.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {DailyQuizUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many DailyQuizs
     * const dailyQuiz = await prisma.dailyQuiz.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    updateMany<T extends DailyQuizUpdateManyArgs>(args: SelectSubset<T, DailyQuizUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more DailyQuizs and returns the data updated in the database.
     * @param {DailyQuizUpdateManyAndReturnArgs} args - Arguments to update many DailyQuizs.
     * @example
     * // Update many DailyQuizs
     * const dailyQuiz = await prisma.dailyQuiz.updateManyAndReturn({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Update zero or more DailyQuizs and only return the `id`
     * const dailyQuizWithIdOnly = await prisma.dailyQuiz.updateManyAndReturn({
     *   select: { id: true },
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    updateManyAndReturn<T extends DailyQuizUpdateManyAndReturnArgs>(args: SelectSubset<T, DailyQuizUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$DailyQuizPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>

    /**
     * Create or update one DailyQuiz.
     * @param {DailyQuizUpsertArgs} args - Arguments to update or create a DailyQuiz.
     * @example
     * // Update or create a DailyQuiz
     * const dailyQuiz = await prisma.dailyQuiz.upsert({
     *   create: {
     *     // ... data to create a DailyQuiz
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the DailyQuiz we want to update
     *   }
     * })
     */
    upsert<T extends DailyQuizUpsertArgs>(args: SelectSubset<T, DailyQuizUpsertArgs<ExtArgs>>): Prisma__DailyQuizClient<$Result.GetResult<Prisma.$DailyQuizPayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>


    /**
     * Count the number of DailyQuizs.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {DailyQuizCountArgs} args - Arguments to filter DailyQuizs to count.
     * @example
     * // Count the number of DailyQuizs
     * const count = await prisma.dailyQuiz.count({
     *   where: {
     *     // ... the filter for the DailyQuizs we want to count
     *   }
     * })
    **/
    count<T extends DailyQuizCountArgs>(
      args?: Subset<T, DailyQuizCountArgs>,
    ): Prisma.PrismaPromise<
      T extends $Utils.Record<'select', any>
        ? T['select'] extends true
          ? number
          : GetScalarType<T['select'], DailyQuizCountAggregateOutputType>
        : number
    >

    /**
     * Allows you to perform aggregations operations on a DailyQuiz.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {DailyQuizAggregateArgs} 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 DailyQuizAggregateArgs>(args: Subset<T, DailyQuizAggregateArgs>): Prisma.PrismaPromise<GetDailyQuizAggregateType<T>>

    /**
     * Group by DailyQuiz.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {DailyQuizGroupByArgs} 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 DailyQuizGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: DailyQuizGroupByArgs['orderBy'] }
        : { orderBy?: DailyQuizGroupByArgs['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, DailyQuizGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetDailyQuizGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the DailyQuiz model
   */
  readonly fields: DailyQuizFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for DailyQuiz.
   * 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__DailyQuizClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    questions<T extends DailyQuiz$questionsArgs<ExtArgs> = {}>(args?: Subset<T, DailyQuiz$questionsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$QuizQuestionPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    submissions<T extends DailyQuiz$submissionsArgs<ExtArgs> = {}>(args?: Subset<T, DailyQuiz$submissionsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$QuizSubmissionPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    awardedCards<T extends DailyQuiz$awardedCardsArgs<ExtArgs> = {}>(args?: Subset<T, DailyQuiz$awardedCardsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$GoldenCardPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    /**
     * 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 DailyQuiz model
   */
  interface DailyQuizFieldRefs {
    readonly id: FieldRef<"DailyQuiz", 'String'>
    readonly date: FieldRef<"DailyQuiz", 'DateTime'>
    readonly windowStart: FieldRef<"DailyQuiz", 'DateTime'>
    readonly windowEnd: FieldRef<"DailyQuiz", 'DateTime'>
    readonly goldWinnersCount: FieldRef<"DailyQuiz", 'Int'>
    readonly silverWinnersCount: FieldRef<"DailyQuiz", 'Int'>
    readonly bronzeWinnersCount: FieldRef<"DailyQuiz", 'Int'>
    readonly goldMinCorrect: FieldRef<"DailyQuiz", 'Int'>
    readonly silverMinCorrect: FieldRef<"DailyQuiz", 'Int'>
    readonly bronzeMinCorrect: FieldRef<"DailyQuiz", 'Int'>
    readonly isProcessed: FieldRef<"DailyQuiz", 'Boolean'>
    readonly createdAt: FieldRef<"DailyQuiz", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * DailyQuiz findUnique
   */
  export type DailyQuizFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the DailyQuiz
     */
    select?: DailyQuizSelect<ExtArgs> | null
    /**
     * Omit specific fields from the DailyQuiz
     */
    omit?: DailyQuizOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: DailyQuizInclude<ExtArgs> | null
    /**
     * Filter, which DailyQuiz to fetch.
     */
    where: DailyQuizWhereUniqueInput
  }

  /**
   * DailyQuiz findUniqueOrThrow
   */
  export type DailyQuizFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the DailyQuiz
     */
    select?: DailyQuizSelect<ExtArgs> | null
    /**
     * Omit specific fields from the DailyQuiz
     */
    omit?: DailyQuizOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: DailyQuizInclude<ExtArgs> | null
    /**
     * Filter, which DailyQuiz to fetch.
     */
    where: DailyQuizWhereUniqueInput
  }

  /**
   * DailyQuiz findFirst
   */
  export type DailyQuizFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the DailyQuiz
     */
    select?: DailyQuizSelect<ExtArgs> | null
    /**
     * Omit specific fields from the DailyQuiz
     */
    omit?: DailyQuizOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: DailyQuizInclude<ExtArgs> | null
    /**
     * Filter, which DailyQuiz to fetch.
     */
    where?: DailyQuizWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of DailyQuizs to fetch.
     */
    orderBy?: DailyQuizOrderByWithRelationInput | DailyQuizOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for DailyQuizs.
     */
    cursor?: DailyQuizWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` DailyQuizs 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` DailyQuizs.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of DailyQuizs.
     */
    distinct?: DailyQuizScalarFieldEnum | DailyQuizScalarFieldEnum[]
  }

  /**
   * DailyQuiz findFirstOrThrow
   */
  export type DailyQuizFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the DailyQuiz
     */
    select?: DailyQuizSelect<ExtArgs> | null
    /**
     * Omit specific fields from the DailyQuiz
     */
    omit?: DailyQuizOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: DailyQuizInclude<ExtArgs> | null
    /**
     * Filter, which DailyQuiz to fetch.
     */
    where?: DailyQuizWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of DailyQuizs to fetch.
     */
    orderBy?: DailyQuizOrderByWithRelationInput | DailyQuizOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for DailyQuizs.
     */
    cursor?: DailyQuizWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` DailyQuizs 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` DailyQuizs.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of DailyQuizs.
     */
    distinct?: DailyQuizScalarFieldEnum | DailyQuizScalarFieldEnum[]
  }

  /**
   * DailyQuiz findMany
   */
  export type DailyQuizFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the DailyQuiz
     */
    select?: DailyQuizSelect<ExtArgs> | null
    /**
     * Omit specific fields from the DailyQuiz
     */
    omit?: DailyQuizOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: DailyQuizInclude<ExtArgs> | null
    /**
     * Filter, which DailyQuizs to fetch.
     */
    where?: DailyQuizWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of DailyQuizs to fetch.
     */
    orderBy?: DailyQuizOrderByWithRelationInput | DailyQuizOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing DailyQuizs.
     */
    cursor?: DailyQuizWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` DailyQuizs 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` DailyQuizs.
     */
    skip?: number
    distinct?: DailyQuizScalarFieldEnum | DailyQuizScalarFieldEnum[]
  }

  /**
   * DailyQuiz create
   */
  export type DailyQuizCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the DailyQuiz
     */
    select?: DailyQuizSelect<ExtArgs> | null
    /**
     * Omit specific fields from the DailyQuiz
     */
    omit?: DailyQuizOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: DailyQuizInclude<ExtArgs> | null
    /**
     * The data needed to create a DailyQuiz.
     */
    data: XOR<DailyQuizCreateInput, DailyQuizUncheckedCreateInput>
  }

  /**
   * DailyQuiz createMany
   */
  export type DailyQuizCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many DailyQuizs.
     */
    data: DailyQuizCreateManyInput | DailyQuizCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * DailyQuiz createManyAndReturn
   */
  export type DailyQuizCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the DailyQuiz
     */
    select?: DailyQuizSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the DailyQuiz
     */
    omit?: DailyQuizOmit<ExtArgs> | null
    /**
     * The data used to create many DailyQuizs.
     */
    data: DailyQuizCreateManyInput | DailyQuizCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * DailyQuiz update
   */
  export type DailyQuizUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the DailyQuiz
     */
    select?: DailyQuizSelect<ExtArgs> | null
    /**
     * Omit specific fields from the DailyQuiz
     */
    omit?: DailyQuizOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: DailyQuizInclude<ExtArgs> | null
    /**
     * The data needed to update a DailyQuiz.
     */
    data: XOR<DailyQuizUpdateInput, DailyQuizUncheckedUpdateInput>
    /**
     * Choose, which DailyQuiz to update.
     */
    where: DailyQuizWhereUniqueInput
  }

  /**
   * DailyQuiz updateMany
   */
  export type DailyQuizUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update DailyQuizs.
     */
    data: XOR<DailyQuizUpdateManyMutationInput, DailyQuizUncheckedUpdateManyInput>
    /**
     * Filter which DailyQuizs to update
     */
    where?: DailyQuizWhereInput
    /**
     * Limit how many DailyQuizs to update.
     */
    limit?: number
  }

  /**
   * DailyQuiz updateManyAndReturn
   */
  export type DailyQuizUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the DailyQuiz
     */
    select?: DailyQuizSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the DailyQuiz
     */
    omit?: DailyQuizOmit<ExtArgs> | null
    /**
     * The data used to update DailyQuizs.
     */
    data: XOR<DailyQuizUpdateManyMutationInput, DailyQuizUncheckedUpdateManyInput>
    /**
     * Filter which DailyQuizs to update
     */
    where?: DailyQuizWhereInput
    /**
     * Limit how many DailyQuizs to update.
     */
    limit?: number
  }

  /**
   * DailyQuiz upsert
   */
  export type DailyQuizUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the DailyQuiz
     */
    select?: DailyQuizSelect<ExtArgs> | null
    /**
     * Omit specific fields from the DailyQuiz
     */
    omit?: DailyQuizOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: DailyQuizInclude<ExtArgs> | null
    /**
     * The filter to search for the DailyQuiz to update in case it exists.
     */
    where: DailyQuizWhereUniqueInput
    /**
     * In case the DailyQuiz found by the `where` argument doesn't exist, create a new DailyQuiz with this data.
     */
    create: XOR<DailyQuizCreateInput, DailyQuizUncheckedCreateInput>
    /**
     * In case the DailyQuiz was found with the provided `where` argument, update it with this data.
     */
    update: XOR<DailyQuizUpdateInput, DailyQuizUncheckedUpdateInput>
  }

  /**
   * DailyQuiz delete
   */
  export type DailyQuizDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the DailyQuiz
     */
    select?: DailyQuizSelect<ExtArgs> | null
    /**
     * Omit specific fields from the DailyQuiz
     */
    omit?: DailyQuizOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: DailyQuizInclude<ExtArgs> | null
    /**
     * Filter which DailyQuiz to delete.
     */
    where: DailyQuizWhereUniqueInput
  }

  /**
   * DailyQuiz deleteMany
   */
  export type DailyQuizDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which DailyQuizs to delete
     */
    where?: DailyQuizWhereInput
    /**
     * Limit how many DailyQuizs to delete.
     */
    limit?: number
  }

  /**
   * DailyQuiz.questions
   */
  export type DailyQuiz$questionsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the QuizQuestion
     */
    select?: QuizQuestionSelect<ExtArgs> | null
    /**
     * Omit specific fields from the QuizQuestion
     */
    omit?: QuizQuestionOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: QuizQuestionInclude<ExtArgs> | null
    where?: QuizQuestionWhereInput
    orderBy?: QuizQuestionOrderByWithRelationInput | QuizQuestionOrderByWithRelationInput[]
    cursor?: QuizQuestionWhereUniqueInput
    take?: number
    skip?: number
    distinct?: QuizQuestionScalarFieldEnum | QuizQuestionScalarFieldEnum[]
  }

  /**
   * DailyQuiz.submissions
   */
  export type DailyQuiz$submissionsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the QuizSubmission
     */
    select?: QuizSubmissionSelect<ExtArgs> | null
    /**
     * Omit specific fields from the QuizSubmission
     */
    omit?: QuizSubmissionOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: QuizSubmissionInclude<ExtArgs> | null
    where?: QuizSubmissionWhereInput
    orderBy?: QuizSubmissionOrderByWithRelationInput | QuizSubmissionOrderByWithRelationInput[]
    cursor?: QuizSubmissionWhereUniqueInput
    take?: number
    skip?: number
    distinct?: QuizSubmissionScalarFieldEnum | QuizSubmissionScalarFieldEnum[]
  }

  /**
   * DailyQuiz.awardedCards
   */
  export type DailyQuiz$awardedCardsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the GoldenCard
     */
    select?: GoldenCardSelect<ExtArgs> | null
    /**
     * Omit specific fields from the GoldenCard
     */
    omit?: GoldenCardOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: GoldenCardInclude<ExtArgs> | null
    where?: GoldenCardWhereInput
    orderBy?: GoldenCardOrderByWithRelationInput | GoldenCardOrderByWithRelationInput[]
    cursor?: GoldenCardWhereUniqueInput
    take?: number
    skip?: number
    distinct?: GoldenCardScalarFieldEnum | GoldenCardScalarFieldEnum[]
  }

  /**
   * DailyQuiz without action
   */
  export type DailyQuizDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the DailyQuiz
     */
    select?: DailyQuizSelect<ExtArgs> | null
    /**
     * Omit specific fields from the DailyQuiz
     */
    omit?: DailyQuizOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: DailyQuizInclude<ExtArgs> | null
  }


  /**
   * Model QuizQuestion
   */

  export type AggregateQuizQuestion = {
    _count: QuizQuestionCountAggregateOutputType | null
    _avg: QuizQuestionAvgAggregateOutputType | null
    _sum: QuizQuestionSumAggregateOutputType | null
    _min: QuizQuestionMinAggregateOutputType | null
    _max: QuizQuestionMaxAggregateOutputType | null
  }

  export type QuizQuestionAvgAggregateOutputType = {
    correctAnswer: number | null
    order: number | null
  }

  export type QuizQuestionSumAggregateOutputType = {
    correctAnswer: number | null
    order: number | null
  }

  export type QuizQuestionMinAggregateOutputType = {
    id: string | null
    quizId: string | null
    questionText: string | null
    correctAnswer: number | null
    order: number | null
  }

  export type QuizQuestionMaxAggregateOutputType = {
    id: string | null
    quizId: string | null
    questionText: string | null
    correctAnswer: number | null
    order: number | null
  }

  export type QuizQuestionCountAggregateOutputType = {
    id: number
    quizId: number
    questionText: number
    options: number
    correctAnswer: number
    order: number
    _all: number
  }


  export type QuizQuestionAvgAggregateInputType = {
    correctAnswer?: true
    order?: true
  }

  export type QuizQuestionSumAggregateInputType = {
    correctAnswer?: true
    order?: true
  }

  export type QuizQuestionMinAggregateInputType = {
    id?: true
    quizId?: true
    questionText?: true
    correctAnswer?: true
    order?: true
  }

  export type QuizQuestionMaxAggregateInputType = {
    id?: true
    quizId?: true
    questionText?: true
    correctAnswer?: true
    order?: true
  }

  export type QuizQuestionCountAggregateInputType = {
    id?: true
    quizId?: true
    questionText?: true
    options?: true
    correctAnswer?: true
    order?: true
    _all?: true
  }

  export type QuizQuestionAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which QuizQuestion to aggregate.
     */
    where?: QuizQuestionWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of QuizQuestions to fetch.
     */
    orderBy?: QuizQuestionOrderByWithRelationInput | QuizQuestionOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: QuizQuestionWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` QuizQuestions 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` QuizQuestions.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned QuizQuestions
    **/
    _count?: true | QuizQuestionCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: QuizQuestionAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: QuizQuestionSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: QuizQuestionMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: QuizQuestionMaxAggregateInputType
  }

  export type GetQuizQuestionAggregateType<T extends QuizQuestionAggregateArgs> = {
        [P in keyof T & keyof AggregateQuizQuestion]: P extends '_count' | 'count'
      ? T[P] extends true
        ? number
        : GetScalarType<T[P], AggregateQuizQuestion[P]>
      : GetScalarType<T[P], AggregateQuizQuestion[P]>
  }




  export type QuizQuestionGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: QuizQuestionWhereInput
    orderBy?: QuizQuestionOrderByWithAggregationInput | QuizQuestionOrderByWithAggregationInput[]
    by: QuizQuestionScalarFieldEnum[] | QuizQuestionScalarFieldEnum
    having?: QuizQuestionScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: QuizQuestionCountAggregateInputType | true
    _avg?: QuizQuestionAvgAggregateInputType
    _sum?: QuizQuestionSumAggregateInputType
    _min?: QuizQuestionMinAggregateInputType
    _max?: QuizQuestionMaxAggregateInputType
  }

  export type QuizQuestionGroupByOutputType = {
    id: string
    quizId: string
    questionText: string
    options: string[]
    correctAnswer: number
    order: number
    _count: QuizQuestionCountAggregateOutputType | null
    _avg: QuizQuestionAvgAggregateOutputType | null
    _sum: QuizQuestionSumAggregateOutputType | null
    _min: QuizQuestionMinAggregateOutputType | null
    _max: QuizQuestionMaxAggregateOutputType | null
  }

  type GetQuizQuestionGroupByPayload<T extends QuizQuestionGroupByArgs> = Prisma.PrismaPromise<
    Array<
      PickEnumerable<QuizQuestionGroupByOutputType, T['by']> &
        {
          [P in ((keyof T) & (keyof QuizQuestionGroupByOutputType))]: P extends '_count'
            ? T[P] extends boolean
              ? number
              : GetScalarType<T[P], QuizQuestionGroupByOutputType[P]>
            : GetScalarType<T[P], QuizQuestionGroupByOutputType[P]>
        }
      >
    >


  export type QuizQuestionSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    quizId?: boolean
    questionText?: boolean
    options?: boolean
    correctAnswer?: boolean
    order?: boolean
    quiz?: boolean | DailyQuizDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["quizQuestion"]>

  export type QuizQuestionSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    quizId?: boolean
    questionText?: boolean
    options?: boolean
    correctAnswer?: boolean
    order?: boolean
    quiz?: boolean | DailyQuizDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["quizQuestion"]>

  export type QuizQuestionSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    quizId?: boolean
    questionText?: boolean
    options?: boolean
    correctAnswer?: boolean
    order?: boolean
    quiz?: boolean | DailyQuizDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["quizQuestion"]>

  export type QuizQuestionSelectScalar = {
    id?: boolean
    quizId?: boolean
    questionText?: boolean
    options?: boolean
    correctAnswer?: boolean
    order?: boolean
  }

  export type QuizQuestionOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "quizId" | "questionText" | "options" | "correctAnswer" | "order", ExtArgs["result"]["quizQuestion"]>
  export type QuizQuestionInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    quiz?: boolean | DailyQuizDefaultArgs<ExtArgs>
  }
  export type QuizQuestionIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    quiz?: boolean | DailyQuizDefaultArgs<ExtArgs>
  }
  export type QuizQuestionIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    quiz?: boolean | DailyQuizDefaultArgs<ExtArgs>
  }

  export type $QuizQuestionPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "QuizQuestion"
    objects: {
      quiz: Prisma.$DailyQuizPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      quizId: string
      questionText: string
      options: string[]
      correctAnswer: number
      order: number
    }, ExtArgs["result"]["quizQuestion"]>
    composites: {}
  }

  type QuizQuestionGetPayload<S extends boolean | null | undefined | QuizQuestionDefaultArgs> = $Result.GetResult<Prisma.$QuizQuestionPayload, S>

  type QuizQuestionCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
    Omit<QuizQuestionFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
      select?: QuizQuestionCountAggregateInputType | true
    }

  export interface QuizQuestionDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> {
    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['QuizQuestion'], meta: { name: 'QuizQuestion' } }
    /**
     * Find zero or one QuizQuestion that matches the filter.
     * @param {QuizQuestionFindUniqueArgs} args - Arguments to find a QuizQuestion
     * @example
     * // Get one QuizQuestion
     * const quizQuestion = await prisma.quizQuestion.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUnique<T extends QuizQuestionFindUniqueArgs>(args: SelectSubset<T, QuizQuestionFindUniqueArgs<ExtArgs>>): Prisma__QuizQuestionClient<$Result.GetResult<Prisma.$QuizQuestionPayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find one QuizQuestion that matches the filter or throw an error with `error.code='P2025'`
     * if no matches were found.
     * @param {QuizQuestionFindUniqueOrThrowArgs} args - Arguments to find a QuizQuestion
     * @example
     * // Get one QuizQuestion
     * const quizQuestion = await prisma.quizQuestion.findUniqueOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUniqueOrThrow<T extends QuizQuestionFindUniqueOrThrowArgs>(args: SelectSubset<T, QuizQuestionFindUniqueOrThrowArgs<ExtArgs>>): Prisma__QuizQuestionClient<$Result.GetResult<Prisma.$QuizQuestionPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first QuizQuestion 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 {QuizQuestionFindFirstArgs} args - Arguments to find a QuizQuestion
     * @example
     * // Get one QuizQuestion
     * const quizQuestion = await prisma.quizQuestion.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends QuizQuestionFindFirstArgs>(args?: SelectSubset<T, QuizQuestionFindFirstArgs<ExtArgs>>): Prisma__QuizQuestionClient<$Result.GetResult<Prisma.$QuizQuestionPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first QuizQuestion 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 {QuizQuestionFindFirstOrThrowArgs} args - Arguments to find a QuizQuestion
     * @example
     * // Get one QuizQuestion
     * const quizQuestion = await prisma.quizQuestion.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends QuizQuestionFindFirstOrThrowArgs>(args?: SelectSubset<T, QuizQuestionFindFirstOrThrowArgs<ExtArgs>>): Prisma__QuizQuestionClient<$Result.GetResult<Prisma.$QuizQuestionPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find zero or more QuizQuestions 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 {QuizQuestionFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all QuizQuestions
     * const quizQuestions = await prisma.quizQuestion.findMany()
     * 
     * // Get first 10 QuizQuestions
     * const quizQuestions = await prisma.quizQuestion.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const quizQuestionWithIdOnly = await prisma.quizQuestion.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends QuizQuestionFindManyArgs>(args?: SelectSubset<T, QuizQuestionFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$QuizQuestionPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>

    /**
     * Create a QuizQuestion.
     * @param {QuizQuestionCreateArgs} args - Arguments to create a QuizQuestion.
     * @example
     * // Create one QuizQuestion
     * const QuizQuestion = await prisma.quizQuestion.create({
     *   data: {
     *     // ... data to create a QuizQuestion
     *   }
     * })
     * 
     */
    create<T extends QuizQuestionCreateArgs>(args: SelectSubset<T, QuizQuestionCreateArgs<ExtArgs>>): Prisma__QuizQuestionClient<$Result.GetResult<Prisma.$QuizQuestionPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Create many QuizQuestions.
     * @param {QuizQuestionCreateManyArgs} args - Arguments to create many QuizQuestions.
     * @example
     * // Create many QuizQuestions
     * const quizQuestion = await prisma.quizQuestion.createMany({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     *     
     */
    createMany<T extends QuizQuestionCreateManyArgs>(args?: SelectSubset<T, QuizQuestionCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create many QuizQuestions and returns the data saved in the database.
     * @param {QuizQuestionCreateManyAndReturnArgs} args - Arguments to create many QuizQuestions.
     * @example
     * // Create many QuizQuestions
     * const quizQuestion = await prisma.quizQuestion.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many QuizQuestions and only return the `id`
     * const quizQuestionWithIdOnly = await prisma.quizQuestion.createManyAndReturn({
     *   select: { id: true },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    createManyAndReturn<T extends QuizQuestionCreateManyAndReturnArgs>(args?: SelectSubset<T, QuizQuestionCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$QuizQuestionPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>

    /**
     * Delete a QuizQuestion.
     * @param {QuizQuestionDeleteArgs} args - Arguments to delete one QuizQuestion.
     * @example
     * // Delete one QuizQuestion
     * const QuizQuestion = await prisma.quizQuestion.delete({
     *   where: {
     *     // ... filter to delete one QuizQuestion
     *   }
     * })
     * 
     */
    delete<T extends QuizQuestionDeleteArgs>(args: SelectSubset<T, QuizQuestionDeleteArgs<ExtArgs>>): Prisma__QuizQuestionClient<$Result.GetResult<Prisma.$QuizQuestionPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Update one QuizQuestion.
     * @param {QuizQuestionUpdateArgs} args - Arguments to update one QuizQuestion.
     * @example
     * // Update one QuizQuestion
     * const quizQuestion = await prisma.quizQuestion.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends QuizQuestionUpdateArgs>(args: SelectSubset<T, QuizQuestionUpdateArgs<ExtArgs>>): Prisma__QuizQuestionClient<$Result.GetResult<Prisma.$QuizQuestionPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Delete zero or more QuizQuestions.
     * @param {QuizQuestionDeleteManyArgs} args - Arguments to filter QuizQuestions to delete.
     * @example
     * // Delete a few QuizQuestions
     * const { count } = await prisma.quizQuestion.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
     */
    deleteMany<T extends QuizQuestionDeleteManyArgs>(args?: SelectSubset<T, QuizQuestionDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more QuizQuestions.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {QuizQuestionUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many QuizQuestions
     * const quizQuestion = await prisma.quizQuestion.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    updateMany<T extends QuizQuestionUpdateManyArgs>(args: SelectSubset<T, QuizQuestionUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more QuizQuestions and returns the data updated in the database.
     * @param {QuizQuestionUpdateManyAndReturnArgs} args - Arguments to update many QuizQuestions.
     * @example
     * // Update many QuizQuestions
     * const quizQuestion = await prisma.quizQuestion.updateManyAndReturn({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Update zero or more QuizQuestions and only return the `id`
     * const quizQuestionWithIdOnly = await prisma.quizQuestion.updateManyAndReturn({
     *   select: { id: true },
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    updateManyAndReturn<T extends QuizQuestionUpdateManyAndReturnArgs>(args: SelectSubset<T, QuizQuestionUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$QuizQuestionPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>

    /**
     * Create or update one QuizQuestion.
     * @param {QuizQuestionUpsertArgs} args - Arguments to update or create a QuizQuestion.
     * @example
     * // Update or create a QuizQuestion
     * const quizQuestion = await prisma.quizQuestion.upsert({
     *   create: {
     *     // ... data to create a QuizQuestion
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the QuizQuestion we want to update
     *   }
     * })
     */
    upsert<T extends QuizQuestionUpsertArgs>(args: SelectSubset<T, QuizQuestionUpsertArgs<ExtArgs>>): Prisma__QuizQuestionClient<$Result.GetResult<Prisma.$QuizQuestionPayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>


    /**
     * Count the number of QuizQuestions.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {QuizQuestionCountArgs} args - Arguments to filter QuizQuestions to count.
     * @example
     * // Count the number of QuizQuestions
     * const count = await prisma.quizQuestion.count({
     *   where: {
     *     // ... the filter for the QuizQuestions we want to count
     *   }
     * })
    **/
    count<T extends QuizQuestionCountArgs>(
      args?: Subset<T, QuizQuestionCountArgs>,
    ): Prisma.PrismaPromise<
      T extends $Utils.Record<'select', any>
        ? T['select'] extends true
          ? number
          : GetScalarType<T['select'], QuizQuestionCountAggregateOutputType>
        : number
    >

    /**
     * Allows you to perform aggregations operations on a QuizQuestion.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {QuizQuestionAggregateArgs} 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 QuizQuestionAggregateArgs>(args: Subset<T, QuizQuestionAggregateArgs>): Prisma.PrismaPromise<GetQuizQuestionAggregateType<T>>

    /**
     * Group by QuizQuestion.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {QuizQuestionGroupByArgs} 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 QuizQuestionGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: QuizQuestionGroupByArgs['orderBy'] }
        : { orderBy?: QuizQuestionGroupByArgs['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, QuizQuestionGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetQuizQuestionGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the QuizQuestion model
   */
  readonly fields: QuizQuestionFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for QuizQuestion.
   * 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__QuizQuestionClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    quiz<T extends DailyQuizDefaultArgs<ExtArgs> = {}>(args?: Subset<T, DailyQuizDefaultArgs<ExtArgs>>): Prisma__DailyQuizClient<$Result.GetResult<Prisma.$DailyQuizPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
    /**
     * 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 QuizQuestion model
   */
  interface QuizQuestionFieldRefs {
    readonly id: FieldRef<"QuizQuestion", 'String'>
    readonly quizId: FieldRef<"QuizQuestion", 'String'>
    readonly questionText: FieldRef<"QuizQuestion", 'String'>
    readonly options: FieldRef<"QuizQuestion", 'String[]'>
    readonly correctAnswer: FieldRef<"QuizQuestion", 'Int'>
    readonly order: FieldRef<"QuizQuestion", 'Int'>
  }
    

  // Custom InputTypes
  /**
   * QuizQuestion findUnique
   */
  export type QuizQuestionFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the QuizQuestion
     */
    select?: QuizQuestionSelect<ExtArgs> | null
    /**
     * Omit specific fields from the QuizQuestion
     */
    omit?: QuizQuestionOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: QuizQuestionInclude<ExtArgs> | null
    /**
     * Filter, which QuizQuestion to fetch.
     */
    where: QuizQuestionWhereUniqueInput
  }

  /**
   * QuizQuestion findUniqueOrThrow
   */
  export type QuizQuestionFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the QuizQuestion
     */
    select?: QuizQuestionSelect<ExtArgs> | null
    /**
     * Omit specific fields from the QuizQuestion
     */
    omit?: QuizQuestionOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: QuizQuestionInclude<ExtArgs> | null
    /**
     * Filter, which QuizQuestion to fetch.
     */
    where: QuizQuestionWhereUniqueInput
  }

  /**
   * QuizQuestion findFirst
   */
  export type QuizQuestionFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the QuizQuestion
     */
    select?: QuizQuestionSelect<ExtArgs> | null
    /**
     * Omit specific fields from the QuizQuestion
     */
    omit?: QuizQuestionOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: QuizQuestionInclude<ExtArgs> | null
    /**
     * Filter, which QuizQuestion to fetch.
     */
    where?: QuizQuestionWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of QuizQuestions to fetch.
     */
    orderBy?: QuizQuestionOrderByWithRelationInput | QuizQuestionOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for QuizQuestions.
     */
    cursor?: QuizQuestionWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` QuizQuestions 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` QuizQuestions.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of QuizQuestions.
     */
    distinct?: QuizQuestionScalarFieldEnum | QuizQuestionScalarFieldEnum[]
  }

  /**
   * QuizQuestion findFirstOrThrow
   */
  export type QuizQuestionFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the QuizQuestion
     */
    select?: QuizQuestionSelect<ExtArgs> | null
    /**
     * Omit specific fields from the QuizQuestion
     */
    omit?: QuizQuestionOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: QuizQuestionInclude<ExtArgs> | null
    /**
     * Filter, which QuizQuestion to fetch.
     */
    where?: QuizQuestionWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of QuizQuestions to fetch.
     */
    orderBy?: QuizQuestionOrderByWithRelationInput | QuizQuestionOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for QuizQuestions.
     */
    cursor?: QuizQuestionWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` QuizQuestions 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` QuizQuestions.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of QuizQuestions.
     */
    distinct?: QuizQuestionScalarFieldEnum | QuizQuestionScalarFieldEnum[]
  }

  /**
   * QuizQuestion findMany
   */
  export type QuizQuestionFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the QuizQuestion
     */
    select?: QuizQuestionSelect<ExtArgs> | null
    /**
     * Omit specific fields from the QuizQuestion
     */
    omit?: QuizQuestionOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: QuizQuestionInclude<ExtArgs> | null
    /**
     * Filter, which QuizQuestions to fetch.
     */
    where?: QuizQuestionWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of QuizQuestions to fetch.
     */
    orderBy?: QuizQuestionOrderByWithRelationInput | QuizQuestionOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing QuizQuestions.
     */
    cursor?: QuizQuestionWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` QuizQuestions 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` QuizQuestions.
     */
    skip?: number
    distinct?: QuizQuestionScalarFieldEnum | QuizQuestionScalarFieldEnum[]
  }

  /**
   * QuizQuestion create
   */
  export type QuizQuestionCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the QuizQuestion
     */
    select?: QuizQuestionSelect<ExtArgs> | null
    /**
     * Omit specific fields from the QuizQuestion
     */
    omit?: QuizQuestionOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: QuizQuestionInclude<ExtArgs> | null
    /**
     * The data needed to create a QuizQuestion.
     */
    data: XOR<QuizQuestionCreateInput, QuizQuestionUncheckedCreateInput>
  }

  /**
   * QuizQuestion createMany
   */
  export type QuizQuestionCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many QuizQuestions.
     */
    data: QuizQuestionCreateManyInput | QuizQuestionCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * QuizQuestion createManyAndReturn
   */
  export type QuizQuestionCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the QuizQuestion
     */
    select?: QuizQuestionSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the QuizQuestion
     */
    omit?: QuizQuestionOmit<ExtArgs> | null
    /**
     * The data used to create many QuizQuestions.
     */
    data: QuizQuestionCreateManyInput | QuizQuestionCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: QuizQuestionIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * QuizQuestion update
   */
  export type QuizQuestionUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the QuizQuestion
     */
    select?: QuizQuestionSelect<ExtArgs> | null
    /**
     * Omit specific fields from the QuizQuestion
     */
    omit?: QuizQuestionOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: QuizQuestionInclude<ExtArgs> | null
    /**
     * The data needed to update a QuizQuestion.
     */
    data: XOR<QuizQuestionUpdateInput, QuizQuestionUncheckedUpdateInput>
    /**
     * Choose, which QuizQuestion to update.
     */
    where: QuizQuestionWhereUniqueInput
  }

  /**
   * QuizQuestion updateMany
   */
  export type QuizQuestionUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update QuizQuestions.
     */
    data: XOR<QuizQuestionUpdateManyMutationInput, QuizQuestionUncheckedUpdateManyInput>
    /**
     * Filter which QuizQuestions to update
     */
    where?: QuizQuestionWhereInput
    /**
     * Limit how many QuizQuestions to update.
     */
    limit?: number
  }

  /**
   * QuizQuestion updateManyAndReturn
   */
  export type QuizQuestionUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the QuizQuestion
     */
    select?: QuizQuestionSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the QuizQuestion
     */
    omit?: QuizQuestionOmit<ExtArgs> | null
    /**
     * The data used to update QuizQuestions.
     */
    data: XOR<QuizQuestionUpdateManyMutationInput, QuizQuestionUncheckedUpdateManyInput>
    /**
     * Filter which QuizQuestions to update
     */
    where?: QuizQuestionWhereInput
    /**
     * Limit how many QuizQuestions to update.
     */
    limit?: number
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: QuizQuestionIncludeUpdateManyAndReturn<ExtArgs> | null
  }

  /**
   * QuizQuestion upsert
   */
  export type QuizQuestionUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the QuizQuestion
     */
    select?: QuizQuestionSelect<ExtArgs> | null
    /**
     * Omit specific fields from the QuizQuestion
     */
    omit?: QuizQuestionOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: QuizQuestionInclude<ExtArgs> | null
    /**
     * The filter to search for the QuizQuestion to update in case it exists.
     */
    where: QuizQuestionWhereUniqueInput
    /**
     * In case the QuizQuestion found by the `where` argument doesn't exist, create a new QuizQuestion with this data.
     */
    create: XOR<QuizQuestionCreateInput, QuizQuestionUncheckedCreateInput>
    /**
     * In case the QuizQuestion was found with the provided `where` argument, update it with this data.
     */
    update: XOR<QuizQuestionUpdateInput, QuizQuestionUncheckedUpdateInput>
  }

  /**
   * QuizQuestion delete
   */
  export type QuizQuestionDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the QuizQuestion
     */
    select?: QuizQuestionSelect<ExtArgs> | null
    /**
     * Omit specific fields from the QuizQuestion
     */
    omit?: QuizQuestionOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: QuizQuestionInclude<ExtArgs> | null
    /**
     * Filter which QuizQuestion to delete.
     */
    where: QuizQuestionWhereUniqueInput
  }

  /**
   * QuizQuestion deleteMany
   */
  export type QuizQuestionDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which QuizQuestions to delete
     */
    where?: QuizQuestionWhereInput
    /**
     * Limit how many QuizQuestions to delete.
     */
    limit?: number
  }

  /**
   * QuizQuestion without action
   */
  export type QuizQuestionDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the QuizQuestion
     */
    select?: QuizQuestionSelect<ExtArgs> | null
    /**
     * Omit specific fields from the QuizQuestion
     */
    omit?: QuizQuestionOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: QuizQuestionInclude<ExtArgs> | null
  }


  /**
   * Model QuizSubmission
   */

  export type AggregateQuizSubmission = {
    _count: QuizSubmissionCountAggregateOutputType | null
    _avg: QuizSubmissionAvgAggregateOutputType | null
    _sum: QuizSubmissionSumAggregateOutputType | null
    _min: QuizSubmissionMinAggregateOutputType | null
    _max: QuizSubmissionMaxAggregateOutputType | null
  }

  export type QuizSubmissionAvgAggregateOutputType = {
    answers: number | null
    correctAnswers: number | null
    score: number | null
  }

  export type QuizSubmissionSumAggregateOutputType = {
    answers: number[]
    correctAnswers: number | null
    score: number | null
  }

  export type QuizSubmissionMinAggregateOutputType = {
    id: string | null
    userId: string | null
    quizId: string | null
    correctAnswers: number | null
    score: number | null
    submittedAt: Date | null
  }

  export type QuizSubmissionMaxAggregateOutputType = {
    id: string | null
    userId: string | null
    quizId: string | null
    correctAnswers: number | null
    score: number | null
    submittedAt: Date | null
  }

  export type QuizSubmissionCountAggregateOutputType = {
    id: number
    userId: number
    quizId: number
    answers: number
    correctAnswers: number
    score: number
    submittedAt: number
    _all: number
  }


  export type QuizSubmissionAvgAggregateInputType = {
    answers?: true
    correctAnswers?: true
    score?: true
  }

  export type QuizSubmissionSumAggregateInputType = {
    answers?: true
    correctAnswers?: true
    score?: true
  }

  export type QuizSubmissionMinAggregateInputType = {
    id?: true
    userId?: true
    quizId?: true
    correctAnswers?: true
    score?: true
    submittedAt?: true
  }

  export type QuizSubmissionMaxAggregateInputType = {
    id?: true
    userId?: true
    quizId?: true
    correctAnswers?: true
    score?: true
    submittedAt?: true
  }

  export type QuizSubmissionCountAggregateInputType = {
    id?: true
    userId?: true
    quizId?: true
    answers?: true
    correctAnswers?: true
    score?: true
    submittedAt?: true
    _all?: true
  }

  export type QuizSubmissionAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which QuizSubmission to aggregate.
     */
    where?: QuizSubmissionWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of QuizSubmissions to fetch.
     */
    orderBy?: QuizSubmissionOrderByWithRelationInput | QuizSubmissionOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: QuizSubmissionWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` QuizSubmissions 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` QuizSubmissions.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned QuizSubmissions
    **/
    _count?: true | QuizSubmissionCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: QuizSubmissionAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: QuizSubmissionSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: QuizSubmissionMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: QuizSubmissionMaxAggregateInputType
  }

  export type GetQuizSubmissionAggregateType<T extends QuizSubmissionAggregateArgs> = {
        [P in keyof T & keyof AggregateQuizSubmission]: P extends '_count' | 'count'
      ? T[P] extends true
        ? number
        : GetScalarType<T[P], AggregateQuizSubmission[P]>
      : GetScalarType<T[P], AggregateQuizSubmission[P]>
  }




  export type QuizSubmissionGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: QuizSubmissionWhereInput
    orderBy?: QuizSubmissionOrderByWithAggregationInput | QuizSubmissionOrderByWithAggregationInput[]
    by: QuizSubmissionScalarFieldEnum[] | QuizSubmissionScalarFieldEnum
    having?: QuizSubmissionScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: QuizSubmissionCountAggregateInputType | true
    _avg?: QuizSubmissionAvgAggregateInputType
    _sum?: QuizSubmissionSumAggregateInputType
    _min?: QuizSubmissionMinAggregateInputType
    _max?: QuizSubmissionMaxAggregateInputType
  }

  export type QuizSubmissionGroupByOutputType = {
    id: string
    userId: string
    quizId: string
    answers: number[]
    correctAnswers: number
    score: number
    submittedAt: Date
    _count: QuizSubmissionCountAggregateOutputType | null
    _avg: QuizSubmissionAvgAggregateOutputType | null
    _sum: QuizSubmissionSumAggregateOutputType | null
    _min: QuizSubmissionMinAggregateOutputType | null
    _max: QuizSubmissionMaxAggregateOutputType | null
  }

  type GetQuizSubmissionGroupByPayload<T extends QuizSubmissionGroupByArgs> = Prisma.PrismaPromise<
    Array<
      PickEnumerable<QuizSubmissionGroupByOutputType, T['by']> &
        {
          [P in ((keyof T) & (keyof QuizSubmissionGroupByOutputType))]: P extends '_count'
            ? T[P] extends boolean
              ? number
              : GetScalarType<T[P], QuizSubmissionGroupByOutputType[P]>
            : GetScalarType<T[P], QuizSubmissionGroupByOutputType[P]>
        }
      >
    >


  export type QuizSubmissionSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    userId?: boolean
    quizId?: boolean
    answers?: boolean
    correctAnswers?: boolean
    score?: boolean
    submittedAt?: boolean
    user?: boolean | UserDefaultArgs<ExtArgs>
    quiz?: boolean | DailyQuizDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["quizSubmission"]>

  export type QuizSubmissionSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    userId?: boolean
    quizId?: boolean
    answers?: boolean
    correctAnswers?: boolean
    score?: boolean
    submittedAt?: boolean
    user?: boolean | UserDefaultArgs<ExtArgs>
    quiz?: boolean | DailyQuizDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["quizSubmission"]>

  export type QuizSubmissionSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    userId?: boolean
    quizId?: boolean
    answers?: boolean
    correctAnswers?: boolean
    score?: boolean
    submittedAt?: boolean
    user?: boolean | UserDefaultArgs<ExtArgs>
    quiz?: boolean | DailyQuizDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["quizSubmission"]>

  export type QuizSubmissionSelectScalar = {
    id?: boolean
    userId?: boolean
    quizId?: boolean
    answers?: boolean
    correctAnswers?: boolean
    score?: boolean
    submittedAt?: boolean
  }

  export type QuizSubmissionOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "userId" | "quizId" | "answers" | "correctAnswers" | "score" | "submittedAt", ExtArgs["result"]["quizSubmission"]>
  export type QuizSubmissionInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
    quiz?: boolean | DailyQuizDefaultArgs<ExtArgs>
  }
  export type QuizSubmissionIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
    quiz?: boolean | DailyQuizDefaultArgs<ExtArgs>
  }
  export type QuizSubmissionIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
    quiz?: boolean | DailyQuizDefaultArgs<ExtArgs>
  }

  export type $QuizSubmissionPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "QuizSubmission"
    objects: {
      user: Prisma.$UserPayload<ExtArgs>
      quiz: Prisma.$DailyQuizPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      userId: string
      quizId: string
      answers: number[]
      correctAnswers: number
      score: number
      submittedAt: Date
    }, ExtArgs["result"]["quizSubmission"]>
    composites: {}
  }

  type QuizSubmissionGetPayload<S extends boolean | null | undefined | QuizSubmissionDefaultArgs> = $Result.GetResult<Prisma.$QuizSubmissionPayload, S>

  type QuizSubmissionCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
    Omit<QuizSubmissionFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
      select?: QuizSubmissionCountAggregateInputType | true
    }

  export interface QuizSubmissionDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> {
    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['QuizSubmission'], meta: { name: 'QuizSubmission' } }
    /**
     * Find zero or one QuizSubmission that matches the filter.
     * @param {QuizSubmissionFindUniqueArgs} args - Arguments to find a QuizSubmission
     * @example
     * // Get one QuizSubmission
     * const quizSubmission = await prisma.quizSubmission.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUnique<T extends QuizSubmissionFindUniqueArgs>(args: SelectSubset<T, QuizSubmissionFindUniqueArgs<ExtArgs>>): Prisma__QuizSubmissionClient<$Result.GetResult<Prisma.$QuizSubmissionPayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find one QuizSubmission that matches the filter or throw an error with `error.code='P2025'`
     * if no matches were found.
     * @param {QuizSubmissionFindUniqueOrThrowArgs} args - Arguments to find a QuizSubmission
     * @example
     * // Get one QuizSubmission
     * const quizSubmission = await prisma.quizSubmission.findUniqueOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUniqueOrThrow<T extends QuizSubmissionFindUniqueOrThrowArgs>(args: SelectSubset<T, QuizSubmissionFindUniqueOrThrowArgs<ExtArgs>>): Prisma__QuizSubmissionClient<$Result.GetResult<Prisma.$QuizSubmissionPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first QuizSubmission 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 {QuizSubmissionFindFirstArgs} args - Arguments to find a QuizSubmission
     * @example
     * // Get one QuizSubmission
     * const quizSubmission = await prisma.quizSubmission.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends QuizSubmissionFindFirstArgs>(args?: SelectSubset<T, QuizSubmissionFindFirstArgs<ExtArgs>>): Prisma__QuizSubmissionClient<$Result.GetResult<Prisma.$QuizSubmissionPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first QuizSubmission 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 {QuizSubmissionFindFirstOrThrowArgs} args - Arguments to find a QuizSubmission
     * @example
     * // Get one QuizSubmission
     * const quizSubmission = await prisma.quizSubmission.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends QuizSubmissionFindFirstOrThrowArgs>(args?: SelectSubset<T, QuizSubmissionFindFirstOrThrowArgs<ExtArgs>>): Prisma__QuizSubmissionClient<$Result.GetResult<Prisma.$QuizSubmissionPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find zero or more QuizSubmissions 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 {QuizSubmissionFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all QuizSubmissions
     * const quizSubmissions = await prisma.quizSubmission.findMany()
     * 
     * // Get first 10 QuizSubmissions
     * const quizSubmissions = await prisma.quizSubmission.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const quizSubmissionWithIdOnly = await prisma.quizSubmission.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends QuizSubmissionFindManyArgs>(args?: SelectSubset<T, QuizSubmissionFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$QuizSubmissionPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>

    /**
     * Create a QuizSubmission.
     * @param {QuizSubmissionCreateArgs} args - Arguments to create a QuizSubmission.
     * @example
     * // Create one QuizSubmission
     * const QuizSubmission = await prisma.quizSubmission.create({
     *   data: {
     *     // ... data to create a QuizSubmission
     *   }
     * })
     * 
     */
    create<T extends QuizSubmissionCreateArgs>(args: SelectSubset<T, QuizSubmissionCreateArgs<ExtArgs>>): Prisma__QuizSubmissionClient<$Result.GetResult<Prisma.$QuizSubmissionPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Create many QuizSubmissions.
     * @param {QuizSubmissionCreateManyArgs} args - Arguments to create many QuizSubmissions.
     * @example
     * // Create many QuizSubmissions
     * const quizSubmission = await prisma.quizSubmission.createMany({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     *     
     */
    createMany<T extends QuizSubmissionCreateManyArgs>(args?: SelectSubset<T, QuizSubmissionCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create many QuizSubmissions and returns the data saved in the database.
     * @param {QuizSubmissionCreateManyAndReturnArgs} args - Arguments to create many QuizSubmissions.
     * @example
     * // Create many QuizSubmissions
     * const quizSubmission = await prisma.quizSubmission.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many QuizSubmissions and only return the `id`
     * const quizSubmissionWithIdOnly = await prisma.quizSubmission.createManyAndReturn({
     *   select: { id: true },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    createManyAndReturn<T extends QuizSubmissionCreateManyAndReturnArgs>(args?: SelectSubset<T, QuizSubmissionCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$QuizSubmissionPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>

    /**
     * Delete a QuizSubmission.
     * @param {QuizSubmissionDeleteArgs} args - Arguments to delete one QuizSubmission.
     * @example
     * // Delete one QuizSubmission
     * const QuizSubmission = await prisma.quizSubmission.delete({
     *   where: {
     *     // ... filter to delete one QuizSubmission
     *   }
     * })
     * 
     */
    delete<T extends QuizSubmissionDeleteArgs>(args: SelectSubset<T, QuizSubmissionDeleteArgs<ExtArgs>>): Prisma__QuizSubmissionClient<$Result.GetResult<Prisma.$QuizSubmissionPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Update one QuizSubmission.
     * @param {QuizSubmissionUpdateArgs} args - Arguments to update one QuizSubmission.
     * @example
     * // Update one QuizSubmission
     * const quizSubmission = await prisma.quizSubmission.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends QuizSubmissionUpdateArgs>(args: SelectSubset<T, QuizSubmissionUpdateArgs<ExtArgs>>): Prisma__QuizSubmissionClient<$Result.GetResult<Prisma.$QuizSubmissionPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Delete zero or more QuizSubmissions.
     * @param {QuizSubmissionDeleteManyArgs} args - Arguments to filter QuizSubmissions to delete.
     * @example
     * // Delete a few QuizSubmissions
     * const { count } = await prisma.quizSubmission.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
     */
    deleteMany<T extends QuizSubmissionDeleteManyArgs>(args?: SelectSubset<T, QuizSubmissionDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more QuizSubmissions.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {QuizSubmissionUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many QuizSubmissions
     * const quizSubmission = await prisma.quizSubmission.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    updateMany<T extends QuizSubmissionUpdateManyArgs>(args: SelectSubset<T, QuizSubmissionUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more QuizSubmissions and returns the data updated in the database.
     * @param {QuizSubmissionUpdateManyAndReturnArgs} args - Arguments to update many QuizSubmissions.
     * @example
     * // Update many QuizSubmissions
     * const quizSubmission = await prisma.quizSubmission.updateManyAndReturn({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Update zero or more QuizSubmissions and only return the `id`
     * const quizSubmissionWithIdOnly = await prisma.quizSubmission.updateManyAndReturn({
     *   select: { id: true },
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    updateManyAndReturn<T extends QuizSubmissionUpdateManyAndReturnArgs>(args: SelectSubset<T, QuizSubmissionUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$QuizSubmissionPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>

    /**
     * Create or update one QuizSubmission.
     * @param {QuizSubmissionUpsertArgs} args - Arguments to update or create a QuizSubmission.
     * @example
     * // Update or create a QuizSubmission
     * const quizSubmission = await prisma.quizSubmission.upsert({
     *   create: {
     *     // ... data to create a QuizSubmission
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the QuizSubmission we want to update
     *   }
     * })
     */
    upsert<T extends QuizSubmissionUpsertArgs>(args: SelectSubset<T, QuizSubmissionUpsertArgs<ExtArgs>>): Prisma__QuizSubmissionClient<$Result.GetResult<Prisma.$QuizSubmissionPayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>


    /**
     * Count the number of QuizSubmissions.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {QuizSubmissionCountArgs} args - Arguments to filter QuizSubmissions to count.
     * @example
     * // Count the number of QuizSubmissions
     * const count = await prisma.quizSubmission.count({
     *   where: {
     *     // ... the filter for the QuizSubmissions we want to count
     *   }
     * })
    **/
    count<T extends QuizSubmissionCountArgs>(
      args?: Subset<T, QuizSubmissionCountArgs>,
    ): Prisma.PrismaPromise<
      T extends $Utils.Record<'select', any>
        ? T['select'] extends true
          ? number
          : GetScalarType<T['select'], QuizSubmissionCountAggregateOutputType>
        : number
    >

    /**
     * Allows you to perform aggregations operations on a QuizSubmission.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {QuizSubmissionAggregateArgs} 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 QuizSubmissionAggregateArgs>(args: Subset<T, QuizSubmissionAggregateArgs>): Prisma.PrismaPromise<GetQuizSubmissionAggregateType<T>>

    /**
     * Group by QuizSubmission.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {QuizSubmissionGroupByArgs} 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 QuizSubmissionGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: QuizSubmissionGroupByArgs['orderBy'] }
        : { orderBy?: QuizSubmissionGroupByArgs['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, QuizSubmissionGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetQuizSubmissionGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the QuizSubmission model
   */
  readonly fields: QuizSubmissionFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for QuizSubmission.
   * 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__QuizSubmissionClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    user<T extends UserDefaultArgs<ExtArgs> = {}>(args?: Subset<T, UserDefaultArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
    quiz<T extends DailyQuizDefaultArgs<ExtArgs> = {}>(args?: Subset<T, DailyQuizDefaultArgs<ExtArgs>>): Prisma__DailyQuizClient<$Result.GetResult<Prisma.$DailyQuizPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
    /**
     * 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 QuizSubmission model
   */
  interface QuizSubmissionFieldRefs {
    readonly id: FieldRef<"QuizSubmission", 'String'>
    readonly userId: FieldRef<"QuizSubmission", 'String'>
    readonly quizId: FieldRef<"QuizSubmission", 'String'>
    readonly answers: FieldRef<"QuizSubmission", 'Int[]'>
    readonly correctAnswers: FieldRef<"QuizSubmission", 'Int'>
    readonly score: FieldRef<"QuizSubmission", 'Int'>
    readonly submittedAt: FieldRef<"QuizSubmission", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * QuizSubmission findUnique
   */
  export type QuizSubmissionFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the QuizSubmission
     */
    select?: QuizSubmissionSelect<ExtArgs> | null
    /**
     * Omit specific fields from the QuizSubmission
     */
    omit?: QuizSubmissionOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: QuizSubmissionInclude<ExtArgs> | null
    /**
     * Filter, which QuizSubmission to fetch.
     */
    where: QuizSubmissionWhereUniqueInput
  }

  /**
   * QuizSubmission findUniqueOrThrow
   */
  export type QuizSubmissionFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the QuizSubmission
     */
    select?: QuizSubmissionSelect<ExtArgs> | null
    /**
     * Omit specific fields from the QuizSubmission
     */
    omit?: QuizSubmissionOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: QuizSubmissionInclude<ExtArgs> | null
    /**
     * Filter, which QuizSubmission to fetch.
     */
    where: QuizSubmissionWhereUniqueInput
  }

  /**
   * QuizSubmission findFirst
   */
  export type QuizSubmissionFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the QuizSubmission
     */
    select?: QuizSubmissionSelect<ExtArgs> | null
    /**
     * Omit specific fields from the QuizSubmission
     */
    omit?: QuizSubmissionOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: QuizSubmissionInclude<ExtArgs> | null
    /**
     * Filter, which QuizSubmission to fetch.
     */
    where?: QuizSubmissionWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of QuizSubmissions to fetch.
     */
    orderBy?: QuizSubmissionOrderByWithRelationInput | QuizSubmissionOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for QuizSubmissions.
     */
    cursor?: QuizSubmissionWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` QuizSubmissions 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` QuizSubmissions.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of QuizSubmissions.
     */
    distinct?: QuizSubmissionScalarFieldEnum | QuizSubmissionScalarFieldEnum[]
  }

  /**
   * QuizSubmission findFirstOrThrow
   */
  export type QuizSubmissionFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the QuizSubmission
     */
    select?: QuizSubmissionSelect<ExtArgs> | null
    /**
     * Omit specific fields from the QuizSubmission
     */
    omit?: QuizSubmissionOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: QuizSubmissionInclude<ExtArgs> | null
    /**
     * Filter, which QuizSubmission to fetch.
     */
    where?: QuizSubmissionWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of QuizSubmissions to fetch.
     */
    orderBy?: QuizSubmissionOrderByWithRelationInput | QuizSubmissionOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for QuizSubmissions.
     */
    cursor?: QuizSubmissionWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` QuizSubmissions 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` QuizSubmissions.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of QuizSubmissions.
     */
    distinct?: QuizSubmissionScalarFieldEnum | QuizSubmissionScalarFieldEnum[]
  }

  /**
   * QuizSubmission findMany
   */
  export type QuizSubmissionFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the QuizSubmission
     */
    select?: QuizSubmissionSelect<ExtArgs> | null
    /**
     * Omit specific fields from the QuizSubmission
     */
    omit?: QuizSubmissionOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: QuizSubmissionInclude<ExtArgs> | null
    /**
     * Filter, which QuizSubmissions to fetch.
     */
    where?: QuizSubmissionWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of QuizSubmissions to fetch.
     */
    orderBy?: QuizSubmissionOrderByWithRelationInput | QuizSubmissionOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing QuizSubmissions.
     */
    cursor?: QuizSubmissionWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` QuizSubmissions 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` QuizSubmissions.
     */
    skip?: number
    distinct?: QuizSubmissionScalarFieldEnum | QuizSubmissionScalarFieldEnum[]
  }

  /**
   * QuizSubmission create
   */
  export type QuizSubmissionCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the QuizSubmission
     */
    select?: QuizSubmissionSelect<ExtArgs> | null
    /**
     * Omit specific fields from the QuizSubmission
     */
    omit?: QuizSubmissionOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: QuizSubmissionInclude<ExtArgs> | null
    /**
     * The data needed to create a QuizSubmission.
     */
    data: XOR<QuizSubmissionCreateInput, QuizSubmissionUncheckedCreateInput>
  }

  /**
   * QuizSubmission createMany
   */
  export type QuizSubmissionCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many QuizSubmissions.
     */
    data: QuizSubmissionCreateManyInput | QuizSubmissionCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * QuizSubmission createManyAndReturn
   */
  export type QuizSubmissionCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the QuizSubmission
     */
    select?: QuizSubmissionSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the QuizSubmission
     */
    omit?: QuizSubmissionOmit<ExtArgs> | null
    /**
     * The data used to create many QuizSubmissions.
     */
    data: QuizSubmissionCreateManyInput | QuizSubmissionCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: QuizSubmissionIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * QuizSubmission update
   */
  export type QuizSubmissionUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the QuizSubmission
     */
    select?: QuizSubmissionSelect<ExtArgs> | null
    /**
     * Omit specific fields from the QuizSubmission
     */
    omit?: QuizSubmissionOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: QuizSubmissionInclude<ExtArgs> | null
    /**
     * The data needed to update a QuizSubmission.
     */
    data: XOR<QuizSubmissionUpdateInput, QuizSubmissionUncheckedUpdateInput>
    /**
     * Choose, which QuizSubmission to update.
     */
    where: QuizSubmissionWhereUniqueInput
  }

  /**
   * QuizSubmission updateMany
   */
  export type QuizSubmissionUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update QuizSubmissions.
     */
    data: XOR<QuizSubmissionUpdateManyMutationInput, QuizSubmissionUncheckedUpdateManyInput>
    /**
     * Filter which QuizSubmissions to update
     */
    where?: QuizSubmissionWhereInput
    /**
     * Limit how many QuizSubmissions to update.
     */
    limit?: number
  }

  /**
   * QuizSubmission updateManyAndReturn
   */
  export type QuizSubmissionUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the QuizSubmission
     */
    select?: QuizSubmissionSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the QuizSubmission
     */
    omit?: QuizSubmissionOmit<ExtArgs> | null
    /**
     * The data used to update QuizSubmissions.
     */
    data: XOR<QuizSubmissionUpdateManyMutationInput, QuizSubmissionUncheckedUpdateManyInput>
    /**
     * Filter which QuizSubmissions to update
     */
    where?: QuizSubmissionWhereInput
    /**
     * Limit how many QuizSubmissions to update.
     */
    limit?: number
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: QuizSubmissionIncludeUpdateManyAndReturn<ExtArgs> | null
  }

  /**
   * QuizSubmission upsert
   */
  export type QuizSubmissionUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the QuizSubmission
     */
    select?: QuizSubmissionSelect<ExtArgs> | null
    /**
     * Omit specific fields from the QuizSubmission
     */
    omit?: QuizSubmissionOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: QuizSubmissionInclude<ExtArgs> | null
    /**
     * The filter to search for the QuizSubmission to update in case it exists.
     */
    where: QuizSubmissionWhereUniqueInput
    /**
     * In case the QuizSubmission found by the `where` argument doesn't exist, create a new QuizSubmission with this data.
     */
    create: XOR<QuizSubmissionCreateInput, QuizSubmissionUncheckedCreateInput>
    /**
     * In case the QuizSubmission was found with the provided `where` argument, update it with this data.
     */
    update: XOR<QuizSubmissionUpdateInput, QuizSubmissionUncheckedUpdateInput>
  }

  /**
   * QuizSubmission delete
   */
  export type QuizSubmissionDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the QuizSubmission
     */
    select?: QuizSubmissionSelect<ExtArgs> | null
    /**
     * Omit specific fields from the QuizSubmission
     */
    omit?: QuizSubmissionOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: QuizSubmissionInclude<ExtArgs> | null
    /**
     * Filter which QuizSubmission to delete.
     */
    where: QuizSubmissionWhereUniqueInput
  }

  /**
   * QuizSubmission deleteMany
   */
  export type QuizSubmissionDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which QuizSubmissions to delete
     */
    where?: QuizSubmissionWhereInput
    /**
     * Limit how many QuizSubmissions to delete.
     */
    limit?: number
  }

  /**
   * QuizSubmission without action
   */
  export type QuizSubmissionDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the QuizSubmission
     */
    select?: QuizSubmissionSelect<ExtArgs> | null
    /**
     * Omit specific fields from the QuizSubmission
     */
    omit?: QuizSubmissionOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: QuizSubmissionInclude<ExtArgs> | null
  }


  /**
   * Model GoldenCard
   */

  export type AggregateGoldenCard = {
    _count: GoldenCardCountAggregateOutputType | null
    _min: GoldenCardMinAggregateOutputType | null
    _max: GoldenCardMaxAggregateOutputType | null
  }

  export type GoldenCardMinAggregateOutputType = {
    id: string | null
    userId: string | null
    quizId: string | null
    playerId: string | null
    cardTier: $Enums.CardTier | null
    status: $Enums.GoldenCardStatus | null
    state: $Enums.SpecialCardState | null
    acquiredDate: Date | null
    openedAt: Date | null
  }

  export type GoldenCardMaxAggregateOutputType = {
    id: string | null
    userId: string | null
    quizId: string | null
    playerId: string | null
    cardTier: $Enums.CardTier | null
    status: $Enums.GoldenCardStatus | null
    state: $Enums.SpecialCardState | null
    acquiredDate: Date | null
    openedAt: Date | null
  }

  export type GoldenCardCountAggregateOutputType = {
    id: number
    userId: number
    quizId: number
    playerId: number
    cardTier: number
    status: number
    state: number
    acquiredDate: number
    openedAt: number
    _all: number
  }


  export type GoldenCardMinAggregateInputType = {
    id?: true
    userId?: true
    quizId?: true
    playerId?: true
    cardTier?: true
    status?: true
    state?: true
    acquiredDate?: true
    openedAt?: true
  }

  export type GoldenCardMaxAggregateInputType = {
    id?: true
    userId?: true
    quizId?: true
    playerId?: true
    cardTier?: true
    status?: true
    state?: true
    acquiredDate?: true
    openedAt?: true
  }

  export type GoldenCardCountAggregateInputType = {
    id?: true
    userId?: true
    quizId?: true
    playerId?: true
    cardTier?: true
    status?: true
    state?: true
    acquiredDate?: true
    openedAt?: true
    _all?: true
  }

  export type GoldenCardAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which GoldenCard to aggregate.
     */
    where?: GoldenCardWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of GoldenCards to fetch.
     */
    orderBy?: GoldenCardOrderByWithRelationInput | GoldenCardOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: GoldenCardWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` GoldenCards 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` GoldenCards.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned GoldenCards
    **/
    _count?: true | GoldenCardCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: GoldenCardMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: GoldenCardMaxAggregateInputType
  }

  export type GetGoldenCardAggregateType<T extends GoldenCardAggregateArgs> = {
        [P in keyof T & keyof AggregateGoldenCard]: P extends '_count' | 'count'
      ? T[P] extends true
        ? number
        : GetScalarType<T[P], AggregateGoldenCard[P]>
      : GetScalarType<T[P], AggregateGoldenCard[P]>
  }




  export type GoldenCardGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: GoldenCardWhereInput
    orderBy?: GoldenCardOrderByWithAggregationInput | GoldenCardOrderByWithAggregationInput[]
    by: GoldenCardScalarFieldEnum[] | GoldenCardScalarFieldEnum
    having?: GoldenCardScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: GoldenCardCountAggregateInputType | true
    _min?: GoldenCardMinAggregateInputType
    _max?: GoldenCardMaxAggregateInputType
  }

  export type GoldenCardGroupByOutputType = {
    id: string
    userId: string
    quizId: string | null
    playerId: string
    cardTier: $Enums.CardTier
    status: $Enums.GoldenCardStatus
    state: $Enums.SpecialCardState
    acquiredDate: Date
    openedAt: Date | null
    _count: GoldenCardCountAggregateOutputType | null
    _min: GoldenCardMinAggregateOutputType | null
    _max: GoldenCardMaxAggregateOutputType | null
  }

  type GetGoldenCardGroupByPayload<T extends GoldenCardGroupByArgs> = Prisma.PrismaPromise<
    Array<
      PickEnumerable<GoldenCardGroupByOutputType, T['by']> &
        {
          [P in ((keyof T) & (keyof GoldenCardGroupByOutputType))]: P extends '_count'
            ? T[P] extends boolean
              ? number
              : GetScalarType<T[P], GoldenCardGroupByOutputType[P]>
            : GetScalarType<T[P], GoldenCardGroupByOutputType[P]>
        }
      >
    >


  export type GoldenCardSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    userId?: boolean
    quizId?: boolean
    playerId?: boolean
    cardTier?: boolean
    status?: boolean
    state?: boolean
    acquiredDate?: boolean
    openedAt?: boolean
    user?: boolean | UserDefaultArgs<ExtArgs>
    quiz?: boolean | GoldenCard$quizArgs<ExtArgs>
    player?: boolean | PlayerDefaultArgs<ExtArgs>
    teamPlayer?: boolean | GoldenCard$teamPlayerArgs<ExtArgs>
  }, ExtArgs["result"]["goldenCard"]>

  export type GoldenCardSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    userId?: boolean
    quizId?: boolean
    playerId?: boolean
    cardTier?: boolean
    status?: boolean
    state?: boolean
    acquiredDate?: boolean
    openedAt?: boolean
    user?: boolean | UserDefaultArgs<ExtArgs>
    quiz?: boolean | GoldenCard$quizArgs<ExtArgs>
    player?: boolean | PlayerDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["goldenCard"]>

  export type GoldenCardSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    userId?: boolean
    quizId?: boolean
    playerId?: boolean
    cardTier?: boolean
    status?: boolean
    state?: boolean
    acquiredDate?: boolean
    openedAt?: boolean
    user?: boolean | UserDefaultArgs<ExtArgs>
    quiz?: boolean | GoldenCard$quizArgs<ExtArgs>
    player?: boolean | PlayerDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["goldenCard"]>

  export type GoldenCardSelectScalar = {
    id?: boolean
    userId?: boolean
    quizId?: boolean
    playerId?: boolean
    cardTier?: boolean
    status?: boolean
    state?: boolean
    acquiredDate?: boolean
    openedAt?: boolean
  }

  export type GoldenCardOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "userId" | "quizId" | "playerId" | "cardTier" | "status" | "state" | "acquiredDate" | "openedAt", ExtArgs["result"]["goldenCard"]>
  export type GoldenCardInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
    quiz?: boolean | GoldenCard$quizArgs<ExtArgs>
    player?: boolean | PlayerDefaultArgs<ExtArgs>
    teamPlayer?: boolean | GoldenCard$teamPlayerArgs<ExtArgs>
  }
  export type GoldenCardIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
    quiz?: boolean | GoldenCard$quizArgs<ExtArgs>
    player?: boolean | PlayerDefaultArgs<ExtArgs>
  }
  export type GoldenCardIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
    quiz?: boolean | GoldenCard$quizArgs<ExtArgs>
    player?: boolean | PlayerDefaultArgs<ExtArgs>
  }

  export type $GoldenCardPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "GoldenCard"
    objects: {
      user: Prisma.$UserPayload<ExtArgs>
      quiz: Prisma.$DailyQuizPayload<ExtArgs> | null
      player: Prisma.$PlayerPayload<ExtArgs>
      teamPlayer: Prisma.$TeamPlayerPayload<ExtArgs> | null
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      userId: string
      quizId: string | null
      playerId: string
      cardTier: $Enums.CardTier
      status: $Enums.GoldenCardStatus
      state: $Enums.SpecialCardState
      acquiredDate: Date
      openedAt: Date | null
    }, ExtArgs["result"]["goldenCard"]>
    composites: {}
  }

  type GoldenCardGetPayload<S extends boolean | null | undefined | GoldenCardDefaultArgs> = $Result.GetResult<Prisma.$GoldenCardPayload, S>

  type GoldenCardCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
    Omit<GoldenCardFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
      select?: GoldenCardCountAggregateInputType | true
    }

  export interface GoldenCardDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> {
    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['GoldenCard'], meta: { name: 'GoldenCard' } }
    /**
     * Find zero or one GoldenCard that matches the filter.
     * @param {GoldenCardFindUniqueArgs} args - Arguments to find a GoldenCard
     * @example
     * // Get one GoldenCard
     * const goldenCard = await prisma.goldenCard.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUnique<T extends GoldenCardFindUniqueArgs>(args: SelectSubset<T, GoldenCardFindUniqueArgs<ExtArgs>>): Prisma__GoldenCardClient<$Result.GetResult<Prisma.$GoldenCardPayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find one GoldenCard that matches the filter or throw an error with `error.code='P2025'`
     * if no matches were found.
     * @param {GoldenCardFindUniqueOrThrowArgs} args - Arguments to find a GoldenCard
     * @example
     * // Get one GoldenCard
     * const goldenCard = await prisma.goldenCard.findUniqueOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUniqueOrThrow<T extends GoldenCardFindUniqueOrThrowArgs>(args: SelectSubset<T, GoldenCardFindUniqueOrThrowArgs<ExtArgs>>): Prisma__GoldenCardClient<$Result.GetResult<Prisma.$GoldenCardPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first GoldenCard 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 {GoldenCardFindFirstArgs} args - Arguments to find a GoldenCard
     * @example
     * // Get one GoldenCard
     * const goldenCard = await prisma.goldenCard.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends GoldenCardFindFirstArgs>(args?: SelectSubset<T, GoldenCardFindFirstArgs<ExtArgs>>): Prisma__GoldenCardClient<$Result.GetResult<Prisma.$GoldenCardPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first GoldenCard 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 {GoldenCardFindFirstOrThrowArgs} args - Arguments to find a GoldenCard
     * @example
     * // Get one GoldenCard
     * const goldenCard = await prisma.goldenCard.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends GoldenCardFindFirstOrThrowArgs>(args?: SelectSubset<T, GoldenCardFindFirstOrThrowArgs<ExtArgs>>): Prisma__GoldenCardClient<$Result.GetResult<Prisma.$GoldenCardPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find zero or more GoldenCards 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 {GoldenCardFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all GoldenCards
     * const goldenCards = await prisma.goldenCard.findMany()
     * 
     * // Get first 10 GoldenCards
     * const goldenCards = await prisma.goldenCard.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const goldenCardWithIdOnly = await prisma.goldenCard.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends GoldenCardFindManyArgs>(args?: SelectSubset<T, GoldenCardFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$GoldenCardPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>

    /**
     * Create a GoldenCard.
     * @param {GoldenCardCreateArgs} args - Arguments to create a GoldenCard.
     * @example
     * // Create one GoldenCard
     * const GoldenCard = await prisma.goldenCard.create({
     *   data: {
     *     // ... data to create a GoldenCard
     *   }
     * })
     * 
     */
    create<T extends GoldenCardCreateArgs>(args: SelectSubset<T, GoldenCardCreateArgs<ExtArgs>>): Prisma__GoldenCardClient<$Result.GetResult<Prisma.$GoldenCardPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Create many GoldenCards.
     * @param {GoldenCardCreateManyArgs} args - Arguments to create many GoldenCards.
     * @example
     * // Create many GoldenCards
     * const goldenCard = await prisma.goldenCard.createMany({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     *     
     */
    createMany<T extends GoldenCardCreateManyArgs>(args?: SelectSubset<T, GoldenCardCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create many GoldenCards and returns the data saved in the database.
     * @param {GoldenCardCreateManyAndReturnArgs} args - Arguments to create many GoldenCards.
     * @example
     * // Create many GoldenCards
     * const goldenCard = await prisma.goldenCard.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many GoldenCards and only return the `id`
     * const goldenCardWithIdOnly = await prisma.goldenCard.createManyAndReturn({
     *   select: { id: true },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    createManyAndReturn<T extends GoldenCardCreateManyAndReturnArgs>(args?: SelectSubset<T, GoldenCardCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$GoldenCardPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>

    /**
     * Delete a GoldenCard.
     * @param {GoldenCardDeleteArgs} args - Arguments to delete one GoldenCard.
     * @example
     * // Delete one GoldenCard
     * const GoldenCard = await prisma.goldenCard.delete({
     *   where: {
     *     // ... filter to delete one GoldenCard
     *   }
     * })
     * 
     */
    delete<T extends GoldenCardDeleteArgs>(args: SelectSubset<T, GoldenCardDeleteArgs<ExtArgs>>): Prisma__GoldenCardClient<$Result.GetResult<Prisma.$GoldenCardPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Update one GoldenCard.
     * @param {GoldenCardUpdateArgs} args - Arguments to update one GoldenCard.
     * @example
     * // Update one GoldenCard
     * const goldenCard = await prisma.goldenCard.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends GoldenCardUpdateArgs>(args: SelectSubset<T, GoldenCardUpdateArgs<ExtArgs>>): Prisma__GoldenCardClient<$Result.GetResult<Prisma.$GoldenCardPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Delete zero or more GoldenCards.
     * @param {GoldenCardDeleteManyArgs} args - Arguments to filter GoldenCards to delete.
     * @example
     * // Delete a few GoldenCards
     * const { count } = await prisma.goldenCard.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
     */
    deleteMany<T extends GoldenCardDeleteManyArgs>(args?: SelectSubset<T, GoldenCardDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more GoldenCards.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {GoldenCardUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many GoldenCards
     * const goldenCard = await prisma.goldenCard.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    updateMany<T extends GoldenCardUpdateManyArgs>(args: SelectSubset<T, GoldenCardUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more GoldenCards and returns the data updated in the database.
     * @param {GoldenCardUpdateManyAndReturnArgs} args - Arguments to update many GoldenCards.
     * @example
     * // Update many GoldenCards
     * const goldenCard = await prisma.goldenCard.updateManyAndReturn({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Update zero or more GoldenCards and only return the `id`
     * const goldenCardWithIdOnly = await prisma.goldenCard.updateManyAndReturn({
     *   select: { id: true },
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    updateManyAndReturn<T extends GoldenCardUpdateManyAndReturnArgs>(args: SelectSubset<T, GoldenCardUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$GoldenCardPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>

    /**
     * Create or update one GoldenCard.
     * @param {GoldenCardUpsertArgs} args - Arguments to update or create a GoldenCard.
     * @example
     * // Update or create a GoldenCard
     * const goldenCard = await prisma.goldenCard.upsert({
     *   create: {
     *     // ... data to create a GoldenCard
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the GoldenCard we want to update
     *   }
     * })
     */
    upsert<T extends GoldenCardUpsertArgs>(args: SelectSubset<T, GoldenCardUpsertArgs<ExtArgs>>): Prisma__GoldenCardClient<$Result.GetResult<Prisma.$GoldenCardPayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>


    /**
     * Count the number of GoldenCards.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {GoldenCardCountArgs} args - Arguments to filter GoldenCards to count.
     * @example
     * // Count the number of GoldenCards
     * const count = await prisma.goldenCard.count({
     *   where: {
     *     // ... the filter for the GoldenCards we want to count
     *   }
     * })
    **/
    count<T extends GoldenCardCountArgs>(
      args?: Subset<T, GoldenCardCountArgs>,
    ): Prisma.PrismaPromise<
      T extends $Utils.Record<'select', any>
        ? T['select'] extends true
          ? number
          : GetScalarType<T['select'], GoldenCardCountAggregateOutputType>
        : number
    >

    /**
     * Allows you to perform aggregations operations on a GoldenCard.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {GoldenCardAggregateArgs} 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 GoldenCardAggregateArgs>(args: Subset<T, GoldenCardAggregateArgs>): Prisma.PrismaPromise<GetGoldenCardAggregateType<T>>

    /**
     * Group by GoldenCard.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {GoldenCardGroupByArgs} 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 GoldenCardGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: GoldenCardGroupByArgs['orderBy'] }
        : { orderBy?: GoldenCardGroupByArgs['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, GoldenCardGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetGoldenCardGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the GoldenCard model
   */
  readonly fields: GoldenCardFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for GoldenCard.
   * 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__GoldenCardClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    user<T extends UserDefaultArgs<ExtArgs> = {}>(args?: Subset<T, UserDefaultArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
    quiz<T extends GoldenCard$quizArgs<ExtArgs> = {}>(args?: Subset<T, GoldenCard$quizArgs<ExtArgs>>): Prisma__DailyQuizClient<$Result.GetResult<Prisma.$DailyQuizPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
    player<T extends PlayerDefaultArgs<ExtArgs> = {}>(args?: Subset<T, PlayerDefaultArgs<ExtArgs>>): Prisma__PlayerClient<$Result.GetResult<Prisma.$PlayerPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
    teamPlayer<T extends GoldenCard$teamPlayerArgs<ExtArgs> = {}>(args?: Subset<T, GoldenCard$teamPlayerArgs<ExtArgs>>): Prisma__TeamPlayerClient<$Result.GetResult<Prisma.$TeamPlayerPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
    /**
     * 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 GoldenCard model
   */
  interface GoldenCardFieldRefs {
    readonly id: FieldRef<"GoldenCard", 'String'>
    readonly userId: FieldRef<"GoldenCard", 'String'>
    readonly quizId: FieldRef<"GoldenCard", 'String'>
    readonly playerId: FieldRef<"GoldenCard", 'String'>
    readonly cardTier: FieldRef<"GoldenCard", 'CardTier'>
    readonly status: FieldRef<"GoldenCard", 'GoldenCardStatus'>
    readonly state: FieldRef<"GoldenCard", 'SpecialCardState'>
    readonly acquiredDate: FieldRef<"GoldenCard", 'DateTime'>
    readonly openedAt: FieldRef<"GoldenCard", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * GoldenCard findUnique
   */
  export type GoldenCardFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the GoldenCard
     */
    select?: GoldenCardSelect<ExtArgs> | null
    /**
     * Omit specific fields from the GoldenCard
     */
    omit?: GoldenCardOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: GoldenCardInclude<ExtArgs> | null
    /**
     * Filter, which GoldenCard to fetch.
     */
    where: GoldenCardWhereUniqueInput
  }

  /**
   * GoldenCard findUniqueOrThrow
   */
  export type GoldenCardFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the GoldenCard
     */
    select?: GoldenCardSelect<ExtArgs> | null
    /**
     * Omit specific fields from the GoldenCard
     */
    omit?: GoldenCardOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: GoldenCardInclude<ExtArgs> | null
    /**
     * Filter, which GoldenCard to fetch.
     */
    where: GoldenCardWhereUniqueInput
  }

  /**
   * GoldenCard findFirst
   */
  export type GoldenCardFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the GoldenCard
     */
    select?: GoldenCardSelect<ExtArgs> | null
    /**
     * Omit specific fields from the GoldenCard
     */
    omit?: GoldenCardOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: GoldenCardInclude<ExtArgs> | null
    /**
     * Filter, which GoldenCard to fetch.
     */
    where?: GoldenCardWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of GoldenCards to fetch.
     */
    orderBy?: GoldenCardOrderByWithRelationInput | GoldenCardOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for GoldenCards.
     */
    cursor?: GoldenCardWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` GoldenCards 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` GoldenCards.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of GoldenCards.
     */
    distinct?: GoldenCardScalarFieldEnum | GoldenCardScalarFieldEnum[]
  }

  /**
   * GoldenCard findFirstOrThrow
   */
  export type GoldenCardFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the GoldenCard
     */
    select?: GoldenCardSelect<ExtArgs> | null
    /**
     * Omit specific fields from the GoldenCard
     */
    omit?: GoldenCardOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: GoldenCardInclude<ExtArgs> | null
    /**
     * Filter, which GoldenCard to fetch.
     */
    where?: GoldenCardWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of GoldenCards to fetch.
     */
    orderBy?: GoldenCardOrderByWithRelationInput | GoldenCardOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for GoldenCards.
     */
    cursor?: GoldenCardWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` GoldenCards 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` GoldenCards.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of GoldenCards.
     */
    distinct?: GoldenCardScalarFieldEnum | GoldenCardScalarFieldEnum[]
  }

  /**
   * GoldenCard findMany
   */
  export type GoldenCardFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the GoldenCard
     */
    select?: GoldenCardSelect<ExtArgs> | null
    /**
     * Omit specific fields from the GoldenCard
     */
    omit?: GoldenCardOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: GoldenCardInclude<ExtArgs> | null
    /**
     * Filter, which GoldenCards to fetch.
     */
    where?: GoldenCardWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of GoldenCards to fetch.
     */
    orderBy?: GoldenCardOrderByWithRelationInput | GoldenCardOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing GoldenCards.
     */
    cursor?: GoldenCardWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` GoldenCards 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` GoldenCards.
     */
    skip?: number
    distinct?: GoldenCardScalarFieldEnum | GoldenCardScalarFieldEnum[]
  }

  /**
   * GoldenCard create
   */
  export type GoldenCardCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the GoldenCard
     */
    select?: GoldenCardSelect<ExtArgs> | null
    /**
     * Omit specific fields from the GoldenCard
     */
    omit?: GoldenCardOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: GoldenCardInclude<ExtArgs> | null
    /**
     * The data needed to create a GoldenCard.
     */
    data: XOR<GoldenCardCreateInput, GoldenCardUncheckedCreateInput>
  }

  /**
   * GoldenCard createMany
   */
  export type GoldenCardCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many GoldenCards.
     */
    data: GoldenCardCreateManyInput | GoldenCardCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * GoldenCard createManyAndReturn
   */
  export type GoldenCardCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the GoldenCard
     */
    select?: GoldenCardSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the GoldenCard
     */
    omit?: GoldenCardOmit<ExtArgs> | null
    /**
     * The data used to create many GoldenCards.
     */
    data: GoldenCardCreateManyInput | GoldenCardCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: GoldenCardIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * GoldenCard update
   */
  export type GoldenCardUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the GoldenCard
     */
    select?: GoldenCardSelect<ExtArgs> | null
    /**
     * Omit specific fields from the GoldenCard
     */
    omit?: GoldenCardOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: GoldenCardInclude<ExtArgs> | null
    /**
     * The data needed to update a GoldenCard.
     */
    data: XOR<GoldenCardUpdateInput, GoldenCardUncheckedUpdateInput>
    /**
     * Choose, which GoldenCard to update.
     */
    where: GoldenCardWhereUniqueInput
  }

  /**
   * GoldenCard updateMany
   */
  export type GoldenCardUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update GoldenCards.
     */
    data: XOR<GoldenCardUpdateManyMutationInput, GoldenCardUncheckedUpdateManyInput>
    /**
     * Filter which GoldenCards to update
     */
    where?: GoldenCardWhereInput
    /**
     * Limit how many GoldenCards to update.
     */
    limit?: number
  }

  /**
   * GoldenCard updateManyAndReturn
   */
  export type GoldenCardUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the GoldenCard
     */
    select?: GoldenCardSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the GoldenCard
     */
    omit?: GoldenCardOmit<ExtArgs> | null
    /**
     * The data used to update GoldenCards.
     */
    data: XOR<GoldenCardUpdateManyMutationInput, GoldenCardUncheckedUpdateManyInput>
    /**
     * Filter which GoldenCards to update
     */
    where?: GoldenCardWhereInput
    /**
     * Limit how many GoldenCards to update.
     */
    limit?: number
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: GoldenCardIncludeUpdateManyAndReturn<ExtArgs> | null
  }

  /**
   * GoldenCard upsert
   */
  export type GoldenCardUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the GoldenCard
     */
    select?: GoldenCardSelect<ExtArgs> | null
    /**
     * Omit specific fields from the GoldenCard
     */
    omit?: GoldenCardOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: GoldenCardInclude<ExtArgs> | null
    /**
     * The filter to search for the GoldenCard to update in case it exists.
     */
    where: GoldenCardWhereUniqueInput
    /**
     * In case the GoldenCard found by the `where` argument doesn't exist, create a new GoldenCard with this data.
     */
    create: XOR<GoldenCardCreateInput, GoldenCardUncheckedCreateInput>
    /**
     * In case the GoldenCard was found with the provided `where` argument, update it with this data.
     */
    update: XOR<GoldenCardUpdateInput, GoldenCardUncheckedUpdateInput>
  }

  /**
   * GoldenCard delete
   */
  export type GoldenCardDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the GoldenCard
     */
    select?: GoldenCardSelect<ExtArgs> | null
    /**
     * Omit specific fields from the GoldenCard
     */
    omit?: GoldenCardOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: GoldenCardInclude<ExtArgs> | null
    /**
     * Filter which GoldenCard to delete.
     */
    where: GoldenCardWhereUniqueInput
  }

  /**
   * GoldenCard deleteMany
   */
  export type GoldenCardDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which GoldenCards to delete
     */
    where?: GoldenCardWhereInput
    /**
     * Limit how many GoldenCards to delete.
     */
    limit?: number
  }

  /**
   * GoldenCard.quiz
   */
  export type GoldenCard$quizArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the DailyQuiz
     */
    select?: DailyQuizSelect<ExtArgs> | null
    /**
     * Omit specific fields from the DailyQuiz
     */
    omit?: DailyQuizOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: DailyQuizInclude<ExtArgs> | null
    where?: DailyQuizWhereInput
  }

  /**
   * GoldenCard.teamPlayer
   */
  export type GoldenCard$teamPlayerArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TeamPlayer
     */
    select?: TeamPlayerSelect<ExtArgs> | null
    /**
     * Omit specific fields from the TeamPlayer
     */
    omit?: TeamPlayerOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TeamPlayerInclude<ExtArgs> | null
    where?: TeamPlayerWhereInput
  }

  /**
   * GoldenCard without action
   */
  export type GoldenCardDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the GoldenCard
     */
    select?: GoldenCardSelect<ExtArgs> | null
    /**
     * Omit specific fields from the GoldenCard
     */
    omit?: GoldenCardOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: GoldenCardInclude<ExtArgs> | null
  }


  /**
   * Model Session
   */

  export type AggregateSession = {
    _count: SessionCountAggregateOutputType | null
    _min: SessionMinAggregateOutputType | null
    _max: SessionMaxAggregateOutputType | null
  }

  export type SessionMinAggregateOutputType = {
    id: string | null
    sessionToken: string | null
    userId: string | null
    expires: Date | null
  }

  export type SessionMaxAggregateOutputType = {
    id: string | null
    sessionToken: string | null
    userId: string | null
    expires: Date | null
  }

  export type SessionCountAggregateOutputType = {
    id: number
    sessionToken: number
    userId: number
    expires: number
    _all: number
  }


  export type SessionMinAggregateInputType = {
    id?: true
    sessionToken?: true
    userId?: true
    expires?: true
  }

  export type SessionMaxAggregateInputType = {
    id?: true
    sessionToken?: true
    userId?: true
    expires?: true
  }

  export type SessionCountAggregateInputType = {
    id?: true
    sessionToken?: true
    userId?: true
    expires?: true
    _all?: true
  }

  export type SessionAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Session to aggregate.
     */
    where?: SessionWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Sessions to fetch.
     */
    orderBy?: SessionOrderByWithRelationInput | SessionOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: SessionWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Sessions 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` Sessions.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned Sessions
    **/
    _count?: true | SessionCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: SessionMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: SessionMaxAggregateInputType
  }

  export type GetSessionAggregateType<T extends SessionAggregateArgs> = {
        [P in keyof T & keyof AggregateSession]: P extends '_count' | 'count'
      ? T[P] extends true
        ? number
        : GetScalarType<T[P], AggregateSession[P]>
      : GetScalarType<T[P], AggregateSession[P]>
  }




  export type SessionGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: SessionWhereInput
    orderBy?: SessionOrderByWithAggregationInput | SessionOrderByWithAggregationInput[]
    by: SessionScalarFieldEnum[] | SessionScalarFieldEnum
    having?: SessionScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: SessionCountAggregateInputType | true
    _min?: SessionMinAggregateInputType
    _max?: SessionMaxAggregateInputType
  }

  export type SessionGroupByOutputType = {
    id: string
    sessionToken: string
    userId: string
    expires: Date
    _count: SessionCountAggregateOutputType | null
    _min: SessionMinAggregateOutputType | null
    _max: SessionMaxAggregateOutputType | null
  }

  type GetSessionGroupByPayload<T extends SessionGroupByArgs> = Prisma.PrismaPromise<
    Array<
      PickEnumerable<SessionGroupByOutputType, T['by']> &
        {
          [P in ((keyof T) & (keyof SessionGroupByOutputType))]: P extends '_count'
            ? T[P] extends boolean
              ? number
              : GetScalarType<T[P], SessionGroupByOutputType[P]>
            : GetScalarType<T[P], SessionGroupByOutputType[P]>
        }
      >
    >


  export type SessionSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    sessionToken?: boolean
    userId?: boolean
    expires?: boolean
    user?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["session"]>

  export type SessionSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    sessionToken?: boolean
    userId?: boolean
    expires?: boolean
    user?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["session"]>

  export type SessionSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    sessionToken?: boolean
    userId?: boolean
    expires?: boolean
    user?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["session"]>

  export type SessionSelectScalar = {
    id?: boolean
    sessionToken?: boolean
    userId?: boolean
    expires?: boolean
  }

  export type SessionOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "sessionToken" | "userId" | "expires", ExtArgs["result"]["session"]>
  export type SessionInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
  }
  export type SessionIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
  }
  export type SessionIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
  }

  export type $SessionPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Session"
    objects: {
      user: Prisma.$UserPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      sessionToken: string
      userId: string
      expires: Date
    }, ExtArgs["result"]["session"]>
    composites: {}
  }

  type SessionGetPayload<S extends boolean | null | undefined | SessionDefaultArgs> = $Result.GetResult<Prisma.$SessionPayload, S>

  type SessionCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
    Omit<SessionFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
      select?: SessionCountAggregateInputType | true
    }

  export interface SessionDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> {
    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['Session'], meta: { name: 'Session' } }
    /**
     * Find zero or one Session that matches the filter.
     * @param {SessionFindUniqueArgs} args - Arguments to find a Session
     * @example
     * // Get one Session
     * const session = await prisma.session.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUnique<T extends SessionFindUniqueArgs>(args: SelectSubset<T, SessionFindUniqueArgs<ExtArgs>>): Prisma__SessionClient<$Result.GetResult<Prisma.$SessionPayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find one Session that matches the filter or throw an error with `error.code='P2025'`
     * if no matches were found.
     * @param {SessionFindUniqueOrThrowArgs} args - Arguments to find a Session
     * @example
     * // Get one Session
     * const session = await prisma.session.findUniqueOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUniqueOrThrow<T extends SessionFindUniqueOrThrowArgs>(args: SelectSubset<T, SessionFindUniqueOrThrowArgs<ExtArgs>>): Prisma__SessionClient<$Result.GetResult<Prisma.$SessionPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first Session 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 {SessionFindFirstArgs} args - Arguments to find a Session
     * @example
     * // Get one Session
     * const session = await prisma.session.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends SessionFindFirstArgs>(args?: SelectSubset<T, SessionFindFirstArgs<ExtArgs>>): Prisma__SessionClient<$Result.GetResult<Prisma.$SessionPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first Session 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 {SessionFindFirstOrThrowArgs} args - Arguments to find a Session
     * @example
     * // Get one Session
     * const session = await prisma.session.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends SessionFindFirstOrThrowArgs>(args?: SelectSubset<T, SessionFindFirstOrThrowArgs<ExtArgs>>): Prisma__SessionClient<$Result.GetResult<Prisma.$SessionPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find zero or more Sessions 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 {SessionFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all Sessions
     * const sessions = await prisma.session.findMany()
     * 
     * // Get first 10 Sessions
     * const sessions = await prisma.session.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const sessionWithIdOnly = await prisma.session.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends SessionFindManyArgs>(args?: SelectSubset<T, SessionFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$SessionPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>

    /**
     * Create a Session.
     * @param {SessionCreateArgs} args - Arguments to create a Session.
     * @example
     * // Create one Session
     * const Session = await prisma.session.create({
     *   data: {
     *     // ... data to create a Session
     *   }
     * })
     * 
     */
    create<T extends SessionCreateArgs>(args: SelectSubset<T, SessionCreateArgs<ExtArgs>>): Prisma__SessionClient<$Result.GetResult<Prisma.$SessionPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Create many Sessions.
     * @param {SessionCreateManyArgs} args - Arguments to create many Sessions.
     * @example
     * // Create many Sessions
     * const session = await prisma.session.createMany({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     *     
     */
    createMany<T extends SessionCreateManyArgs>(args?: SelectSubset<T, SessionCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create many Sessions and returns the data saved in the database.
     * @param {SessionCreateManyAndReturnArgs} args - Arguments to create many Sessions.
     * @example
     * // Create many Sessions
     * const session = await prisma.session.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many Sessions and only return the `id`
     * const sessionWithIdOnly = await prisma.session.createManyAndReturn({
     *   select: { id: true },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    createManyAndReturn<T extends SessionCreateManyAndReturnArgs>(args?: SelectSubset<T, SessionCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$SessionPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>

    /**
     * Delete a Session.
     * @param {SessionDeleteArgs} args - Arguments to delete one Session.
     * @example
     * // Delete one Session
     * const Session = await prisma.session.delete({
     *   where: {
     *     // ... filter to delete one Session
     *   }
     * })
     * 
     */
    delete<T extends SessionDeleteArgs>(args: SelectSubset<T, SessionDeleteArgs<ExtArgs>>): Prisma__SessionClient<$Result.GetResult<Prisma.$SessionPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Update one Session.
     * @param {SessionUpdateArgs} args - Arguments to update one Session.
     * @example
     * // Update one Session
     * const session = await prisma.session.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends SessionUpdateArgs>(args: SelectSubset<T, SessionUpdateArgs<ExtArgs>>): Prisma__SessionClient<$Result.GetResult<Prisma.$SessionPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Delete zero or more Sessions.
     * @param {SessionDeleteManyArgs} args - Arguments to filter Sessions to delete.
     * @example
     * // Delete a few Sessions
     * const { count } = await prisma.session.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
     */
    deleteMany<T extends SessionDeleteManyArgs>(args?: SelectSubset<T, SessionDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more Sessions.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {SessionUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many Sessions
     * const session = await prisma.session.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    updateMany<T extends SessionUpdateManyArgs>(args: SelectSubset<T, SessionUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more Sessions and returns the data updated in the database.
     * @param {SessionUpdateManyAndReturnArgs} args - Arguments to update many Sessions.
     * @example
     * // Update many Sessions
     * const session = await prisma.session.updateManyAndReturn({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Update zero or more Sessions and only return the `id`
     * const sessionWithIdOnly = await prisma.session.updateManyAndReturn({
     *   select: { id: true },
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    updateManyAndReturn<T extends SessionUpdateManyAndReturnArgs>(args: SelectSubset<T, SessionUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$SessionPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>

    /**
     * Create or update one Session.
     * @param {SessionUpsertArgs} args - Arguments to update or create a Session.
     * @example
     * // Update or create a Session
     * const session = await prisma.session.upsert({
     *   create: {
     *     // ... data to create a Session
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the Session we want to update
     *   }
     * })
     */
    upsert<T extends SessionUpsertArgs>(args: SelectSubset<T, SessionUpsertArgs<ExtArgs>>): Prisma__SessionClient<$Result.GetResult<Prisma.$SessionPayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>


    /**
     * Count the number of Sessions.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {SessionCountArgs} args - Arguments to filter Sessions to count.
     * @example
     * // Count the number of Sessions
     * const count = await prisma.session.count({
     *   where: {
     *     // ... the filter for the Sessions we want to count
     *   }
     * })
    **/
    count<T extends SessionCountArgs>(
      args?: Subset<T, SessionCountArgs>,
    ): Prisma.PrismaPromise<
      T extends $Utils.Record<'select', any>
        ? T['select'] extends true
          ? number
          : GetScalarType<T['select'], SessionCountAggregateOutputType>
        : number
    >

    /**
     * Allows you to perform aggregations operations on a Session.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {SessionAggregateArgs} 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 SessionAggregateArgs>(args: Subset<T, SessionAggregateArgs>): Prisma.PrismaPromise<GetSessionAggregateType<T>>

    /**
     * Group by Session.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {SessionGroupByArgs} 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 SessionGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: SessionGroupByArgs['orderBy'] }
        : { orderBy?: SessionGroupByArgs['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, SessionGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetSessionGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the Session model
   */
  readonly fields: SessionFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for Session.
   * 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__SessionClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    user<T extends UserDefaultArgs<ExtArgs> = {}>(args?: Subset<T, UserDefaultArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
    /**
     * 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 Session model
   */
  interface SessionFieldRefs {
    readonly id: FieldRef<"Session", 'String'>
    readonly sessionToken: FieldRef<"Session", 'String'>
    readonly userId: FieldRef<"Session", 'String'>
    readonly expires: FieldRef<"Session", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * Session findUnique
   */
  export type SessionFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Session
     */
    select?: SessionSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Session
     */
    omit?: SessionOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SessionInclude<ExtArgs> | null
    /**
     * Filter, which Session to fetch.
     */
    where: SessionWhereUniqueInput
  }

  /**
   * Session findUniqueOrThrow
   */
  export type SessionFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Session
     */
    select?: SessionSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Session
     */
    omit?: SessionOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SessionInclude<ExtArgs> | null
    /**
     * Filter, which Session to fetch.
     */
    where: SessionWhereUniqueInput
  }

  /**
   * Session findFirst
   */
  export type SessionFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Session
     */
    select?: SessionSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Session
     */
    omit?: SessionOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SessionInclude<ExtArgs> | null
    /**
     * Filter, which Session to fetch.
     */
    where?: SessionWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Sessions to fetch.
     */
    orderBy?: SessionOrderByWithRelationInput | SessionOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Sessions.
     */
    cursor?: SessionWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Sessions 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` Sessions.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Sessions.
     */
    distinct?: SessionScalarFieldEnum | SessionScalarFieldEnum[]
  }

  /**
   * Session findFirstOrThrow
   */
  export type SessionFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Session
     */
    select?: SessionSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Session
     */
    omit?: SessionOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SessionInclude<ExtArgs> | null
    /**
     * Filter, which Session to fetch.
     */
    where?: SessionWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Sessions to fetch.
     */
    orderBy?: SessionOrderByWithRelationInput | SessionOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Sessions.
     */
    cursor?: SessionWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Sessions 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` Sessions.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Sessions.
     */
    distinct?: SessionScalarFieldEnum | SessionScalarFieldEnum[]
  }

  /**
   * Session findMany
   */
  export type SessionFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Session
     */
    select?: SessionSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Session
     */
    omit?: SessionOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SessionInclude<ExtArgs> | null
    /**
     * Filter, which Sessions to fetch.
     */
    where?: SessionWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Sessions to fetch.
     */
    orderBy?: SessionOrderByWithRelationInput | SessionOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing Sessions.
     */
    cursor?: SessionWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Sessions 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` Sessions.
     */
    skip?: number
    distinct?: SessionScalarFieldEnum | SessionScalarFieldEnum[]
  }

  /**
   * Session create
   */
  export type SessionCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Session
     */
    select?: SessionSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Session
     */
    omit?: SessionOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SessionInclude<ExtArgs> | null
    /**
     * The data needed to create a Session.
     */
    data: XOR<SessionCreateInput, SessionUncheckedCreateInput>
  }

  /**
   * Session createMany
   */
  export type SessionCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many Sessions.
     */
    data: SessionCreateManyInput | SessionCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * Session createManyAndReturn
   */
  export type SessionCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Session
     */
    select?: SessionSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the Session
     */
    omit?: SessionOmit<ExtArgs> | null
    /**
     * The data used to create many Sessions.
     */
    data: SessionCreateManyInput | SessionCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SessionIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * Session update
   */
  export type SessionUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Session
     */
    select?: SessionSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Session
     */
    omit?: SessionOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SessionInclude<ExtArgs> | null
    /**
     * The data needed to update a Session.
     */
    data: XOR<SessionUpdateInput, SessionUncheckedUpdateInput>
    /**
     * Choose, which Session to update.
     */
    where: SessionWhereUniqueInput
  }

  /**
   * Session updateMany
   */
  export type SessionUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Sessions.
     */
    data: XOR<SessionUpdateManyMutationInput, SessionUncheckedUpdateManyInput>
    /**
     * Filter which Sessions to update
     */
    where?: SessionWhereInput
    /**
     * Limit how many Sessions to update.
     */
    limit?: number
  }

  /**
   * Session updateManyAndReturn
   */
  export type SessionUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Session
     */
    select?: SessionSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the Session
     */
    omit?: SessionOmit<ExtArgs> | null
    /**
     * The data used to update Sessions.
     */
    data: XOR<SessionUpdateManyMutationInput, SessionUncheckedUpdateManyInput>
    /**
     * Filter which Sessions to update
     */
    where?: SessionWhereInput
    /**
     * Limit how many Sessions to update.
     */
    limit?: number
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SessionIncludeUpdateManyAndReturn<ExtArgs> | null
  }

  /**
   * Session upsert
   */
  export type SessionUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Session
     */
    select?: SessionSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Session
     */
    omit?: SessionOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SessionInclude<ExtArgs> | null
    /**
     * The filter to search for the Session to update in case it exists.
     */
    where: SessionWhereUniqueInput
    /**
     * In case the Session found by the `where` argument doesn't exist, create a new Session with this data.
     */
    create: XOR<SessionCreateInput, SessionUncheckedCreateInput>
    /**
     * In case the Session was found with the provided `where` argument, update it with this data.
     */
    update: XOR<SessionUpdateInput, SessionUncheckedUpdateInput>
  }

  /**
   * Session delete
   */
  export type SessionDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Session
     */
    select?: SessionSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Session
     */
    omit?: SessionOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SessionInclude<ExtArgs> | null
    /**
     * Filter which Session to delete.
     */
    where: SessionWhereUniqueInput
  }

  /**
   * Session deleteMany
   */
  export type SessionDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Sessions to delete
     */
    where?: SessionWhereInput
    /**
     * Limit how many Sessions to delete.
     */
    limit?: number
  }

  /**
   * Session without action
   */
  export type SessionDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Session
     */
    select?: SessionSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Session
     */
    omit?: SessionOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SessionInclude<ExtArgs> | null
  }


  /**
   * Model Team
   */

  export type AggregateTeam = {
    _count: TeamCountAggregateOutputType | null
    _avg: TeamAvgAggregateOutputType | null
    _sum: TeamSumAggregateOutputType | null
    _min: TeamMinAggregateOutputType | null
    _max: TeamMaxAggregateOutputType | null
  }

  export type TeamAvgAggregateOutputType = {
    budget: number | null
    totalPoints: number | null
  }

  export type TeamSumAggregateOutputType = {
    budget: number | null
    totalPoints: number | null
  }

  export type TeamMinAggregateOutputType = {
    id: string | null
    name: string | null
    userId: string | null
    budget: number | null
    totalPoints: number | null
    formation: string | null
    status: $Enums.TeamStatus | null
    createdAt: Date | null
  }

  export type TeamMaxAggregateOutputType = {
    id: string | null
    name: string | null
    userId: string | null
    budget: number | null
    totalPoints: number | null
    formation: string | null
    status: $Enums.TeamStatus | null
    createdAt: Date | null
  }

  export type TeamCountAggregateOutputType = {
    id: number
    name: number
    userId: number
    budget: number
    totalPoints: number
    formation: number
    status: number
    createdAt: number
    _all: number
  }


  export type TeamAvgAggregateInputType = {
    budget?: true
    totalPoints?: true
  }

  export type TeamSumAggregateInputType = {
    budget?: true
    totalPoints?: true
  }

  export type TeamMinAggregateInputType = {
    id?: true
    name?: true
    userId?: true
    budget?: true
    totalPoints?: true
    formation?: true
    status?: true
    createdAt?: true
  }

  export type TeamMaxAggregateInputType = {
    id?: true
    name?: true
    userId?: true
    budget?: true
    totalPoints?: true
    formation?: true
    status?: true
    createdAt?: true
  }

  export type TeamCountAggregateInputType = {
    id?: true
    name?: true
    userId?: true
    budget?: true
    totalPoints?: true
    formation?: true
    status?: true
    createdAt?: true
    _all?: true
  }

  export type TeamAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Team to aggregate.
     */
    where?: TeamWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Teams to fetch.
     */
    orderBy?: TeamOrderByWithRelationInput | TeamOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: TeamWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Teams 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` Teams.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned Teams
    **/
    _count?: true | TeamCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: TeamAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: TeamSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: TeamMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: TeamMaxAggregateInputType
  }

  export type GetTeamAggregateType<T extends TeamAggregateArgs> = {
        [P in keyof T & keyof AggregateTeam]: P extends '_count' | 'count'
      ? T[P] extends true
        ? number
        : GetScalarType<T[P], AggregateTeam[P]>
      : GetScalarType<T[P], AggregateTeam[P]>
  }




  export type TeamGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: TeamWhereInput
    orderBy?: TeamOrderByWithAggregationInput | TeamOrderByWithAggregationInput[]
    by: TeamScalarFieldEnum[] | TeamScalarFieldEnum
    having?: TeamScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: TeamCountAggregateInputType | true
    _avg?: TeamAvgAggregateInputType
    _sum?: TeamSumAggregateInputType
    _min?: TeamMinAggregateInputType
    _max?: TeamMaxAggregateInputType
  }

  export type TeamGroupByOutputType = {
    id: string
    name: string
    userId: string
    budget: number
    totalPoints: number
    formation: string
    status: $Enums.TeamStatus
    createdAt: Date
    _count: TeamCountAggregateOutputType | null
    _avg: TeamAvgAggregateOutputType | null
    _sum: TeamSumAggregateOutputType | null
    _min: TeamMinAggregateOutputType | null
    _max: TeamMaxAggregateOutputType | null
  }

  type GetTeamGroupByPayload<T extends TeamGroupByArgs> = Prisma.PrismaPromise<
    Array<
      PickEnumerable<TeamGroupByOutputType, T['by']> &
        {
          [P in ((keyof T) & (keyof TeamGroupByOutputType))]: P extends '_count'
            ? T[P] extends boolean
              ? number
              : GetScalarType<T[P], TeamGroupByOutputType[P]>
            : GetScalarType<T[P], TeamGroupByOutputType[P]>
        }
      >
    >


  export type TeamSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
    userId?: boolean
    budget?: boolean
    totalPoints?: boolean
    formation?: boolean
    status?: boolean
    createdAt?: boolean
    user?: boolean | UserDefaultArgs<ExtArgs>
    players?: boolean | Team$playersArgs<ExtArgs>
    _count?: boolean | TeamCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["team"]>

  export type TeamSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
    userId?: boolean
    budget?: boolean
    totalPoints?: boolean
    formation?: boolean
    status?: boolean
    createdAt?: boolean
    user?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["team"]>

  export type TeamSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
    userId?: boolean
    budget?: boolean
    totalPoints?: boolean
    formation?: boolean
    status?: boolean
    createdAt?: boolean
    user?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["team"]>

  export type TeamSelectScalar = {
    id?: boolean
    name?: boolean
    userId?: boolean
    budget?: boolean
    totalPoints?: boolean
    formation?: boolean
    status?: boolean
    createdAt?: boolean
  }

  export type TeamOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "name" | "userId" | "budget" | "totalPoints" | "formation" | "status" | "createdAt", ExtArgs["result"]["team"]>
  export type TeamInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
    players?: boolean | Team$playersArgs<ExtArgs>
    _count?: boolean | TeamCountOutputTypeDefaultArgs<ExtArgs>
  }
  export type TeamIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
  }
  export type TeamIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
  }

  export type $TeamPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Team"
    objects: {
      user: Prisma.$UserPayload<ExtArgs>
      players: Prisma.$TeamPlayerPayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      name: string
      userId: string
      budget: number
      totalPoints: number
      formation: string
      status: $Enums.TeamStatus
      createdAt: Date
    }, ExtArgs["result"]["team"]>
    composites: {}
  }

  type TeamGetPayload<S extends boolean | null | undefined | TeamDefaultArgs> = $Result.GetResult<Prisma.$TeamPayload, S>

  type TeamCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
    Omit<TeamFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
      select?: TeamCountAggregateInputType | true
    }

  export interface TeamDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> {
    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['Team'], meta: { name: 'Team' } }
    /**
     * Find zero or one Team that matches the filter.
     * @param {TeamFindUniqueArgs} args - Arguments to find a Team
     * @example
     * // Get one Team
     * const team = await prisma.team.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUnique<T extends TeamFindUniqueArgs>(args: SelectSubset<T, TeamFindUniqueArgs<ExtArgs>>): Prisma__TeamClient<$Result.GetResult<Prisma.$TeamPayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find one Team that matches the filter or throw an error with `error.code='P2025'`
     * if no matches were found.
     * @param {TeamFindUniqueOrThrowArgs} args - Arguments to find a Team
     * @example
     * // Get one Team
     * const team = await prisma.team.findUniqueOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUniqueOrThrow<T extends TeamFindUniqueOrThrowArgs>(args: SelectSubset<T, TeamFindUniqueOrThrowArgs<ExtArgs>>): Prisma__TeamClient<$Result.GetResult<Prisma.$TeamPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first Team 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 {TeamFindFirstArgs} args - Arguments to find a Team
     * @example
     * // Get one Team
     * const team = await prisma.team.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends TeamFindFirstArgs>(args?: SelectSubset<T, TeamFindFirstArgs<ExtArgs>>): Prisma__TeamClient<$Result.GetResult<Prisma.$TeamPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first Team 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 {TeamFindFirstOrThrowArgs} args - Arguments to find a Team
     * @example
     * // Get one Team
     * const team = await prisma.team.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends TeamFindFirstOrThrowArgs>(args?: SelectSubset<T, TeamFindFirstOrThrowArgs<ExtArgs>>): Prisma__TeamClient<$Result.GetResult<Prisma.$TeamPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find zero or more Teams 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 {TeamFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all Teams
     * const teams = await prisma.team.findMany()
     * 
     * // Get first 10 Teams
     * const teams = await prisma.team.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const teamWithIdOnly = await prisma.team.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends TeamFindManyArgs>(args?: SelectSubset<T, TeamFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$TeamPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>

    /**
     * Create a Team.
     * @param {TeamCreateArgs} args - Arguments to create a Team.
     * @example
     * // Create one Team
     * const Team = await prisma.team.create({
     *   data: {
     *     // ... data to create a Team
     *   }
     * })
     * 
     */
    create<T extends TeamCreateArgs>(args: SelectSubset<T, TeamCreateArgs<ExtArgs>>): Prisma__TeamClient<$Result.GetResult<Prisma.$TeamPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Create many Teams.
     * @param {TeamCreateManyArgs} args - Arguments to create many Teams.
     * @example
     * // Create many Teams
     * const team = await prisma.team.createMany({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     *     
     */
    createMany<T extends TeamCreateManyArgs>(args?: SelectSubset<T, TeamCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create many Teams and returns the data saved in the database.
     * @param {TeamCreateManyAndReturnArgs} args - Arguments to create many Teams.
     * @example
     * // Create many Teams
     * const team = await prisma.team.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many Teams and only return the `id`
     * const teamWithIdOnly = await prisma.team.createManyAndReturn({
     *   select: { id: true },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    createManyAndReturn<T extends TeamCreateManyAndReturnArgs>(args?: SelectSubset<T, TeamCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$TeamPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>

    /**
     * Delete a Team.
     * @param {TeamDeleteArgs} args - Arguments to delete one Team.
     * @example
     * // Delete one Team
     * const Team = await prisma.team.delete({
     *   where: {
     *     // ... filter to delete one Team
     *   }
     * })
     * 
     */
    delete<T extends TeamDeleteArgs>(args: SelectSubset<T, TeamDeleteArgs<ExtArgs>>): Prisma__TeamClient<$Result.GetResult<Prisma.$TeamPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Update one Team.
     * @param {TeamUpdateArgs} args - Arguments to update one Team.
     * @example
     * // Update one Team
     * const team = await prisma.team.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends TeamUpdateArgs>(args: SelectSubset<T, TeamUpdateArgs<ExtArgs>>): Prisma__TeamClient<$Result.GetResult<Prisma.$TeamPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Delete zero or more Teams.
     * @param {TeamDeleteManyArgs} args - Arguments to filter Teams to delete.
     * @example
     * // Delete a few Teams
     * const { count } = await prisma.team.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
     */
    deleteMany<T extends TeamDeleteManyArgs>(args?: SelectSubset<T, TeamDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more Teams.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {TeamUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many Teams
     * const team = await prisma.team.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    updateMany<T extends TeamUpdateManyArgs>(args: SelectSubset<T, TeamUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more Teams and returns the data updated in the database.
     * @param {TeamUpdateManyAndReturnArgs} args - Arguments to update many Teams.
     * @example
     * // Update many Teams
     * const team = await prisma.team.updateManyAndReturn({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Update zero or more Teams and only return the `id`
     * const teamWithIdOnly = await prisma.team.updateManyAndReturn({
     *   select: { id: true },
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    updateManyAndReturn<T extends TeamUpdateManyAndReturnArgs>(args: SelectSubset<T, TeamUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$TeamPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>

    /**
     * Create or update one Team.
     * @param {TeamUpsertArgs} args - Arguments to update or create a Team.
     * @example
     * // Update or create a Team
     * const team = await prisma.team.upsert({
     *   create: {
     *     // ... data to create a Team
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the Team we want to update
     *   }
     * })
     */
    upsert<T extends TeamUpsertArgs>(args: SelectSubset<T, TeamUpsertArgs<ExtArgs>>): Prisma__TeamClient<$Result.GetResult<Prisma.$TeamPayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>


    /**
     * Count the number of Teams.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {TeamCountArgs} args - Arguments to filter Teams to count.
     * @example
     * // Count the number of Teams
     * const count = await prisma.team.count({
     *   where: {
     *     // ... the filter for the Teams we want to count
     *   }
     * })
    **/
    count<T extends TeamCountArgs>(
      args?: Subset<T, TeamCountArgs>,
    ): Prisma.PrismaPromise<
      T extends $Utils.Record<'select', any>
        ? T['select'] extends true
          ? number
          : GetScalarType<T['select'], TeamCountAggregateOutputType>
        : number
    >

    /**
     * Allows you to perform aggregations operations on a Team.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {TeamAggregateArgs} 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 TeamAggregateArgs>(args: Subset<T, TeamAggregateArgs>): Prisma.PrismaPromise<GetTeamAggregateType<T>>

    /**
     * Group by Team.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {TeamGroupByArgs} 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 TeamGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: TeamGroupByArgs['orderBy'] }
        : { orderBy?: TeamGroupByArgs['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, TeamGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetTeamGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the Team model
   */
  readonly fields: TeamFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for Team.
   * 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__TeamClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    user<T extends UserDefaultArgs<ExtArgs> = {}>(args?: Subset<T, UserDefaultArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
    players<T extends Team$playersArgs<ExtArgs> = {}>(args?: Subset<T, Team$playersArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$TeamPlayerPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    /**
     * 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 Team model
   */
  interface TeamFieldRefs {
    readonly id: FieldRef<"Team", 'String'>
    readonly name: FieldRef<"Team", 'String'>
    readonly userId: FieldRef<"Team", 'String'>
    readonly budget: FieldRef<"Team", 'Float'>
    readonly totalPoints: FieldRef<"Team", 'Int'>
    readonly formation: FieldRef<"Team", 'String'>
    readonly status: FieldRef<"Team", 'TeamStatus'>
    readonly createdAt: FieldRef<"Team", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * Team findUnique
   */
  export type TeamFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Team
     */
    select?: TeamSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Team
     */
    omit?: TeamOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TeamInclude<ExtArgs> | null
    /**
     * Filter, which Team to fetch.
     */
    where: TeamWhereUniqueInput
  }

  /**
   * Team findUniqueOrThrow
   */
  export type TeamFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Team
     */
    select?: TeamSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Team
     */
    omit?: TeamOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TeamInclude<ExtArgs> | null
    /**
     * Filter, which Team to fetch.
     */
    where: TeamWhereUniqueInput
  }

  /**
   * Team findFirst
   */
  export type TeamFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Team
     */
    select?: TeamSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Team
     */
    omit?: TeamOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TeamInclude<ExtArgs> | null
    /**
     * Filter, which Team to fetch.
     */
    where?: TeamWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Teams to fetch.
     */
    orderBy?: TeamOrderByWithRelationInput | TeamOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Teams.
     */
    cursor?: TeamWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Teams 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` Teams.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Teams.
     */
    distinct?: TeamScalarFieldEnum | TeamScalarFieldEnum[]
  }

  /**
   * Team findFirstOrThrow
   */
  export type TeamFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Team
     */
    select?: TeamSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Team
     */
    omit?: TeamOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TeamInclude<ExtArgs> | null
    /**
     * Filter, which Team to fetch.
     */
    where?: TeamWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Teams to fetch.
     */
    orderBy?: TeamOrderByWithRelationInput | TeamOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Teams.
     */
    cursor?: TeamWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Teams 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` Teams.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Teams.
     */
    distinct?: TeamScalarFieldEnum | TeamScalarFieldEnum[]
  }

  /**
   * Team findMany
   */
  export type TeamFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Team
     */
    select?: TeamSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Team
     */
    omit?: TeamOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TeamInclude<ExtArgs> | null
    /**
     * Filter, which Teams to fetch.
     */
    where?: TeamWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Teams to fetch.
     */
    orderBy?: TeamOrderByWithRelationInput | TeamOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing Teams.
     */
    cursor?: TeamWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Teams 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` Teams.
     */
    skip?: number
    distinct?: TeamScalarFieldEnum | TeamScalarFieldEnum[]
  }

  /**
   * Team create
   */
  export type TeamCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Team
     */
    select?: TeamSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Team
     */
    omit?: TeamOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TeamInclude<ExtArgs> | null
    /**
     * The data needed to create a Team.
     */
    data: XOR<TeamCreateInput, TeamUncheckedCreateInput>
  }

  /**
   * Team createMany
   */
  export type TeamCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many Teams.
     */
    data: TeamCreateManyInput | TeamCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * Team createManyAndReturn
   */
  export type TeamCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Team
     */
    select?: TeamSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the Team
     */
    omit?: TeamOmit<ExtArgs> | null
    /**
     * The data used to create many Teams.
     */
    data: TeamCreateManyInput | TeamCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TeamIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * Team update
   */
  export type TeamUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Team
     */
    select?: TeamSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Team
     */
    omit?: TeamOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TeamInclude<ExtArgs> | null
    /**
     * The data needed to update a Team.
     */
    data: XOR<TeamUpdateInput, TeamUncheckedUpdateInput>
    /**
     * Choose, which Team to update.
     */
    where: TeamWhereUniqueInput
  }

  /**
   * Team updateMany
   */
  export type TeamUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Teams.
     */
    data: XOR<TeamUpdateManyMutationInput, TeamUncheckedUpdateManyInput>
    /**
     * Filter which Teams to update
     */
    where?: TeamWhereInput
    /**
     * Limit how many Teams to update.
     */
    limit?: number
  }

  /**
   * Team updateManyAndReturn
   */
  export type TeamUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Team
     */
    select?: TeamSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the Team
     */
    omit?: TeamOmit<ExtArgs> | null
    /**
     * The data used to update Teams.
     */
    data: XOR<TeamUpdateManyMutationInput, TeamUncheckedUpdateManyInput>
    /**
     * Filter which Teams to update
     */
    where?: TeamWhereInput
    /**
     * Limit how many Teams to update.
     */
    limit?: number
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TeamIncludeUpdateManyAndReturn<ExtArgs> | null
  }

  /**
   * Team upsert
   */
  export type TeamUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Team
     */
    select?: TeamSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Team
     */
    omit?: TeamOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TeamInclude<ExtArgs> | null
    /**
     * The filter to search for the Team to update in case it exists.
     */
    where: TeamWhereUniqueInput
    /**
     * In case the Team found by the `where` argument doesn't exist, create a new Team with this data.
     */
    create: XOR<TeamCreateInput, TeamUncheckedCreateInput>
    /**
     * In case the Team was found with the provided `where` argument, update it with this data.
     */
    update: XOR<TeamUpdateInput, TeamUncheckedUpdateInput>
  }

  /**
   * Team delete
   */
  export type TeamDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Team
     */
    select?: TeamSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Team
     */
    omit?: TeamOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TeamInclude<ExtArgs> | null
    /**
     * Filter which Team to delete.
     */
    where: TeamWhereUniqueInput
  }

  /**
   * Team deleteMany
   */
  export type TeamDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Teams to delete
     */
    where?: TeamWhereInput
    /**
     * Limit how many Teams to delete.
     */
    limit?: number
  }

  /**
   * Team.players
   */
  export type Team$playersArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TeamPlayer
     */
    select?: TeamPlayerSelect<ExtArgs> | null
    /**
     * Omit specific fields from the TeamPlayer
     */
    omit?: TeamPlayerOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TeamPlayerInclude<ExtArgs> | null
    where?: TeamPlayerWhereInput
    orderBy?: TeamPlayerOrderByWithRelationInput | TeamPlayerOrderByWithRelationInput[]
    cursor?: TeamPlayerWhereUniqueInput
    take?: number
    skip?: number
    distinct?: TeamPlayerScalarFieldEnum | TeamPlayerScalarFieldEnum[]
  }

  /**
   * Team without action
   */
  export type TeamDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Team
     */
    select?: TeamSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Team
     */
    omit?: TeamOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TeamInclude<ExtArgs> | null
  }


  /**
   * Model TeamPlayer
   */

  export type AggregateTeamPlayer = {
    _count: TeamPlayerCountAggregateOutputType | null
    _avg: TeamPlayerAvgAggregateOutputType | null
    _sum: TeamPlayerSumAggregateOutputType | null
    _min: TeamPlayerMinAggregateOutputType | null
    _max: TeamPlayerMaxAggregateOutputType | null
  }

  export type TeamPlayerAvgAggregateOutputType = {
    positionIndex: number | null
  }

  export type TeamPlayerSumAggregateOutputType = {
    positionIndex: number | null
  }

  export type TeamPlayerMinAggregateOutputType = {
    teamId: string | null
    playerId: string | null
    goldenCardId: string | null
    isCaptain: boolean | null
    isViceCaptain: boolean | null
    isBench: boolean | null
    positionIndex: number | null
  }

  export type TeamPlayerMaxAggregateOutputType = {
    teamId: string | null
    playerId: string | null
    goldenCardId: string | null
    isCaptain: boolean | null
    isViceCaptain: boolean | null
    isBench: boolean | null
    positionIndex: number | null
  }

  export type TeamPlayerCountAggregateOutputType = {
    teamId: number
    playerId: number
    goldenCardId: number
    isCaptain: number
    isViceCaptain: number
    isBench: number
    positionIndex: number
    _all: number
  }


  export type TeamPlayerAvgAggregateInputType = {
    positionIndex?: true
  }

  export type TeamPlayerSumAggregateInputType = {
    positionIndex?: true
  }

  export type TeamPlayerMinAggregateInputType = {
    teamId?: true
    playerId?: true
    goldenCardId?: true
    isCaptain?: true
    isViceCaptain?: true
    isBench?: true
    positionIndex?: true
  }

  export type TeamPlayerMaxAggregateInputType = {
    teamId?: true
    playerId?: true
    goldenCardId?: true
    isCaptain?: true
    isViceCaptain?: true
    isBench?: true
    positionIndex?: true
  }

  export type TeamPlayerCountAggregateInputType = {
    teamId?: true
    playerId?: true
    goldenCardId?: true
    isCaptain?: true
    isViceCaptain?: true
    isBench?: true
    positionIndex?: true
    _all?: true
  }

  export type TeamPlayerAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which TeamPlayer to aggregate.
     */
    where?: TeamPlayerWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of TeamPlayers to fetch.
     */
    orderBy?: TeamPlayerOrderByWithRelationInput | TeamPlayerOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: TeamPlayerWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` TeamPlayers 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` TeamPlayers.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned TeamPlayers
    **/
    _count?: true | TeamPlayerCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: TeamPlayerAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: TeamPlayerSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: TeamPlayerMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: TeamPlayerMaxAggregateInputType
  }

  export type GetTeamPlayerAggregateType<T extends TeamPlayerAggregateArgs> = {
        [P in keyof T & keyof AggregateTeamPlayer]: P extends '_count' | 'count'
      ? T[P] extends true
        ? number
        : GetScalarType<T[P], AggregateTeamPlayer[P]>
      : GetScalarType<T[P], AggregateTeamPlayer[P]>
  }




  export type TeamPlayerGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: TeamPlayerWhereInput
    orderBy?: TeamPlayerOrderByWithAggregationInput | TeamPlayerOrderByWithAggregationInput[]
    by: TeamPlayerScalarFieldEnum[] | TeamPlayerScalarFieldEnum
    having?: TeamPlayerScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: TeamPlayerCountAggregateInputType | true
    _avg?: TeamPlayerAvgAggregateInputType
    _sum?: TeamPlayerSumAggregateInputType
    _min?: TeamPlayerMinAggregateInputType
    _max?: TeamPlayerMaxAggregateInputType
  }

  export type TeamPlayerGroupByOutputType = {
    teamId: string
    playerId: string
    goldenCardId: string | null
    isCaptain: boolean
    isViceCaptain: boolean
    isBench: boolean
    positionIndex: number
    _count: TeamPlayerCountAggregateOutputType | null
    _avg: TeamPlayerAvgAggregateOutputType | null
    _sum: TeamPlayerSumAggregateOutputType | null
    _min: TeamPlayerMinAggregateOutputType | null
    _max: TeamPlayerMaxAggregateOutputType | null
  }

  type GetTeamPlayerGroupByPayload<T extends TeamPlayerGroupByArgs> = Prisma.PrismaPromise<
    Array<
      PickEnumerable<TeamPlayerGroupByOutputType, T['by']> &
        {
          [P in ((keyof T) & (keyof TeamPlayerGroupByOutputType))]: P extends '_count'
            ? T[P] extends boolean
              ? number
              : GetScalarType<T[P], TeamPlayerGroupByOutputType[P]>
            : GetScalarType<T[P], TeamPlayerGroupByOutputType[P]>
        }
      >
    >


  export type TeamPlayerSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    teamId?: boolean
    playerId?: boolean
    goldenCardId?: boolean
    isCaptain?: boolean
    isViceCaptain?: boolean
    isBench?: boolean
    positionIndex?: boolean
    team?: boolean | TeamDefaultArgs<ExtArgs>
    player?: boolean | PlayerDefaultArgs<ExtArgs>
    goldenCard?: boolean | TeamPlayer$goldenCardArgs<ExtArgs>
  }, ExtArgs["result"]["teamPlayer"]>

  export type TeamPlayerSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    teamId?: boolean
    playerId?: boolean
    goldenCardId?: boolean
    isCaptain?: boolean
    isViceCaptain?: boolean
    isBench?: boolean
    positionIndex?: boolean
    team?: boolean | TeamDefaultArgs<ExtArgs>
    player?: boolean | PlayerDefaultArgs<ExtArgs>
    goldenCard?: boolean | TeamPlayer$goldenCardArgs<ExtArgs>
  }, ExtArgs["result"]["teamPlayer"]>

  export type TeamPlayerSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    teamId?: boolean
    playerId?: boolean
    goldenCardId?: boolean
    isCaptain?: boolean
    isViceCaptain?: boolean
    isBench?: boolean
    positionIndex?: boolean
    team?: boolean | TeamDefaultArgs<ExtArgs>
    player?: boolean | PlayerDefaultArgs<ExtArgs>
    goldenCard?: boolean | TeamPlayer$goldenCardArgs<ExtArgs>
  }, ExtArgs["result"]["teamPlayer"]>

  export type TeamPlayerSelectScalar = {
    teamId?: boolean
    playerId?: boolean
    goldenCardId?: boolean
    isCaptain?: boolean
    isViceCaptain?: boolean
    isBench?: boolean
    positionIndex?: boolean
  }

  export type TeamPlayerOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"teamId" | "playerId" | "goldenCardId" | "isCaptain" | "isViceCaptain" | "isBench" | "positionIndex", ExtArgs["result"]["teamPlayer"]>
  export type TeamPlayerInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    team?: boolean | TeamDefaultArgs<ExtArgs>
    player?: boolean | PlayerDefaultArgs<ExtArgs>
    goldenCard?: boolean | TeamPlayer$goldenCardArgs<ExtArgs>
  }
  export type TeamPlayerIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    team?: boolean | TeamDefaultArgs<ExtArgs>
    player?: boolean | PlayerDefaultArgs<ExtArgs>
    goldenCard?: boolean | TeamPlayer$goldenCardArgs<ExtArgs>
  }
  export type TeamPlayerIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    team?: boolean | TeamDefaultArgs<ExtArgs>
    player?: boolean | PlayerDefaultArgs<ExtArgs>
    goldenCard?: boolean | TeamPlayer$goldenCardArgs<ExtArgs>
  }

  export type $TeamPlayerPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "TeamPlayer"
    objects: {
      team: Prisma.$TeamPayload<ExtArgs>
      player: Prisma.$PlayerPayload<ExtArgs>
      goldenCard: Prisma.$GoldenCardPayload<ExtArgs> | null
    }
    scalars: $Extensions.GetPayloadResult<{
      teamId: string
      playerId: string
      goldenCardId: string | null
      isCaptain: boolean
      isViceCaptain: boolean
      isBench: boolean
      positionIndex: number
    }, ExtArgs["result"]["teamPlayer"]>
    composites: {}
  }

  type TeamPlayerGetPayload<S extends boolean | null | undefined | TeamPlayerDefaultArgs> = $Result.GetResult<Prisma.$TeamPlayerPayload, S>

  type TeamPlayerCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
    Omit<TeamPlayerFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
      select?: TeamPlayerCountAggregateInputType | true
    }

  export interface TeamPlayerDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> {
    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['TeamPlayer'], meta: { name: 'TeamPlayer' } }
    /**
     * Find zero or one TeamPlayer that matches the filter.
     * @param {TeamPlayerFindUniqueArgs} args - Arguments to find a TeamPlayer
     * @example
     * // Get one TeamPlayer
     * const teamPlayer = await prisma.teamPlayer.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUnique<T extends TeamPlayerFindUniqueArgs>(args: SelectSubset<T, TeamPlayerFindUniqueArgs<ExtArgs>>): Prisma__TeamPlayerClient<$Result.GetResult<Prisma.$TeamPlayerPayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find one TeamPlayer that matches the filter or throw an error with `error.code='P2025'`
     * if no matches were found.
     * @param {TeamPlayerFindUniqueOrThrowArgs} args - Arguments to find a TeamPlayer
     * @example
     * // Get one TeamPlayer
     * const teamPlayer = await prisma.teamPlayer.findUniqueOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUniqueOrThrow<T extends TeamPlayerFindUniqueOrThrowArgs>(args: SelectSubset<T, TeamPlayerFindUniqueOrThrowArgs<ExtArgs>>): Prisma__TeamPlayerClient<$Result.GetResult<Prisma.$TeamPlayerPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first TeamPlayer 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 {TeamPlayerFindFirstArgs} args - Arguments to find a TeamPlayer
     * @example
     * // Get one TeamPlayer
     * const teamPlayer = await prisma.teamPlayer.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends TeamPlayerFindFirstArgs>(args?: SelectSubset<T, TeamPlayerFindFirstArgs<ExtArgs>>): Prisma__TeamPlayerClient<$Result.GetResult<Prisma.$TeamPlayerPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first TeamPlayer 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 {TeamPlayerFindFirstOrThrowArgs} args - Arguments to find a TeamPlayer
     * @example
     * // Get one TeamPlayer
     * const teamPlayer = await prisma.teamPlayer.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends TeamPlayerFindFirstOrThrowArgs>(args?: SelectSubset<T, TeamPlayerFindFirstOrThrowArgs<ExtArgs>>): Prisma__TeamPlayerClient<$Result.GetResult<Prisma.$TeamPlayerPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find zero or more TeamPlayers 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 {TeamPlayerFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all TeamPlayers
     * const teamPlayers = await prisma.teamPlayer.findMany()
     * 
     * // Get first 10 TeamPlayers
     * const teamPlayers = await prisma.teamPlayer.findMany({ take: 10 })
     * 
     * // Only select the `teamId`
     * const teamPlayerWithTeamIdOnly = await prisma.teamPlayer.findMany({ select: { teamId: true } })
     * 
     */
    findMany<T extends TeamPlayerFindManyArgs>(args?: SelectSubset<T, TeamPlayerFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$TeamPlayerPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>

    /**
     * Create a TeamPlayer.
     * @param {TeamPlayerCreateArgs} args - Arguments to create a TeamPlayer.
     * @example
     * // Create one TeamPlayer
     * const TeamPlayer = await prisma.teamPlayer.create({
     *   data: {
     *     // ... data to create a TeamPlayer
     *   }
     * })
     * 
     */
    create<T extends TeamPlayerCreateArgs>(args: SelectSubset<T, TeamPlayerCreateArgs<ExtArgs>>): Prisma__TeamPlayerClient<$Result.GetResult<Prisma.$TeamPlayerPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Create many TeamPlayers.
     * @param {TeamPlayerCreateManyArgs} args - Arguments to create many TeamPlayers.
     * @example
     * // Create many TeamPlayers
     * const teamPlayer = await prisma.teamPlayer.createMany({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     *     
     */
    createMany<T extends TeamPlayerCreateManyArgs>(args?: SelectSubset<T, TeamPlayerCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create many TeamPlayers and returns the data saved in the database.
     * @param {TeamPlayerCreateManyAndReturnArgs} args - Arguments to create many TeamPlayers.
     * @example
     * // Create many TeamPlayers
     * const teamPlayer = await prisma.teamPlayer.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many TeamPlayers and only return the `teamId`
     * const teamPlayerWithTeamIdOnly = await prisma.teamPlayer.createManyAndReturn({
     *   select: { teamId: true },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    createManyAndReturn<T extends TeamPlayerCreateManyAndReturnArgs>(args?: SelectSubset<T, TeamPlayerCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$TeamPlayerPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>

    /**
     * Delete a TeamPlayer.
     * @param {TeamPlayerDeleteArgs} args - Arguments to delete one TeamPlayer.
     * @example
     * // Delete one TeamPlayer
     * const TeamPlayer = await prisma.teamPlayer.delete({
     *   where: {
     *     // ... filter to delete one TeamPlayer
     *   }
     * })
     * 
     */
    delete<T extends TeamPlayerDeleteArgs>(args: SelectSubset<T, TeamPlayerDeleteArgs<ExtArgs>>): Prisma__TeamPlayerClient<$Result.GetResult<Prisma.$TeamPlayerPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Update one TeamPlayer.
     * @param {TeamPlayerUpdateArgs} args - Arguments to update one TeamPlayer.
     * @example
     * // Update one TeamPlayer
     * const teamPlayer = await prisma.teamPlayer.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends TeamPlayerUpdateArgs>(args: SelectSubset<T, TeamPlayerUpdateArgs<ExtArgs>>): Prisma__TeamPlayerClient<$Result.GetResult<Prisma.$TeamPlayerPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Delete zero or more TeamPlayers.
     * @param {TeamPlayerDeleteManyArgs} args - Arguments to filter TeamPlayers to delete.
     * @example
     * // Delete a few TeamPlayers
     * const { count } = await prisma.teamPlayer.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
     */
    deleteMany<T extends TeamPlayerDeleteManyArgs>(args?: SelectSubset<T, TeamPlayerDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more TeamPlayers.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {TeamPlayerUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many TeamPlayers
     * const teamPlayer = await prisma.teamPlayer.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    updateMany<T extends TeamPlayerUpdateManyArgs>(args: SelectSubset<T, TeamPlayerUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more TeamPlayers and returns the data updated in the database.
     * @param {TeamPlayerUpdateManyAndReturnArgs} args - Arguments to update many TeamPlayers.
     * @example
     * // Update many TeamPlayers
     * const teamPlayer = await prisma.teamPlayer.updateManyAndReturn({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Update zero or more TeamPlayers and only return the `teamId`
     * const teamPlayerWithTeamIdOnly = await prisma.teamPlayer.updateManyAndReturn({
     *   select: { teamId: true },
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    updateManyAndReturn<T extends TeamPlayerUpdateManyAndReturnArgs>(args: SelectSubset<T, TeamPlayerUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$TeamPlayerPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>

    /**
     * Create or update one TeamPlayer.
     * @param {TeamPlayerUpsertArgs} args - Arguments to update or create a TeamPlayer.
     * @example
     * // Update or create a TeamPlayer
     * const teamPlayer = await prisma.teamPlayer.upsert({
     *   create: {
     *     // ... data to create a TeamPlayer
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the TeamPlayer we want to update
     *   }
     * })
     */
    upsert<T extends TeamPlayerUpsertArgs>(args: SelectSubset<T, TeamPlayerUpsertArgs<ExtArgs>>): Prisma__TeamPlayerClient<$Result.GetResult<Prisma.$TeamPlayerPayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>


    /**
     * Count the number of TeamPlayers.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {TeamPlayerCountArgs} args - Arguments to filter TeamPlayers to count.
     * @example
     * // Count the number of TeamPlayers
     * const count = await prisma.teamPlayer.count({
     *   where: {
     *     // ... the filter for the TeamPlayers we want to count
     *   }
     * })
    **/
    count<T extends TeamPlayerCountArgs>(
      args?: Subset<T, TeamPlayerCountArgs>,
    ): Prisma.PrismaPromise<
      T extends $Utils.Record<'select', any>
        ? T['select'] extends true
          ? number
          : GetScalarType<T['select'], TeamPlayerCountAggregateOutputType>
        : number
    >

    /**
     * Allows you to perform aggregations operations on a TeamPlayer.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {TeamPlayerAggregateArgs} 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 TeamPlayerAggregateArgs>(args: Subset<T, TeamPlayerAggregateArgs>): Prisma.PrismaPromise<GetTeamPlayerAggregateType<T>>

    /**
     * Group by TeamPlayer.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {TeamPlayerGroupByArgs} 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 TeamPlayerGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: TeamPlayerGroupByArgs['orderBy'] }
        : { orderBy?: TeamPlayerGroupByArgs['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, TeamPlayerGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetTeamPlayerGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the TeamPlayer model
   */
  readonly fields: TeamPlayerFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for TeamPlayer.
   * 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__TeamPlayerClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    team<T extends TeamDefaultArgs<ExtArgs> = {}>(args?: Subset<T, TeamDefaultArgs<ExtArgs>>): Prisma__TeamClient<$Result.GetResult<Prisma.$TeamPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
    player<T extends PlayerDefaultArgs<ExtArgs> = {}>(args?: Subset<T, PlayerDefaultArgs<ExtArgs>>): Prisma__PlayerClient<$Result.GetResult<Prisma.$PlayerPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
    goldenCard<T extends TeamPlayer$goldenCardArgs<ExtArgs> = {}>(args?: Subset<T, TeamPlayer$goldenCardArgs<ExtArgs>>): Prisma__GoldenCardClient<$Result.GetResult<Prisma.$GoldenCardPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
    /**
     * 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 TeamPlayer model
   */
  interface TeamPlayerFieldRefs {
    readonly teamId: FieldRef<"TeamPlayer", 'String'>
    readonly playerId: FieldRef<"TeamPlayer", 'String'>
    readonly goldenCardId: FieldRef<"TeamPlayer", 'String'>
    readonly isCaptain: FieldRef<"TeamPlayer", 'Boolean'>
    readonly isViceCaptain: FieldRef<"TeamPlayer", 'Boolean'>
    readonly isBench: FieldRef<"TeamPlayer", 'Boolean'>
    readonly positionIndex: FieldRef<"TeamPlayer", 'Int'>
  }
    

  // Custom InputTypes
  /**
   * TeamPlayer findUnique
   */
  export type TeamPlayerFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TeamPlayer
     */
    select?: TeamPlayerSelect<ExtArgs> | null
    /**
     * Omit specific fields from the TeamPlayer
     */
    omit?: TeamPlayerOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TeamPlayerInclude<ExtArgs> | null
    /**
     * Filter, which TeamPlayer to fetch.
     */
    where: TeamPlayerWhereUniqueInput
  }

  /**
   * TeamPlayer findUniqueOrThrow
   */
  export type TeamPlayerFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TeamPlayer
     */
    select?: TeamPlayerSelect<ExtArgs> | null
    /**
     * Omit specific fields from the TeamPlayer
     */
    omit?: TeamPlayerOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TeamPlayerInclude<ExtArgs> | null
    /**
     * Filter, which TeamPlayer to fetch.
     */
    where: TeamPlayerWhereUniqueInput
  }

  /**
   * TeamPlayer findFirst
   */
  export type TeamPlayerFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TeamPlayer
     */
    select?: TeamPlayerSelect<ExtArgs> | null
    /**
     * Omit specific fields from the TeamPlayer
     */
    omit?: TeamPlayerOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TeamPlayerInclude<ExtArgs> | null
    /**
     * Filter, which TeamPlayer to fetch.
     */
    where?: TeamPlayerWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of TeamPlayers to fetch.
     */
    orderBy?: TeamPlayerOrderByWithRelationInput | TeamPlayerOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for TeamPlayers.
     */
    cursor?: TeamPlayerWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` TeamPlayers 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` TeamPlayers.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of TeamPlayers.
     */
    distinct?: TeamPlayerScalarFieldEnum | TeamPlayerScalarFieldEnum[]
  }

  /**
   * TeamPlayer findFirstOrThrow
   */
  export type TeamPlayerFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TeamPlayer
     */
    select?: TeamPlayerSelect<ExtArgs> | null
    /**
     * Omit specific fields from the TeamPlayer
     */
    omit?: TeamPlayerOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TeamPlayerInclude<ExtArgs> | null
    /**
     * Filter, which TeamPlayer to fetch.
     */
    where?: TeamPlayerWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of TeamPlayers to fetch.
     */
    orderBy?: TeamPlayerOrderByWithRelationInput | TeamPlayerOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for TeamPlayers.
     */
    cursor?: TeamPlayerWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` TeamPlayers 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` TeamPlayers.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of TeamPlayers.
     */
    distinct?: TeamPlayerScalarFieldEnum | TeamPlayerScalarFieldEnum[]
  }

  /**
   * TeamPlayer findMany
   */
  export type TeamPlayerFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TeamPlayer
     */
    select?: TeamPlayerSelect<ExtArgs> | null
    /**
     * Omit specific fields from the TeamPlayer
     */
    omit?: TeamPlayerOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TeamPlayerInclude<ExtArgs> | null
    /**
     * Filter, which TeamPlayers to fetch.
     */
    where?: TeamPlayerWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of TeamPlayers to fetch.
     */
    orderBy?: TeamPlayerOrderByWithRelationInput | TeamPlayerOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing TeamPlayers.
     */
    cursor?: TeamPlayerWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` TeamPlayers 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` TeamPlayers.
     */
    skip?: number
    distinct?: TeamPlayerScalarFieldEnum | TeamPlayerScalarFieldEnum[]
  }

  /**
   * TeamPlayer create
   */
  export type TeamPlayerCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TeamPlayer
     */
    select?: TeamPlayerSelect<ExtArgs> | null
    /**
     * Omit specific fields from the TeamPlayer
     */
    omit?: TeamPlayerOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TeamPlayerInclude<ExtArgs> | null
    /**
     * The data needed to create a TeamPlayer.
     */
    data: XOR<TeamPlayerCreateInput, TeamPlayerUncheckedCreateInput>
  }

  /**
   * TeamPlayer createMany
   */
  export type TeamPlayerCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many TeamPlayers.
     */
    data: TeamPlayerCreateManyInput | TeamPlayerCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * TeamPlayer createManyAndReturn
   */
  export type TeamPlayerCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TeamPlayer
     */
    select?: TeamPlayerSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the TeamPlayer
     */
    omit?: TeamPlayerOmit<ExtArgs> | null
    /**
     * The data used to create many TeamPlayers.
     */
    data: TeamPlayerCreateManyInput | TeamPlayerCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TeamPlayerIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * TeamPlayer update
   */
  export type TeamPlayerUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TeamPlayer
     */
    select?: TeamPlayerSelect<ExtArgs> | null
    /**
     * Omit specific fields from the TeamPlayer
     */
    omit?: TeamPlayerOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TeamPlayerInclude<ExtArgs> | null
    /**
     * The data needed to update a TeamPlayer.
     */
    data: XOR<TeamPlayerUpdateInput, TeamPlayerUncheckedUpdateInput>
    /**
     * Choose, which TeamPlayer to update.
     */
    where: TeamPlayerWhereUniqueInput
  }

  /**
   * TeamPlayer updateMany
   */
  export type TeamPlayerUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update TeamPlayers.
     */
    data: XOR<TeamPlayerUpdateManyMutationInput, TeamPlayerUncheckedUpdateManyInput>
    /**
     * Filter which TeamPlayers to update
     */
    where?: TeamPlayerWhereInput
    /**
     * Limit how many TeamPlayers to update.
     */
    limit?: number
  }

  /**
   * TeamPlayer updateManyAndReturn
   */
  export type TeamPlayerUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TeamPlayer
     */
    select?: TeamPlayerSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the TeamPlayer
     */
    omit?: TeamPlayerOmit<ExtArgs> | null
    /**
     * The data used to update TeamPlayers.
     */
    data: XOR<TeamPlayerUpdateManyMutationInput, TeamPlayerUncheckedUpdateManyInput>
    /**
     * Filter which TeamPlayers to update
     */
    where?: TeamPlayerWhereInput
    /**
     * Limit how many TeamPlayers to update.
     */
    limit?: number
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TeamPlayerIncludeUpdateManyAndReturn<ExtArgs> | null
  }

  /**
   * TeamPlayer upsert
   */
  export type TeamPlayerUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TeamPlayer
     */
    select?: TeamPlayerSelect<ExtArgs> | null
    /**
     * Omit specific fields from the TeamPlayer
     */
    omit?: TeamPlayerOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TeamPlayerInclude<ExtArgs> | null
    /**
     * The filter to search for the TeamPlayer to update in case it exists.
     */
    where: TeamPlayerWhereUniqueInput
    /**
     * In case the TeamPlayer found by the `where` argument doesn't exist, create a new TeamPlayer with this data.
     */
    create: XOR<TeamPlayerCreateInput, TeamPlayerUncheckedCreateInput>
    /**
     * In case the TeamPlayer was found with the provided `where` argument, update it with this data.
     */
    update: XOR<TeamPlayerUpdateInput, TeamPlayerUncheckedUpdateInput>
  }

  /**
   * TeamPlayer delete
   */
  export type TeamPlayerDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TeamPlayer
     */
    select?: TeamPlayerSelect<ExtArgs> | null
    /**
     * Omit specific fields from the TeamPlayer
     */
    omit?: TeamPlayerOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TeamPlayerInclude<ExtArgs> | null
    /**
     * Filter which TeamPlayer to delete.
     */
    where: TeamPlayerWhereUniqueInput
  }

  /**
   * TeamPlayer deleteMany
   */
  export type TeamPlayerDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which TeamPlayers to delete
     */
    where?: TeamPlayerWhereInput
    /**
     * Limit how many TeamPlayers to delete.
     */
    limit?: number
  }

  /**
   * TeamPlayer.goldenCard
   */
  export type TeamPlayer$goldenCardArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the GoldenCard
     */
    select?: GoldenCardSelect<ExtArgs> | null
    /**
     * Omit specific fields from the GoldenCard
     */
    omit?: GoldenCardOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: GoldenCardInclude<ExtArgs> | null
    where?: GoldenCardWhereInput
  }

  /**
   * TeamPlayer without action
   */
  export type TeamPlayerDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TeamPlayer
     */
    select?: TeamPlayerSelect<ExtArgs> | null
    /**
     * Omit specific fields from the TeamPlayer
     */
    omit?: TeamPlayerOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TeamPlayerInclude<ExtArgs> | null
  }


  /**
   * Model Package
   */

  export type AggregatePackage = {
    _count: PackageCountAggregateOutputType | null
    _avg: PackageAvgAggregateOutputType | null
    _sum: PackageSumAggregateOutputType | null
    _min: PackageMinAggregateOutputType | null
    _max: PackageMaxAggregateOutputType | null
  }

  export type PackageAvgAggregateOutputType = {
    budgetBonus: number | null
    price: number | null
  }

  export type PackageSumAggregateOutputType = {
    budgetBonus: number | null
    price: number | null
  }

  export type PackageMinAggregateOutputType = {
    id: string | null
    name: string | null
    budgetBonus: number | null
    price: number | null
    description: string | null
    isActive: boolean | null
  }

  export type PackageMaxAggregateOutputType = {
    id: string | null
    name: string | null
    budgetBonus: number | null
    price: number | null
    description: string | null
    isActive: boolean | null
  }

  export type PackageCountAggregateOutputType = {
    id: number
    name: number
    budgetBonus: number
    price: number
    description: number
    isActive: number
    _all: number
  }


  export type PackageAvgAggregateInputType = {
    budgetBonus?: true
    price?: true
  }

  export type PackageSumAggregateInputType = {
    budgetBonus?: true
    price?: true
  }

  export type PackageMinAggregateInputType = {
    id?: true
    name?: true
    budgetBonus?: true
    price?: true
    description?: true
    isActive?: true
  }

  export type PackageMaxAggregateInputType = {
    id?: true
    name?: true
    budgetBonus?: true
    price?: true
    description?: true
    isActive?: true
  }

  export type PackageCountAggregateInputType = {
    id?: true
    name?: true
    budgetBonus?: true
    price?: true
    description?: true
    isActive?: true
    _all?: true
  }

  export type PackageAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Package to aggregate.
     */
    where?: PackageWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Packages to fetch.
     */
    orderBy?: PackageOrderByWithRelationInput | PackageOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: PackageWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Packages 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` Packages.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned Packages
    **/
    _count?: true | PackageCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: PackageAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: PackageSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: PackageMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: PackageMaxAggregateInputType
  }

  export type GetPackageAggregateType<T extends PackageAggregateArgs> = {
        [P in keyof T & keyof AggregatePackage]: P extends '_count' | 'count'
      ? T[P] extends true
        ? number
        : GetScalarType<T[P], AggregatePackage[P]>
      : GetScalarType<T[P], AggregatePackage[P]>
  }




  export type PackageGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: PackageWhereInput
    orderBy?: PackageOrderByWithAggregationInput | PackageOrderByWithAggregationInput[]
    by: PackageScalarFieldEnum[] | PackageScalarFieldEnum
    having?: PackageScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: PackageCountAggregateInputType | true
    _avg?: PackageAvgAggregateInputType
    _sum?: PackageSumAggregateInputType
    _min?: PackageMinAggregateInputType
    _max?: PackageMaxAggregateInputType
  }

  export type PackageGroupByOutputType = {
    id: string
    name: string
    budgetBonus: number
    price: number
    description: string | null
    isActive: boolean
    _count: PackageCountAggregateOutputType | null
    _avg: PackageAvgAggregateOutputType | null
    _sum: PackageSumAggregateOutputType | null
    _min: PackageMinAggregateOutputType | null
    _max: PackageMaxAggregateOutputType | null
  }

  type GetPackageGroupByPayload<T extends PackageGroupByArgs> = Prisma.PrismaPromise<
    Array<
      PickEnumerable<PackageGroupByOutputType, T['by']> &
        {
          [P in ((keyof T) & (keyof PackageGroupByOutputType))]: P extends '_count'
            ? T[P] extends boolean
              ? number
              : GetScalarType<T[P], PackageGroupByOutputType[P]>
            : GetScalarType<T[P], PackageGroupByOutputType[P]>
        }
      >
    >


  export type PackageSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
    budgetBonus?: boolean
    price?: boolean
    description?: boolean
    isActive?: boolean
    payments?: boolean | Package$paymentsArgs<ExtArgs>
    _count?: boolean | PackageCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["package"]>

  export type PackageSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
    budgetBonus?: boolean
    price?: boolean
    description?: boolean
    isActive?: boolean
  }, ExtArgs["result"]["package"]>

  export type PackageSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
    budgetBonus?: boolean
    price?: boolean
    description?: boolean
    isActive?: boolean
  }, ExtArgs["result"]["package"]>

  export type PackageSelectScalar = {
    id?: boolean
    name?: boolean
    budgetBonus?: boolean
    price?: boolean
    description?: boolean
    isActive?: boolean
  }

  export type PackageOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "name" | "budgetBonus" | "price" | "description" | "isActive", ExtArgs["result"]["package"]>
  export type PackageInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    payments?: boolean | Package$paymentsArgs<ExtArgs>
    _count?: boolean | PackageCountOutputTypeDefaultArgs<ExtArgs>
  }
  export type PackageIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {}
  export type PackageIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {}

  export type $PackagePayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Package"
    objects: {
      payments: Prisma.$PaymentPayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      name: string
      budgetBonus: number
      price: number
      description: string | null
      isActive: boolean
    }, ExtArgs["result"]["package"]>
    composites: {}
  }

  type PackageGetPayload<S extends boolean | null | undefined | PackageDefaultArgs> = $Result.GetResult<Prisma.$PackagePayload, S>

  type PackageCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
    Omit<PackageFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
      select?: PackageCountAggregateInputType | true
    }

  export interface PackageDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> {
    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['Package'], meta: { name: 'Package' } }
    /**
     * Find zero or one Package that matches the filter.
     * @param {PackageFindUniqueArgs} args - Arguments to find a Package
     * @example
     * // Get one Package
     * const package = await prisma.package.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUnique<T extends PackageFindUniqueArgs>(args: SelectSubset<T, PackageFindUniqueArgs<ExtArgs>>): Prisma__PackageClient<$Result.GetResult<Prisma.$PackagePayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find one Package that matches the filter or throw an error with `error.code='P2025'`
     * if no matches were found.
     * @param {PackageFindUniqueOrThrowArgs} args - Arguments to find a Package
     * @example
     * // Get one Package
     * const package = await prisma.package.findUniqueOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUniqueOrThrow<T extends PackageFindUniqueOrThrowArgs>(args: SelectSubset<T, PackageFindUniqueOrThrowArgs<ExtArgs>>): Prisma__PackageClient<$Result.GetResult<Prisma.$PackagePayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first Package 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 {PackageFindFirstArgs} args - Arguments to find a Package
     * @example
     * // Get one Package
     * const package = await prisma.package.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends PackageFindFirstArgs>(args?: SelectSubset<T, PackageFindFirstArgs<ExtArgs>>): Prisma__PackageClient<$Result.GetResult<Prisma.$PackagePayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first Package 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 {PackageFindFirstOrThrowArgs} args - Arguments to find a Package
     * @example
     * // Get one Package
     * const package = await prisma.package.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends PackageFindFirstOrThrowArgs>(args?: SelectSubset<T, PackageFindFirstOrThrowArgs<ExtArgs>>): Prisma__PackageClient<$Result.GetResult<Prisma.$PackagePayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find zero or more Packages 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 {PackageFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all Packages
     * const packages = await prisma.package.findMany()
     * 
     * // Get first 10 Packages
     * const packages = await prisma.package.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const packageWithIdOnly = await prisma.package.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends PackageFindManyArgs>(args?: SelectSubset<T, PackageFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$PackagePayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>

    /**
     * Create a Package.
     * @param {PackageCreateArgs} args - Arguments to create a Package.
     * @example
     * // Create one Package
     * const Package = await prisma.package.create({
     *   data: {
     *     // ... data to create a Package
     *   }
     * })
     * 
     */
    create<T extends PackageCreateArgs>(args: SelectSubset<T, PackageCreateArgs<ExtArgs>>): Prisma__PackageClient<$Result.GetResult<Prisma.$PackagePayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Create many Packages.
     * @param {PackageCreateManyArgs} args - Arguments to create many Packages.
     * @example
     * // Create many Packages
     * const package = await prisma.package.createMany({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     *     
     */
    createMany<T extends PackageCreateManyArgs>(args?: SelectSubset<T, PackageCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create many Packages and returns the data saved in the database.
     * @param {PackageCreateManyAndReturnArgs} args - Arguments to create many Packages.
     * @example
     * // Create many Packages
     * const package = await prisma.package.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many Packages and only return the `id`
     * const packageWithIdOnly = await prisma.package.createManyAndReturn({
     *   select: { id: true },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    createManyAndReturn<T extends PackageCreateManyAndReturnArgs>(args?: SelectSubset<T, PackageCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$PackagePayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>

    /**
     * Delete a Package.
     * @param {PackageDeleteArgs} args - Arguments to delete one Package.
     * @example
     * // Delete one Package
     * const Package = await prisma.package.delete({
     *   where: {
     *     // ... filter to delete one Package
     *   }
     * })
     * 
     */
    delete<T extends PackageDeleteArgs>(args: SelectSubset<T, PackageDeleteArgs<ExtArgs>>): Prisma__PackageClient<$Result.GetResult<Prisma.$PackagePayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Update one Package.
     * @param {PackageUpdateArgs} args - Arguments to update one Package.
     * @example
     * // Update one Package
     * const package = await prisma.package.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends PackageUpdateArgs>(args: SelectSubset<T, PackageUpdateArgs<ExtArgs>>): Prisma__PackageClient<$Result.GetResult<Prisma.$PackagePayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Delete zero or more Packages.
     * @param {PackageDeleteManyArgs} args - Arguments to filter Packages to delete.
     * @example
     * // Delete a few Packages
     * const { count } = await prisma.package.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
     */
    deleteMany<T extends PackageDeleteManyArgs>(args?: SelectSubset<T, PackageDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more Packages.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {PackageUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many Packages
     * const package = await prisma.package.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    updateMany<T extends PackageUpdateManyArgs>(args: SelectSubset<T, PackageUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more Packages and returns the data updated in the database.
     * @param {PackageUpdateManyAndReturnArgs} args - Arguments to update many Packages.
     * @example
     * // Update many Packages
     * const package = await prisma.package.updateManyAndReturn({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Update zero or more Packages and only return the `id`
     * const packageWithIdOnly = await prisma.package.updateManyAndReturn({
     *   select: { id: true },
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    updateManyAndReturn<T extends PackageUpdateManyAndReturnArgs>(args: SelectSubset<T, PackageUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$PackagePayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>

    /**
     * Create or update one Package.
     * @param {PackageUpsertArgs} args - Arguments to update or create a Package.
     * @example
     * // Update or create a Package
     * const package = await prisma.package.upsert({
     *   create: {
     *     // ... data to create a Package
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the Package we want to update
     *   }
     * })
     */
    upsert<T extends PackageUpsertArgs>(args: SelectSubset<T, PackageUpsertArgs<ExtArgs>>): Prisma__PackageClient<$Result.GetResult<Prisma.$PackagePayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>


    /**
     * Count the number of Packages.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {PackageCountArgs} args - Arguments to filter Packages to count.
     * @example
     * // Count the number of Packages
     * const count = await prisma.package.count({
     *   where: {
     *     // ... the filter for the Packages we want to count
     *   }
     * })
    **/
    count<T extends PackageCountArgs>(
      args?: Subset<T, PackageCountArgs>,
    ): Prisma.PrismaPromise<
      T extends $Utils.Record<'select', any>
        ? T['select'] extends true
          ? number
          : GetScalarType<T['select'], PackageCountAggregateOutputType>
        : number
    >

    /**
     * Allows you to perform aggregations operations on a Package.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {PackageAggregateArgs} 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 PackageAggregateArgs>(args: Subset<T, PackageAggregateArgs>): Prisma.PrismaPromise<GetPackageAggregateType<T>>

    /**
     * Group by Package.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {PackageGroupByArgs} 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 PackageGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: PackageGroupByArgs['orderBy'] }
        : { orderBy?: PackageGroupByArgs['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, PackageGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetPackageGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the Package model
   */
  readonly fields: PackageFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for Package.
   * 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__PackageClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    payments<T extends Package$paymentsArgs<ExtArgs> = {}>(args?: Subset<T, Package$paymentsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$PaymentPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    /**
     * 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 Package model
   */
  interface PackageFieldRefs {
    readonly id: FieldRef<"Package", 'String'>
    readonly name: FieldRef<"Package", 'String'>
    readonly budgetBonus: FieldRef<"Package", 'Float'>
    readonly price: FieldRef<"Package", 'Int'>
    readonly description: FieldRef<"Package", 'String'>
    readonly isActive: FieldRef<"Package", 'Boolean'>
  }
    

  // Custom InputTypes
  /**
   * Package findUnique
   */
  export type PackageFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Package
     */
    select?: PackageSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Package
     */
    omit?: PackageOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PackageInclude<ExtArgs> | null
    /**
     * Filter, which Package to fetch.
     */
    where: PackageWhereUniqueInput
  }

  /**
   * Package findUniqueOrThrow
   */
  export type PackageFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Package
     */
    select?: PackageSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Package
     */
    omit?: PackageOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PackageInclude<ExtArgs> | null
    /**
     * Filter, which Package to fetch.
     */
    where: PackageWhereUniqueInput
  }

  /**
   * Package findFirst
   */
  export type PackageFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Package
     */
    select?: PackageSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Package
     */
    omit?: PackageOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PackageInclude<ExtArgs> | null
    /**
     * Filter, which Package to fetch.
     */
    where?: PackageWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Packages to fetch.
     */
    orderBy?: PackageOrderByWithRelationInput | PackageOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Packages.
     */
    cursor?: PackageWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Packages 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` Packages.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Packages.
     */
    distinct?: PackageScalarFieldEnum | PackageScalarFieldEnum[]
  }

  /**
   * Package findFirstOrThrow
   */
  export type PackageFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Package
     */
    select?: PackageSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Package
     */
    omit?: PackageOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PackageInclude<ExtArgs> | null
    /**
     * Filter, which Package to fetch.
     */
    where?: PackageWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Packages to fetch.
     */
    orderBy?: PackageOrderByWithRelationInput | PackageOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Packages.
     */
    cursor?: PackageWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Packages 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` Packages.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Packages.
     */
    distinct?: PackageScalarFieldEnum | PackageScalarFieldEnum[]
  }

  /**
   * Package findMany
   */
  export type PackageFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Package
     */
    select?: PackageSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Package
     */
    omit?: PackageOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PackageInclude<ExtArgs> | null
    /**
     * Filter, which Packages to fetch.
     */
    where?: PackageWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Packages to fetch.
     */
    orderBy?: PackageOrderByWithRelationInput | PackageOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing Packages.
     */
    cursor?: PackageWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Packages 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` Packages.
     */
    skip?: number
    distinct?: PackageScalarFieldEnum | PackageScalarFieldEnum[]
  }

  /**
   * Package create
   */
  export type PackageCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Package
     */
    select?: PackageSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Package
     */
    omit?: PackageOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PackageInclude<ExtArgs> | null
    /**
     * The data needed to create a Package.
     */
    data: XOR<PackageCreateInput, PackageUncheckedCreateInput>
  }

  /**
   * Package createMany
   */
  export type PackageCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many Packages.
     */
    data: PackageCreateManyInput | PackageCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * Package createManyAndReturn
   */
  export type PackageCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Package
     */
    select?: PackageSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the Package
     */
    omit?: PackageOmit<ExtArgs> | null
    /**
     * The data used to create many Packages.
     */
    data: PackageCreateManyInput | PackageCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * Package update
   */
  export type PackageUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Package
     */
    select?: PackageSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Package
     */
    omit?: PackageOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PackageInclude<ExtArgs> | null
    /**
     * The data needed to update a Package.
     */
    data: XOR<PackageUpdateInput, PackageUncheckedUpdateInput>
    /**
     * Choose, which Package to update.
     */
    where: PackageWhereUniqueInput
  }

  /**
   * Package updateMany
   */
  export type PackageUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Packages.
     */
    data: XOR<PackageUpdateManyMutationInput, PackageUncheckedUpdateManyInput>
    /**
     * Filter which Packages to update
     */
    where?: PackageWhereInput
    /**
     * Limit how many Packages to update.
     */
    limit?: number
  }

  /**
   * Package updateManyAndReturn
   */
  export type PackageUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Package
     */
    select?: PackageSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the Package
     */
    omit?: PackageOmit<ExtArgs> | null
    /**
     * The data used to update Packages.
     */
    data: XOR<PackageUpdateManyMutationInput, PackageUncheckedUpdateManyInput>
    /**
     * Filter which Packages to update
     */
    where?: PackageWhereInput
    /**
     * Limit how many Packages to update.
     */
    limit?: number
  }

  /**
   * Package upsert
   */
  export type PackageUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Package
     */
    select?: PackageSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Package
     */
    omit?: PackageOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PackageInclude<ExtArgs> | null
    /**
     * The filter to search for the Package to update in case it exists.
     */
    where: PackageWhereUniqueInput
    /**
     * In case the Package found by the `where` argument doesn't exist, create a new Package with this data.
     */
    create: XOR<PackageCreateInput, PackageUncheckedCreateInput>
    /**
     * In case the Package was found with the provided `where` argument, update it with this data.
     */
    update: XOR<PackageUpdateInput, PackageUncheckedUpdateInput>
  }

  /**
   * Package delete
   */
  export type PackageDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Package
     */
    select?: PackageSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Package
     */
    omit?: PackageOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PackageInclude<ExtArgs> | null
    /**
     * Filter which Package to delete.
     */
    where: PackageWhereUniqueInput
  }

  /**
   * Package deleteMany
   */
  export type PackageDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Packages to delete
     */
    where?: PackageWhereInput
    /**
     * Limit how many Packages to delete.
     */
    limit?: number
  }

  /**
   * Package.payments
   */
  export type Package$paymentsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Payment
     */
    select?: PaymentSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Payment
     */
    omit?: PaymentOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PaymentInclude<ExtArgs> | null
    where?: PaymentWhereInput
    orderBy?: PaymentOrderByWithRelationInput | PaymentOrderByWithRelationInput[]
    cursor?: PaymentWhereUniqueInput
    take?: number
    skip?: number
    distinct?: PaymentScalarFieldEnum | PaymentScalarFieldEnum[]
  }

  /**
   * Package without action
   */
  export type PackageDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Package
     */
    select?: PackageSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Package
     */
    omit?: PackageOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PackageInclude<ExtArgs> | null
  }


  /**
   * Model Payment
   */

  export type AggregatePayment = {
    _count: PaymentCountAggregateOutputType | null
    _avg: PaymentAvgAggregateOutputType | null
    _sum: PaymentSumAggregateOutputType | null
    _min: PaymentMinAggregateOutputType | null
    _max: PaymentMaxAggregateOutputType | null
  }

  export type PaymentAvgAggregateOutputType = {
    amount: number | null
  }

  export type PaymentSumAggregateOutputType = {
    amount: number | null
  }

  export type PaymentMinAggregateOutputType = {
    id: string | null
    userId: string | null
    packageId: string | null
    amount: number | null
    authority: string | null
    refId: string | null
    status: $Enums.PaymentStatus | null
    createdAt: Date | null
    updatedAt: Date | null
  }

  export type PaymentMaxAggregateOutputType = {
    id: string | null
    userId: string | null
    packageId: string | null
    amount: number | null
    authority: string | null
    refId: string | null
    status: $Enums.PaymentStatus | null
    createdAt: Date | null
    updatedAt: Date | null
  }

  export type PaymentCountAggregateOutputType = {
    id: number
    userId: number
    packageId: number
    amount: number
    authority: number
    refId: number
    status: number
    createdAt: number
    updatedAt: number
    _all: number
  }


  export type PaymentAvgAggregateInputType = {
    amount?: true
  }

  export type PaymentSumAggregateInputType = {
    amount?: true
  }

  export type PaymentMinAggregateInputType = {
    id?: true
    userId?: true
    packageId?: true
    amount?: true
    authority?: true
    refId?: true
    status?: true
    createdAt?: true
    updatedAt?: true
  }

  export type PaymentMaxAggregateInputType = {
    id?: true
    userId?: true
    packageId?: true
    amount?: true
    authority?: true
    refId?: true
    status?: true
    createdAt?: true
    updatedAt?: true
  }

  export type PaymentCountAggregateInputType = {
    id?: true
    userId?: true
    packageId?: true
    amount?: true
    authority?: true
    refId?: true
    status?: true
    createdAt?: true
    updatedAt?: true
    _all?: true
  }

  export type PaymentAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Payment to aggregate.
     */
    where?: PaymentWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Payments to fetch.
     */
    orderBy?: PaymentOrderByWithRelationInput | PaymentOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: PaymentWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Payments 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` Payments.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned Payments
    **/
    _count?: true | PaymentCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: PaymentAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: PaymentSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: PaymentMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: PaymentMaxAggregateInputType
  }

  export type GetPaymentAggregateType<T extends PaymentAggregateArgs> = {
        [P in keyof T & keyof AggregatePayment]: P extends '_count' | 'count'
      ? T[P] extends true
        ? number
        : GetScalarType<T[P], AggregatePayment[P]>
      : GetScalarType<T[P], AggregatePayment[P]>
  }




  export type PaymentGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: PaymentWhereInput
    orderBy?: PaymentOrderByWithAggregationInput | PaymentOrderByWithAggregationInput[]
    by: PaymentScalarFieldEnum[] | PaymentScalarFieldEnum
    having?: PaymentScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: PaymentCountAggregateInputType | true
    _avg?: PaymentAvgAggregateInputType
    _sum?: PaymentSumAggregateInputType
    _min?: PaymentMinAggregateInputType
    _max?: PaymentMaxAggregateInputType
  }

  export type PaymentGroupByOutputType = {
    id: string
    userId: string
    packageId: string
    amount: number
    authority: string | null
    refId: string | null
    status: $Enums.PaymentStatus
    createdAt: Date
    updatedAt: Date
    _count: PaymentCountAggregateOutputType | null
    _avg: PaymentAvgAggregateOutputType | null
    _sum: PaymentSumAggregateOutputType | null
    _min: PaymentMinAggregateOutputType | null
    _max: PaymentMaxAggregateOutputType | null
  }

  type GetPaymentGroupByPayload<T extends PaymentGroupByArgs> = Prisma.PrismaPromise<
    Array<
      PickEnumerable<PaymentGroupByOutputType, T['by']> &
        {
          [P in ((keyof T) & (keyof PaymentGroupByOutputType))]: P extends '_count'
            ? T[P] extends boolean
              ? number
              : GetScalarType<T[P], PaymentGroupByOutputType[P]>
            : GetScalarType<T[P], PaymentGroupByOutputType[P]>
        }
      >
    >


  export type PaymentSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    userId?: boolean
    packageId?: boolean
    amount?: boolean
    authority?: boolean
    refId?: boolean
    status?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    user?: boolean | UserDefaultArgs<ExtArgs>
    package?: boolean | PackageDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["payment"]>

  export type PaymentSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    userId?: boolean
    packageId?: boolean
    amount?: boolean
    authority?: boolean
    refId?: boolean
    status?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    user?: boolean | UserDefaultArgs<ExtArgs>
    package?: boolean | PackageDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["payment"]>

  export type PaymentSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    userId?: boolean
    packageId?: boolean
    amount?: boolean
    authority?: boolean
    refId?: boolean
    status?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    user?: boolean | UserDefaultArgs<ExtArgs>
    package?: boolean | PackageDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["payment"]>

  export type PaymentSelectScalar = {
    id?: boolean
    userId?: boolean
    packageId?: boolean
    amount?: boolean
    authority?: boolean
    refId?: boolean
    status?: boolean
    createdAt?: boolean
    updatedAt?: boolean
  }

  export type PaymentOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "userId" | "packageId" | "amount" | "authority" | "refId" | "status" | "createdAt" | "updatedAt", ExtArgs["result"]["payment"]>
  export type PaymentInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
    package?: boolean | PackageDefaultArgs<ExtArgs>
  }
  export type PaymentIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
    package?: boolean | PackageDefaultArgs<ExtArgs>
  }
  export type PaymentIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
    package?: boolean | PackageDefaultArgs<ExtArgs>
  }

  export type $PaymentPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Payment"
    objects: {
      user: Prisma.$UserPayload<ExtArgs>
      package: Prisma.$PackagePayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      userId: string
      packageId: string
      amount: number
      authority: string | null
      refId: string | null
      status: $Enums.PaymentStatus
      createdAt: Date
      updatedAt: Date
    }, ExtArgs["result"]["payment"]>
    composites: {}
  }

  type PaymentGetPayload<S extends boolean | null | undefined | PaymentDefaultArgs> = $Result.GetResult<Prisma.$PaymentPayload, S>

  type PaymentCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
    Omit<PaymentFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
      select?: PaymentCountAggregateInputType | true
    }

  export interface PaymentDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> {
    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['Payment'], meta: { name: 'Payment' } }
    /**
     * Find zero or one Payment that matches the filter.
     * @param {PaymentFindUniqueArgs} args - Arguments to find a Payment
     * @example
     * // Get one Payment
     * const payment = await prisma.payment.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUnique<T extends PaymentFindUniqueArgs>(args: SelectSubset<T, PaymentFindUniqueArgs<ExtArgs>>): Prisma__PaymentClient<$Result.GetResult<Prisma.$PaymentPayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find one Payment that matches the filter or throw an error with `error.code='P2025'`
     * if no matches were found.
     * @param {PaymentFindUniqueOrThrowArgs} args - Arguments to find a Payment
     * @example
     * // Get one Payment
     * const payment = await prisma.payment.findUniqueOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUniqueOrThrow<T extends PaymentFindUniqueOrThrowArgs>(args: SelectSubset<T, PaymentFindUniqueOrThrowArgs<ExtArgs>>): Prisma__PaymentClient<$Result.GetResult<Prisma.$PaymentPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first Payment 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 {PaymentFindFirstArgs} args - Arguments to find a Payment
     * @example
     * // Get one Payment
     * const payment = await prisma.payment.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends PaymentFindFirstArgs>(args?: SelectSubset<T, PaymentFindFirstArgs<ExtArgs>>): Prisma__PaymentClient<$Result.GetResult<Prisma.$PaymentPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first Payment 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 {PaymentFindFirstOrThrowArgs} args - Arguments to find a Payment
     * @example
     * // Get one Payment
     * const payment = await prisma.payment.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends PaymentFindFirstOrThrowArgs>(args?: SelectSubset<T, PaymentFindFirstOrThrowArgs<ExtArgs>>): Prisma__PaymentClient<$Result.GetResult<Prisma.$PaymentPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find zero or more Payments 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 {PaymentFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all Payments
     * const payments = await prisma.payment.findMany()
     * 
     * // Get first 10 Payments
     * const payments = await prisma.payment.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const paymentWithIdOnly = await prisma.payment.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends PaymentFindManyArgs>(args?: SelectSubset<T, PaymentFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$PaymentPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>

    /**
     * Create a Payment.
     * @param {PaymentCreateArgs} args - Arguments to create a Payment.
     * @example
     * // Create one Payment
     * const Payment = await prisma.payment.create({
     *   data: {
     *     // ... data to create a Payment
     *   }
     * })
     * 
     */
    create<T extends PaymentCreateArgs>(args: SelectSubset<T, PaymentCreateArgs<ExtArgs>>): Prisma__PaymentClient<$Result.GetResult<Prisma.$PaymentPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Create many Payments.
     * @param {PaymentCreateManyArgs} args - Arguments to create many Payments.
     * @example
     * // Create many Payments
     * const payment = await prisma.payment.createMany({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     *     
     */
    createMany<T extends PaymentCreateManyArgs>(args?: SelectSubset<T, PaymentCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create many Payments and returns the data saved in the database.
     * @param {PaymentCreateManyAndReturnArgs} args - Arguments to create many Payments.
     * @example
     * // Create many Payments
     * const payment = await prisma.payment.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many Payments and only return the `id`
     * const paymentWithIdOnly = await prisma.payment.createManyAndReturn({
     *   select: { id: true },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    createManyAndReturn<T extends PaymentCreateManyAndReturnArgs>(args?: SelectSubset<T, PaymentCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$PaymentPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>

    /**
     * Delete a Payment.
     * @param {PaymentDeleteArgs} args - Arguments to delete one Payment.
     * @example
     * // Delete one Payment
     * const Payment = await prisma.payment.delete({
     *   where: {
     *     // ... filter to delete one Payment
     *   }
     * })
     * 
     */
    delete<T extends PaymentDeleteArgs>(args: SelectSubset<T, PaymentDeleteArgs<ExtArgs>>): Prisma__PaymentClient<$Result.GetResult<Prisma.$PaymentPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Update one Payment.
     * @param {PaymentUpdateArgs} args - Arguments to update one Payment.
     * @example
     * // Update one Payment
     * const payment = await prisma.payment.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends PaymentUpdateArgs>(args: SelectSubset<T, PaymentUpdateArgs<ExtArgs>>): Prisma__PaymentClient<$Result.GetResult<Prisma.$PaymentPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Delete zero or more Payments.
     * @param {PaymentDeleteManyArgs} args - Arguments to filter Payments to delete.
     * @example
     * // Delete a few Payments
     * const { count } = await prisma.payment.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
     */
    deleteMany<T extends PaymentDeleteManyArgs>(args?: SelectSubset<T, PaymentDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more Payments.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {PaymentUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many Payments
     * const payment = await prisma.payment.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    updateMany<T extends PaymentUpdateManyArgs>(args: SelectSubset<T, PaymentUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more Payments and returns the data updated in the database.
     * @param {PaymentUpdateManyAndReturnArgs} args - Arguments to update many Payments.
     * @example
     * // Update many Payments
     * const payment = await prisma.payment.updateManyAndReturn({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Update zero or more Payments and only return the `id`
     * const paymentWithIdOnly = await prisma.payment.updateManyAndReturn({
     *   select: { id: true },
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    updateManyAndReturn<T extends PaymentUpdateManyAndReturnArgs>(args: SelectSubset<T, PaymentUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$PaymentPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>

    /**
     * Create or update one Payment.
     * @param {PaymentUpsertArgs} args - Arguments to update or create a Payment.
     * @example
     * // Update or create a Payment
     * const payment = await prisma.payment.upsert({
     *   create: {
     *     // ... data to create a Payment
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the Payment we want to update
     *   }
     * })
     */
    upsert<T extends PaymentUpsertArgs>(args: SelectSubset<T, PaymentUpsertArgs<ExtArgs>>): Prisma__PaymentClient<$Result.GetResult<Prisma.$PaymentPayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>


    /**
     * Count the number of Payments.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {PaymentCountArgs} args - Arguments to filter Payments to count.
     * @example
     * // Count the number of Payments
     * const count = await prisma.payment.count({
     *   where: {
     *     // ... the filter for the Payments we want to count
     *   }
     * })
    **/
    count<T extends PaymentCountArgs>(
      args?: Subset<T, PaymentCountArgs>,
    ): Prisma.PrismaPromise<
      T extends $Utils.Record<'select', any>
        ? T['select'] extends true
          ? number
          : GetScalarType<T['select'], PaymentCountAggregateOutputType>
        : number
    >

    /**
     * Allows you to perform aggregations operations on a Payment.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {PaymentAggregateArgs} 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 PaymentAggregateArgs>(args: Subset<T, PaymentAggregateArgs>): Prisma.PrismaPromise<GetPaymentAggregateType<T>>

    /**
     * Group by Payment.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {PaymentGroupByArgs} 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 PaymentGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: PaymentGroupByArgs['orderBy'] }
        : { orderBy?: PaymentGroupByArgs['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, PaymentGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetPaymentGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the Payment model
   */
  readonly fields: PaymentFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for Payment.
   * 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__PaymentClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    user<T extends UserDefaultArgs<ExtArgs> = {}>(args?: Subset<T, UserDefaultArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
    package<T extends PackageDefaultArgs<ExtArgs> = {}>(args?: Subset<T, PackageDefaultArgs<ExtArgs>>): Prisma__PackageClient<$Result.GetResult<Prisma.$PackagePayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
    /**
     * 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 Payment model
   */
  interface PaymentFieldRefs {
    readonly id: FieldRef<"Payment", 'String'>
    readonly userId: FieldRef<"Payment", 'String'>
    readonly packageId: FieldRef<"Payment", 'String'>
    readonly amount: FieldRef<"Payment", 'Int'>
    readonly authority: FieldRef<"Payment", 'String'>
    readonly refId: FieldRef<"Payment", 'String'>
    readonly status: FieldRef<"Payment", 'PaymentStatus'>
    readonly createdAt: FieldRef<"Payment", 'DateTime'>
    readonly updatedAt: FieldRef<"Payment", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * Payment findUnique
   */
  export type PaymentFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Payment
     */
    select?: PaymentSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Payment
     */
    omit?: PaymentOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PaymentInclude<ExtArgs> | null
    /**
     * Filter, which Payment to fetch.
     */
    where: PaymentWhereUniqueInput
  }

  /**
   * Payment findUniqueOrThrow
   */
  export type PaymentFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Payment
     */
    select?: PaymentSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Payment
     */
    omit?: PaymentOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PaymentInclude<ExtArgs> | null
    /**
     * Filter, which Payment to fetch.
     */
    where: PaymentWhereUniqueInput
  }

  /**
   * Payment findFirst
   */
  export type PaymentFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Payment
     */
    select?: PaymentSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Payment
     */
    omit?: PaymentOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PaymentInclude<ExtArgs> | null
    /**
     * Filter, which Payment to fetch.
     */
    where?: PaymentWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Payments to fetch.
     */
    orderBy?: PaymentOrderByWithRelationInput | PaymentOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Payments.
     */
    cursor?: PaymentWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Payments 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` Payments.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Payments.
     */
    distinct?: PaymentScalarFieldEnum | PaymentScalarFieldEnum[]
  }

  /**
   * Payment findFirstOrThrow
   */
  export type PaymentFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Payment
     */
    select?: PaymentSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Payment
     */
    omit?: PaymentOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PaymentInclude<ExtArgs> | null
    /**
     * Filter, which Payment to fetch.
     */
    where?: PaymentWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Payments to fetch.
     */
    orderBy?: PaymentOrderByWithRelationInput | PaymentOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Payments.
     */
    cursor?: PaymentWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Payments 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` Payments.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Payments.
     */
    distinct?: PaymentScalarFieldEnum | PaymentScalarFieldEnum[]
  }

  /**
   * Payment findMany
   */
  export type PaymentFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Payment
     */
    select?: PaymentSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Payment
     */
    omit?: PaymentOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PaymentInclude<ExtArgs> | null
    /**
     * Filter, which Payments to fetch.
     */
    where?: PaymentWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Payments to fetch.
     */
    orderBy?: PaymentOrderByWithRelationInput | PaymentOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing Payments.
     */
    cursor?: PaymentWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Payments 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` Payments.
     */
    skip?: number
    distinct?: PaymentScalarFieldEnum | PaymentScalarFieldEnum[]
  }

  /**
   * Payment create
   */
  export type PaymentCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Payment
     */
    select?: PaymentSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Payment
     */
    omit?: PaymentOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PaymentInclude<ExtArgs> | null
    /**
     * The data needed to create a Payment.
     */
    data: XOR<PaymentCreateInput, PaymentUncheckedCreateInput>
  }

  /**
   * Payment createMany
   */
  export type PaymentCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many Payments.
     */
    data: PaymentCreateManyInput | PaymentCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * Payment createManyAndReturn
   */
  export type PaymentCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Payment
     */
    select?: PaymentSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the Payment
     */
    omit?: PaymentOmit<ExtArgs> | null
    /**
     * The data used to create many Payments.
     */
    data: PaymentCreateManyInput | PaymentCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PaymentIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * Payment update
   */
  export type PaymentUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Payment
     */
    select?: PaymentSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Payment
     */
    omit?: PaymentOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PaymentInclude<ExtArgs> | null
    /**
     * The data needed to update a Payment.
     */
    data: XOR<PaymentUpdateInput, PaymentUncheckedUpdateInput>
    /**
     * Choose, which Payment to update.
     */
    where: PaymentWhereUniqueInput
  }

  /**
   * Payment updateMany
   */
  export type PaymentUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Payments.
     */
    data: XOR<PaymentUpdateManyMutationInput, PaymentUncheckedUpdateManyInput>
    /**
     * Filter which Payments to update
     */
    where?: PaymentWhereInput
    /**
     * Limit how many Payments to update.
     */
    limit?: number
  }

  /**
   * Payment updateManyAndReturn
   */
  export type PaymentUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Payment
     */
    select?: PaymentSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the Payment
     */
    omit?: PaymentOmit<ExtArgs> | null
    /**
     * The data used to update Payments.
     */
    data: XOR<PaymentUpdateManyMutationInput, PaymentUncheckedUpdateManyInput>
    /**
     * Filter which Payments to update
     */
    where?: PaymentWhereInput
    /**
     * Limit how many Payments to update.
     */
    limit?: number
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PaymentIncludeUpdateManyAndReturn<ExtArgs> | null
  }

  /**
   * Payment upsert
   */
  export type PaymentUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Payment
     */
    select?: PaymentSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Payment
     */
    omit?: PaymentOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PaymentInclude<ExtArgs> | null
    /**
     * The filter to search for the Payment to update in case it exists.
     */
    where: PaymentWhereUniqueInput
    /**
     * In case the Payment found by the `where` argument doesn't exist, create a new Payment with this data.
     */
    create: XOR<PaymentCreateInput, PaymentUncheckedCreateInput>
    /**
     * In case the Payment was found with the provided `where` argument, update it with this data.
     */
    update: XOR<PaymentUpdateInput, PaymentUncheckedUpdateInput>
  }

  /**
   * Payment delete
   */
  export type PaymentDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Payment
     */
    select?: PaymentSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Payment
     */
    omit?: PaymentOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PaymentInclude<ExtArgs> | null
    /**
     * Filter which Payment to delete.
     */
    where: PaymentWhereUniqueInput
  }

  /**
   * Payment deleteMany
   */
  export type PaymentDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Payments to delete
     */
    where?: PaymentWhereInput
    /**
     * Limit how many Payments to delete.
     */
    limit?: number
  }

  /**
   * Payment without action
   */
  export type PaymentDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Payment
     */
    select?: PaymentSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Payment
     */
    omit?: PaymentOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PaymentInclude<ExtArgs> | null
  }


  /**
   * Enums
   */

  export const TransactionIsolationLevel: {
    ReadUncommitted: 'ReadUncommitted',
    ReadCommitted: 'ReadCommitted',
    RepeatableRead: 'RepeatableRead',
    Serializable: 'Serializable'
  };

  export type TransactionIsolationLevel = (typeof TransactionIsolationLevel)[keyof typeof TransactionIsolationLevel]


  export const CountryScalarFieldEnum: {
    id: 'id',
    name: 'name',
    code: 'code',
    flagUrl: 'flagUrl',
    flagImage: 'flagImage',
    confederation: 'confederation',
    qualificationMethod: 'qualificationMethod',
    qualificationDate: 'qualificationDate',
    participationHistory: 'participationHistory',
    bestResult: 'bestResult',
    description: 'description',
    defaultFormation: 'defaultFormation',
    defaultLineupPlayerIds: 'defaultLineupPlayerIds',
    defaultCaptainId: 'defaultCaptainId',
    groupId: 'groupId',
    isEliminated: 'isEliminated'
  };

  export type CountryScalarFieldEnum = (typeof CountryScalarFieldEnum)[keyof typeof CountryScalarFieldEnum]


  export const GroupScalarFieldEnum: {
    id: 'id',
    name: 'name'
  };

  export type GroupScalarFieldEnum = (typeof GroupScalarFieldEnum)[keyof typeof GroupScalarFieldEnum]


  export const PlayerScalarFieldEnum: {
    id: 'id',
    name: 'name',
    image: 'image',
    position: 'position',
    countryId: 'countryId',
    price: 'price',
    totalPoints: 'totalPoints',
    isActive: 'isActive',
    isGoldenCardEligible: 'isGoldenCardEligible',
    cardTier: 'cardTier',
    createdAt: 'createdAt',
    updatedAt: 'updatedAt'
  };

  export type PlayerScalarFieldEnum = (typeof PlayerScalarFieldEnum)[keyof typeof PlayerScalarFieldEnum]


  export const MatchScalarFieldEnum: {
    id: 'id',
    homeTeamId: 'homeTeamId',
    awayTeamId: 'awayTeamId',
    homeScore: 'homeScore',
    awayScore: 'awayScore',
    stage: 'stage',
    status: 'status',
    matchDate: 'matchDate',
    matchDatePersian: 'matchDatePersian',
    stadium: 'stadium',
    city: 'city',
    referee: 'referee',
    assistant1: 'assistant1',
    assistant2: 'assistant2',
    fourthOfficial: 'fourthOfficial',
    attendance: 'attendance',
    weather: 'weather',
    description: 'description',
    roundId: 'roundId',
    createdAt: 'createdAt'
  };

  export type MatchScalarFieldEnum = (typeof MatchScalarFieldEnum)[keyof typeof MatchScalarFieldEnum]


  export const RoundScalarFieldEnum: {
    id: 'id',
    number: 'number',
    name: 'name',
    isActive: 'isActive',
    deadline: 'deadline',
    createdAt: 'createdAt'
  };

  export type RoundScalarFieldEnum = (typeof RoundScalarFieldEnum)[keyof typeof RoundScalarFieldEnum]


  export const GameweekScalarFieldEnum: {
    id: 'id',
    number: 'number',
    name: 'name',
    isActive: 'isActive',
    deadline: 'deadline',
    createdAt: 'createdAt'
  };

  export type GameweekScalarFieldEnum = (typeof GameweekScalarFieldEnum)[keyof typeof GameweekScalarFieldEnum]


  export const MatchEventScalarFieldEnum: {
    id: 'id',
    matchId: 'matchId',
    playerId: 'playerId',
    type: 'type',
    minute: 'minute',
    extraInfo: 'extraInfo',
    createdAt: 'createdAt'
  };

  export type MatchEventScalarFieldEnum = (typeof MatchEventScalarFieldEnum)[keyof typeof MatchEventScalarFieldEnum]


  export const MatchLineupScalarFieldEnum: {
    id: 'id',
    matchId: 'matchId',
    countryId: 'countryId',
    formation: 'formation',
    playerIds: 'playerIds'
  };

  export type MatchLineupScalarFieldEnum = (typeof MatchLineupScalarFieldEnum)[keyof typeof MatchLineupScalarFieldEnum]


  export const PlayerMatchStatScalarFieldEnum: {
    id: 'id',
    playerId: 'playerId',
    matchId: 'matchId',
    goals: 'goals',
    assists: 'assists',
    yellowCards: 'yellowCards',
    redCards: 'redCards',
    minutesPlayed: 'minutesPlayed',
    cleanSheet: 'cleanSheet',
    penaltySaved: 'penaltySaved',
    penaltyMissed: 'penaltyMissed',
    ownGoals: 'ownGoals',
    isMotm: 'isMotm',
    extraTimeBonus: 'extraTimeBonus',
    points: 'points'
  };

  export type PlayerMatchStatScalarFieldEnum = (typeof PlayerMatchStatScalarFieldEnum)[keyof typeof PlayerMatchStatScalarFieldEnum]


  export const ScoringRuleScalarFieldEnum: {
    id: 'id',
    position: 'position',
    eventType: 'eventType',
    points: 'points',
    updatedAt: 'updatedAt',
    updatedBy: 'updatedBy'
  };

  export type ScoringRuleScalarFieldEnum = (typeof ScoringRuleScalarFieldEnum)[keyof typeof ScoringRuleScalarFieldEnum]


  export const UserScalarFieldEnum: {
    id: 'id',
    name: 'name',
    email: 'email',
    phone: 'phone',
    password: 'password',
    role: 'role',
    createdAt: 'createdAt'
  };

  export type UserScalarFieldEnum = (typeof UserScalarFieldEnum)[keyof typeof UserScalarFieldEnum]


  export const LoginOtpScalarFieldEnum: {
    id: 'id',
    phone: 'phone',
    codeHash: 'codeHash',
    attempts: 'attempts',
    expiresAt: 'expiresAt',
    consumedAt: 'consumedAt',
    createdAt: 'createdAt'
  };

  export type LoginOtpScalarFieldEnum = (typeof LoginOtpScalarFieldEnum)[keyof typeof LoginOtpScalarFieldEnum]


  export const FantasyNewsScalarFieldEnum: {
    id: 'id',
    icon: 'icon',
    title: 'title',
    description: 'description',
    newsTime: 'newsTime',
    createdAt: 'createdAt',
    updatedAt: 'updatedAt'
  };

  export type FantasyNewsScalarFieldEnum = (typeof FantasyNewsScalarFieldEnum)[keyof typeof FantasyNewsScalarFieldEnum]


  export const DailyQuizScalarFieldEnum: {
    id: 'id',
    date: 'date',
    windowStart: 'windowStart',
    windowEnd: 'windowEnd',
    goldWinnersCount: 'goldWinnersCount',
    silverWinnersCount: 'silverWinnersCount',
    bronzeWinnersCount: 'bronzeWinnersCount',
    goldMinCorrect: 'goldMinCorrect',
    silverMinCorrect: 'silverMinCorrect',
    bronzeMinCorrect: 'bronzeMinCorrect',
    isProcessed: 'isProcessed',
    createdAt: 'createdAt'
  };

  export type DailyQuizScalarFieldEnum = (typeof DailyQuizScalarFieldEnum)[keyof typeof DailyQuizScalarFieldEnum]


  export const QuizQuestionScalarFieldEnum: {
    id: 'id',
    quizId: 'quizId',
    questionText: 'questionText',
    options: 'options',
    correctAnswer: 'correctAnswer',
    order: 'order'
  };

  export type QuizQuestionScalarFieldEnum = (typeof QuizQuestionScalarFieldEnum)[keyof typeof QuizQuestionScalarFieldEnum]


  export const QuizSubmissionScalarFieldEnum: {
    id: 'id',
    userId: 'userId',
    quizId: 'quizId',
    answers: 'answers',
    correctAnswers: 'correctAnswers',
    score: 'score',
    submittedAt: 'submittedAt'
  };

  export type QuizSubmissionScalarFieldEnum = (typeof QuizSubmissionScalarFieldEnum)[keyof typeof QuizSubmissionScalarFieldEnum]


  export const GoldenCardScalarFieldEnum: {
    id: 'id',
    userId: 'userId',
    quizId: 'quizId',
    playerId: 'playerId',
    cardTier: 'cardTier',
    status: 'status',
    state: 'state',
    acquiredDate: 'acquiredDate',
    openedAt: 'openedAt'
  };

  export type GoldenCardScalarFieldEnum = (typeof GoldenCardScalarFieldEnum)[keyof typeof GoldenCardScalarFieldEnum]


  export const SessionScalarFieldEnum: {
    id: 'id',
    sessionToken: 'sessionToken',
    userId: 'userId',
    expires: 'expires'
  };

  export type SessionScalarFieldEnum = (typeof SessionScalarFieldEnum)[keyof typeof SessionScalarFieldEnum]


  export const TeamScalarFieldEnum: {
    id: 'id',
    name: 'name',
    userId: 'userId',
    budget: 'budget',
    totalPoints: 'totalPoints',
    formation: 'formation',
    status: 'status',
    createdAt: 'createdAt'
  };

  export type TeamScalarFieldEnum = (typeof TeamScalarFieldEnum)[keyof typeof TeamScalarFieldEnum]


  export const TeamPlayerScalarFieldEnum: {
    teamId: 'teamId',
    playerId: 'playerId',
    goldenCardId: 'goldenCardId',
    isCaptain: 'isCaptain',
    isViceCaptain: 'isViceCaptain',
    isBench: 'isBench',
    positionIndex: 'positionIndex'
  };

  export type TeamPlayerScalarFieldEnum = (typeof TeamPlayerScalarFieldEnum)[keyof typeof TeamPlayerScalarFieldEnum]


  export const PackageScalarFieldEnum: {
    id: 'id',
    name: 'name',
    budgetBonus: 'budgetBonus',
    price: 'price',
    description: 'description',
    isActive: 'isActive'
  };

  export type PackageScalarFieldEnum = (typeof PackageScalarFieldEnum)[keyof typeof PackageScalarFieldEnum]


  export const PaymentScalarFieldEnum: {
    id: 'id',
    userId: 'userId',
    packageId: 'packageId',
    amount: 'amount',
    authority: 'authority',
    refId: 'refId',
    status: 'status',
    createdAt: 'createdAt',
    updatedAt: 'updatedAt'
  };

  export type PaymentScalarFieldEnum = (typeof PaymentScalarFieldEnum)[keyof typeof PaymentScalarFieldEnum]


  export const SortOrder: {
    asc: 'asc',
    desc: 'desc'
  };

  export type SortOrder = (typeof SortOrder)[keyof typeof SortOrder]


  export const QueryMode: {
    default: 'default',
    insensitive: 'insensitive'
  };

  export type QueryMode = (typeof QueryMode)[keyof typeof QueryMode]


  export const NullsOrder: {
    first: 'first',
    last: 'last'
  };

  export type NullsOrder = (typeof NullsOrder)[keyof typeof NullsOrder]


  /**
   * Field references
   */


  /**
   * Reference to a field of type 'String'
   */
  export type StringFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'String'>
    


  /**
   * Reference to a field of type 'String[]'
   */
  export type ListStringFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'String[]'>
    


  /**
   * Reference to a field of type 'Boolean'
   */
  export type BooleanFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Boolean'>
    


  /**
   * Reference to a field of type 'Position'
   */
  export type EnumPositionFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Position'>
    


  /**
   * Reference to a field of type 'Position[]'
   */
  export type ListEnumPositionFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Position[]'>
    


  /**
   * Reference to a field of type 'Float'
   */
  export type FloatFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Float'>
    


  /**
   * Reference to a field of type 'Float[]'
   */
  export type ListFloatFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Float[]'>
    


  /**
   * Reference to a field of type 'Int'
   */
  export type IntFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Int'>
    


  /**
   * Reference to a field of type 'Int[]'
   */
  export type ListIntFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Int[]'>
    


  /**
   * Reference to a field of type 'CardTier'
   */
  export type EnumCardTierFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'CardTier'>
    


  /**
   * Reference to a field of type 'CardTier[]'
   */
  export type ListEnumCardTierFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'CardTier[]'>
    


  /**
   * Reference to a field of type 'DateTime'
   */
  export type DateTimeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'DateTime'>
    


  /**
   * Reference to a field of type 'DateTime[]'
   */
  export type ListDateTimeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'DateTime[]'>
    


  /**
   * Reference to a field of type 'MatchStage'
   */
  export type EnumMatchStageFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'MatchStage'>
    


  /**
   * Reference to a field of type 'MatchStage[]'
   */
  export type ListEnumMatchStageFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'MatchStage[]'>
    


  /**
   * Reference to a field of type 'MatchStatus'
   */
  export type EnumMatchStatusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'MatchStatus'>
    


  /**
   * Reference to a field of type 'MatchStatus[]'
   */
  export type ListEnumMatchStatusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'MatchStatus[]'>
    


  /**
   * Reference to a field of type 'EventType'
   */
  export type EnumEventTypeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'EventType'>
    


  /**
   * Reference to a field of type 'EventType[]'
   */
  export type ListEnumEventTypeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'EventType[]'>
    


  /**
   * Reference to a field of type 'Role'
   */
  export type EnumRoleFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Role'>
    


  /**
   * Reference to a field of type 'Role[]'
   */
  export type ListEnumRoleFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Role[]'>
    


  /**
   * Reference to a field of type 'GoldenCardStatus'
   */
  export type EnumGoldenCardStatusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'GoldenCardStatus'>
    


  /**
   * Reference to a field of type 'GoldenCardStatus[]'
   */
  export type ListEnumGoldenCardStatusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'GoldenCardStatus[]'>
    


  /**
   * Reference to a field of type 'SpecialCardState'
   */
  export type EnumSpecialCardStateFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'SpecialCardState'>
    


  /**
   * Reference to a field of type 'SpecialCardState[]'
   */
  export type ListEnumSpecialCardStateFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'SpecialCardState[]'>
    


  /**
   * Reference to a field of type 'TeamStatus'
   */
  export type EnumTeamStatusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'TeamStatus'>
    


  /**
   * Reference to a field of type 'TeamStatus[]'
   */
  export type ListEnumTeamStatusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'TeamStatus[]'>
    


  /**
   * Reference to a field of type 'PaymentStatus'
   */
  export type EnumPaymentStatusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'PaymentStatus'>
    


  /**
   * Reference to a field of type 'PaymentStatus[]'
   */
  export type ListEnumPaymentStatusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'PaymentStatus[]'>
    
  /**
   * Deep Input Types
   */


  export type CountryWhereInput = {
    AND?: CountryWhereInput | CountryWhereInput[]
    OR?: CountryWhereInput[]
    NOT?: CountryWhereInput | CountryWhereInput[]
    id?: StringFilter<"Country"> | string
    name?: StringFilter<"Country"> | string
    code?: StringFilter<"Country"> | string
    flagUrl?: StringNullableFilter<"Country"> | string | null
    flagImage?: StringNullableFilter<"Country"> | string | null
    confederation?: StringNullableFilter<"Country"> | string | null
    qualificationMethod?: StringNullableFilter<"Country"> | string | null
    qualificationDate?: StringNullableFilter<"Country"> | string | null
    participationHistory?: StringNullableFilter<"Country"> | string | null
    bestResult?: StringNullableFilter<"Country"> | string | null
    description?: StringNullableFilter<"Country"> | string | null
    defaultFormation?: StringFilter<"Country"> | string
    defaultLineupPlayerIds?: StringNullableListFilter<"Country">
    defaultCaptainId?: StringNullableFilter<"Country"> | string | null
    groupId?: StringNullableFilter<"Country"> | string | null
    isEliminated?: BoolFilter<"Country"> | boolean
    group?: XOR<GroupNullableScalarRelationFilter, GroupWhereInput> | null
    players?: PlayerListRelationFilter
    homeMatches?: MatchListRelationFilter
    awayMatches?: MatchListRelationFilter
  }

  export type CountryOrderByWithRelationInput = {
    id?: SortOrder
    name?: SortOrder
    code?: SortOrder
    flagUrl?: SortOrderInput | SortOrder
    flagImage?: SortOrderInput | SortOrder
    confederation?: SortOrderInput | SortOrder
    qualificationMethod?: SortOrderInput | SortOrder
    qualificationDate?: SortOrderInput | SortOrder
    participationHistory?: SortOrderInput | SortOrder
    bestResult?: SortOrderInput | SortOrder
    description?: SortOrderInput | SortOrder
    defaultFormation?: SortOrder
    defaultLineupPlayerIds?: SortOrder
    defaultCaptainId?: SortOrderInput | SortOrder
    groupId?: SortOrderInput | SortOrder
    isEliminated?: SortOrder
    group?: GroupOrderByWithRelationInput
    players?: PlayerOrderByRelationAggregateInput
    homeMatches?: MatchOrderByRelationAggregateInput
    awayMatches?: MatchOrderByRelationAggregateInput
  }

  export type CountryWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    name?: string
    code?: string
    AND?: CountryWhereInput | CountryWhereInput[]
    OR?: CountryWhereInput[]
    NOT?: CountryWhereInput | CountryWhereInput[]
    flagUrl?: StringNullableFilter<"Country"> | string | null
    flagImage?: StringNullableFilter<"Country"> | string | null
    confederation?: StringNullableFilter<"Country"> | string | null
    qualificationMethod?: StringNullableFilter<"Country"> | string | null
    qualificationDate?: StringNullableFilter<"Country"> | string | null
    participationHistory?: StringNullableFilter<"Country"> | string | null
    bestResult?: StringNullableFilter<"Country"> | string | null
    description?: StringNullableFilter<"Country"> | string | null
    defaultFormation?: StringFilter<"Country"> | string
    defaultLineupPlayerIds?: StringNullableListFilter<"Country">
    defaultCaptainId?: StringNullableFilter<"Country"> | string | null
    groupId?: StringNullableFilter<"Country"> | string | null
    isEliminated?: BoolFilter<"Country"> | boolean
    group?: XOR<GroupNullableScalarRelationFilter, GroupWhereInput> | null
    players?: PlayerListRelationFilter
    homeMatches?: MatchListRelationFilter
    awayMatches?: MatchListRelationFilter
  }, "id" | "name" | "code">

  export type CountryOrderByWithAggregationInput = {
    id?: SortOrder
    name?: SortOrder
    code?: SortOrder
    flagUrl?: SortOrderInput | SortOrder
    flagImage?: SortOrderInput | SortOrder
    confederation?: SortOrderInput | SortOrder
    qualificationMethod?: SortOrderInput | SortOrder
    qualificationDate?: SortOrderInput | SortOrder
    participationHistory?: SortOrderInput | SortOrder
    bestResult?: SortOrderInput | SortOrder
    description?: SortOrderInput | SortOrder
    defaultFormation?: SortOrder
    defaultLineupPlayerIds?: SortOrder
    defaultCaptainId?: SortOrderInput | SortOrder
    groupId?: SortOrderInput | SortOrder
    isEliminated?: SortOrder
    _count?: CountryCountOrderByAggregateInput
    _max?: CountryMaxOrderByAggregateInput
    _min?: CountryMinOrderByAggregateInput
  }

  export type CountryScalarWhereWithAggregatesInput = {
    AND?: CountryScalarWhereWithAggregatesInput | CountryScalarWhereWithAggregatesInput[]
    OR?: CountryScalarWhereWithAggregatesInput[]
    NOT?: CountryScalarWhereWithAggregatesInput | CountryScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"Country"> | string
    name?: StringWithAggregatesFilter<"Country"> | string
    code?: StringWithAggregatesFilter<"Country"> | string
    flagUrl?: StringNullableWithAggregatesFilter<"Country"> | string | null
    flagImage?: StringNullableWithAggregatesFilter<"Country"> | string | null
    confederation?: StringNullableWithAggregatesFilter<"Country"> | string | null
    qualificationMethod?: StringNullableWithAggregatesFilter<"Country"> | string | null
    qualificationDate?: StringNullableWithAggregatesFilter<"Country"> | string | null
    participationHistory?: StringNullableWithAggregatesFilter<"Country"> | string | null
    bestResult?: StringNullableWithAggregatesFilter<"Country"> | string | null
    description?: StringNullableWithAggregatesFilter<"Country"> | string | null
    defaultFormation?: StringWithAggregatesFilter<"Country"> | string
    defaultLineupPlayerIds?: StringNullableListFilter<"Country">
    defaultCaptainId?: StringNullableWithAggregatesFilter<"Country"> | string | null
    groupId?: StringNullableWithAggregatesFilter<"Country"> | string | null
    isEliminated?: BoolWithAggregatesFilter<"Country"> | boolean
  }

  export type GroupWhereInput = {
    AND?: GroupWhereInput | GroupWhereInput[]
    OR?: GroupWhereInput[]
    NOT?: GroupWhereInput | GroupWhereInput[]
    id?: StringFilter<"Group"> | string
    name?: StringFilter<"Group"> | string
    countries?: CountryListRelationFilter
  }

  export type GroupOrderByWithRelationInput = {
    id?: SortOrder
    name?: SortOrder
    countries?: CountryOrderByRelationAggregateInput
  }

  export type GroupWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    name?: string
    AND?: GroupWhereInput | GroupWhereInput[]
    OR?: GroupWhereInput[]
    NOT?: GroupWhereInput | GroupWhereInput[]
    countries?: CountryListRelationFilter
  }, "id" | "name">

  export type GroupOrderByWithAggregationInput = {
    id?: SortOrder
    name?: SortOrder
    _count?: GroupCountOrderByAggregateInput
    _max?: GroupMaxOrderByAggregateInput
    _min?: GroupMinOrderByAggregateInput
  }

  export type GroupScalarWhereWithAggregatesInput = {
    AND?: GroupScalarWhereWithAggregatesInput | GroupScalarWhereWithAggregatesInput[]
    OR?: GroupScalarWhereWithAggregatesInput[]
    NOT?: GroupScalarWhereWithAggregatesInput | GroupScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"Group"> | string
    name?: StringWithAggregatesFilter<"Group"> | string
  }

  export type PlayerWhereInput = {
    AND?: PlayerWhereInput | PlayerWhereInput[]
    OR?: PlayerWhereInput[]
    NOT?: PlayerWhereInput | PlayerWhereInput[]
    id?: StringFilter<"Player"> | string
    name?: StringFilter<"Player"> | string
    image?: StringNullableFilter<"Player"> | string | null
    position?: EnumPositionFilter<"Player"> | $Enums.Position
    countryId?: StringFilter<"Player"> | string
    price?: FloatFilter<"Player"> | number
    totalPoints?: IntFilter<"Player"> | number
    isActive?: BoolFilter<"Player"> | boolean
    isGoldenCardEligible?: BoolFilter<"Player"> | boolean
    cardTier?: EnumCardTierFilter<"Player"> | $Enums.CardTier
    createdAt?: DateTimeFilter<"Player"> | Date | string
    updatedAt?: DateTimeFilter<"Player"> | Date | string
    country?: XOR<CountryScalarRelationFilter, CountryWhereInput>
    matchStats?: PlayerMatchStatListRelationFilter
    teamPlayers?: TeamPlayerListRelationFilter
    events?: MatchEventListRelationFilter
    goldenCards?: GoldenCardListRelationFilter
  }

  export type PlayerOrderByWithRelationInput = {
    id?: SortOrder
    name?: SortOrder
    image?: SortOrderInput | SortOrder
    position?: SortOrder
    countryId?: SortOrder
    price?: SortOrder
    totalPoints?: SortOrder
    isActive?: SortOrder
    isGoldenCardEligible?: SortOrder
    cardTier?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    country?: CountryOrderByWithRelationInput
    matchStats?: PlayerMatchStatOrderByRelationAggregateInput
    teamPlayers?: TeamPlayerOrderByRelationAggregateInput
    events?: MatchEventOrderByRelationAggregateInput
    goldenCards?: GoldenCardOrderByRelationAggregateInput
  }

  export type PlayerWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: PlayerWhereInput | PlayerWhereInput[]
    OR?: PlayerWhereInput[]
    NOT?: PlayerWhereInput | PlayerWhereInput[]
    name?: StringFilter<"Player"> | string
    image?: StringNullableFilter<"Player"> | string | null
    position?: EnumPositionFilter<"Player"> | $Enums.Position
    countryId?: StringFilter<"Player"> | string
    price?: FloatFilter<"Player"> | number
    totalPoints?: IntFilter<"Player"> | number
    isActive?: BoolFilter<"Player"> | boolean
    isGoldenCardEligible?: BoolFilter<"Player"> | boolean
    cardTier?: EnumCardTierFilter<"Player"> | $Enums.CardTier
    createdAt?: DateTimeFilter<"Player"> | Date | string
    updatedAt?: DateTimeFilter<"Player"> | Date | string
    country?: XOR<CountryScalarRelationFilter, CountryWhereInput>
    matchStats?: PlayerMatchStatListRelationFilter
    teamPlayers?: TeamPlayerListRelationFilter
    events?: MatchEventListRelationFilter
    goldenCards?: GoldenCardListRelationFilter
  }, "id">

  export type PlayerOrderByWithAggregationInput = {
    id?: SortOrder
    name?: SortOrder
    image?: SortOrderInput | SortOrder
    position?: SortOrder
    countryId?: SortOrder
    price?: SortOrder
    totalPoints?: SortOrder
    isActive?: SortOrder
    isGoldenCardEligible?: SortOrder
    cardTier?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    _count?: PlayerCountOrderByAggregateInput
    _avg?: PlayerAvgOrderByAggregateInput
    _max?: PlayerMaxOrderByAggregateInput
    _min?: PlayerMinOrderByAggregateInput
    _sum?: PlayerSumOrderByAggregateInput
  }

  export type PlayerScalarWhereWithAggregatesInput = {
    AND?: PlayerScalarWhereWithAggregatesInput | PlayerScalarWhereWithAggregatesInput[]
    OR?: PlayerScalarWhereWithAggregatesInput[]
    NOT?: PlayerScalarWhereWithAggregatesInput | PlayerScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"Player"> | string
    name?: StringWithAggregatesFilter<"Player"> | string
    image?: StringNullableWithAggregatesFilter<"Player"> | string | null
    position?: EnumPositionWithAggregatesFilter<"Player"> | $Enums.Position
    countryId?: StringWithAggregatesFilter<"Player"> | string
    price?: FloatWithAggregatesFilter<"Player"> | number
    totalPoints?: IntWithAggregatesFilter<"Player"> | number
    isActive?: BoolWithAggregatesFilter<"Player"> | boolean
    isGoldenCardEligible?: BoolWithAggregatesFilter<"Player"> | boolean
    cardTier?: EnumCardTierWithAggregatesFilter<"Player"> | $Enums.CardTier
    createdAt?: DateTimeWithAggregatesFilter<"Player"> | Date | string
    updatedAt?: DateTimeWithAggregatesFilter<"Player"> | Date | string
  }

  export type MatchWhereInput = {
    AND?: MatchWhereInput | MatchWhereInput[]
    OR?: MatchWhereInput[]
    NOT?: MatchWhereInput | MatchWhereInput[]
    id?: StringFilter<"Match"> | string
    homeTeamId?: StringFilter<"Match"> | string
    awayTeamId?: StringFilter<"Match"> | string
    homeScore?: IntNullableFilter<"Match"> | number | null
    awayScore?: IntNullableFilter<"Match"> | number | null
    stage?: EnumMatchStageFilter<"Match"> | $Enums.MatchStage
    status?: EnumMatchStatusFilter<"Match"> | $Enums.MatchStatus
    matchDate?: DateTimeFilter<"Match"> | Date | string
    matchDatePersian?: StringNullableFilter<"Match"> | string | null
    stadium?: StringNullableFilter<"Match"> | string | null
    city?: StringNullableFilter<"Match"> | string | null
    referee?: StringNullableFilter<"Match"> | string | null
    assistant1?: StringNullableFilter<"Match"> | string | null
    assistant2?: StringNullableFilter<"Match"> | string | null
    fourthOfficial?: StringNullableFilter<"Match"> | string | null
    attendance?: IntNullableFilter<"Match"> | number | null
    weather?: StringNullableFilter<"Match"> | string | null
    description?: StringNullableFilter<"Match"> | string | null
    roundId?: StringNullableFilter<"Match"> | string | null
    createdAt?: DateTimeFilter<"Match"> | Date | string
    homeTeam?: XOR<CountryScalarRelationFilter, CountryWhereInput>
    awayTeam?: XOR<CountryScalarRelationFilter, CountryWhereInput>
    round?: XOR<RoundNullableScalarRelationFilter, RoundWhereInput> | null
    playerStats?: PlayerMatchStatListRelationFilter
    events?: MatchEventListRelationFilter
    lineups?: MatchLineupListRelationFilter
  }

  export type MatchOrderByWithRelationInput = {
    id?: SortOrder
    homeTeamId?: SortOrder
    awayTeamId?: SortOrder
    homeScore?: SortOrderInput | SortOrder
    awayScore?: SortOrderInput | SortOrder
    stage?: SortOrder
    status?: SortOrder
    matchDate?: SortOrder
    matchDatePersian?: SortOrderInput | SortOrder
    stadium?: SortOrderInput | SortOrder
    city?: SortOrderInput | SortOrder
    referee?: SortOrderInput | SortOrder
    assistant1?: SortOrderInput | SortOrder
    assistant2?: SortOrderInput | SortOrder
    fourthOfficial?: SortOrderInput | SortOrder
    attendance?: SortOrderInput | SortOrder
    weather?: SortOrderInput | SortOrder
    description?: SortOrderInput | SortOrder
    roundId?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    homeTeam?: CountryOrderByWithRelationInput
    awayTeam?: CountryOrderByWithRelationInput
    round?: RoundOrderByWithRelationInput
    playerStats?: PlayerMatchStatOrderByRelationAggregateInput
    events?: MatchEventOrderByRelationAggregateInput
    lineups?: MatchLineupOrderByRelationAggregateInput
  }

  export type MatchWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: MatchWhereInput | MatchWhereInput[]
    OR?: MatchWhereInput[]
    NOT?: MatchWhereInput | MatchWhereInput[]
    homeTeamId?: StringFilter<"Match"> | string
    awayTeamId?: StringFilter<"Match"> | string
    homeScore?: IntNullableFilter<"Match"> | number | null
    awayScore?: IntNullableFilter<"Match"> | number | null
    stage?: EnumMatchStageFilter<"Match"> | $Enums.MatchStage
    status?: EnumMatchStatusFilter<"Match"> | $Enums.MatchStatus
    matchDate?: DateTimeFilter<"Match"> | Date | string
    matchDatePersian?: StringNullableFilter<"Match"> | string | null
    stadium?: StringNullableFilter<"Match"> | string | null
    city?: StringNullableFilter<"Match"> | string | null
    referee?: StringNullableFilter<"Match"> | string | null
    assistant1?: StringNullableFilter<"Match"> | string | null
    assistant2?: StringNullableFilter<"Match"> | string | null
    fourthOfficial?: StringNullableFilter<"Match"> | string | null
    attendance?: IntNullableFilter<"Match"> | number | null
    weather?: StringNullableFilter<"Match"> | string | null
    description?: StringNullableFilter<"Match"> | string | null
    roundId?: StringNullableFilter<"Match"> | string | null
    createdAt?: DateTimeFilter<"Match"> | Date | string
    homeTeam?: XOR<CountryScalarRelationFilter, CountryWhereInput>
    awayTeam?: XOR<CountryScalarRelationFilter, CountryWhereInput>
    round?: XOR<RoundNullableScalarRelationFilter, RoundWhereInput> | null
    playerStats?: PlayerMatchStatListRelationFilter
    events?: MatchEventListRelationFilter
    lineups?: MatchLineupListRelationFilter
  }, "id">

  export type MatchOrderByWithAggregationInput = {
    id?: SortOrder
    homeTeamId?: SortOrder
    awayTeamId?: SortOrder
    homeScore?: SortOrderInput | SortOrder
    awayScore?: SortOrderInput | SortOrder
    stage?: SortOrder
    status?: SortOrder
    matchDate?: SortOrder
    matchDatePersian?: SortOrderInput | SortOrder
    stadium?: SortOrderInput | SortOrder
    city?: SortOrderInput | SortOrder
    referee?: SortOrderInput | SortOrder
    assistant1?: SortOrderInput | SortOrder
    assistant2?: SortOrderInput | SortOrder
    fourthOfficial?: SortOrderInput | SortOrder
    attendance?: SortOrderInput | SortOrder
    weather?: SortOrderInput | SortOrder
    description?: SortOrderInput | SortOrder
    roundId?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    _count?: MatchCountOrderByAggregateInput
    _avg?: MatchAvgOrderByAggregateInput
    _max?: MatchMaxOrderByAggregateInput
    _min?: MatchMinOrderByAggregateInput
    _sum?: MatchSumOrderByAggregateInput
  }

  export type MatchScalarWhereWithAggregatesInput = {
    AND?: MatchScalarWhereWithAggregatesInput | MatchScalarWhereWithAggregatesInput[]
    OR?: MatchScalarWhereWithAggregatesInput[]
    NOT?: MatchScalarWhereWithAggregatesInput | MatchScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"Match"> | string
    homeTeamId?: StringWithAggregatesFilter<"Match"> | string
    awayTeamId?: StringWithAggregatesFilter<"Match"> | string
    homeScore?: IntNullableWithAggregatesFilter<"Match"> | number | null
    awayScore?: IntNullableWithAggregatesFilter<"Match"> | number | null
    stage?: EnumMatchStageWithAggregatesFilter<"Match"> | $Enums.MatchStage
    status?: EnumMatchStatusWithAggregatesFilter<"Match"> | $Enums.MatchStatus
    matchDate?: DateTimeWithAggregatesFilter<"Match"> | Date | string
    matchDatePersian?: StringNullableWithAggregatesFilter<"Match"> | string | null
    stadium?: StringNullableWithAggregatesFilter<"Match"> | string | null
    city?: StringNullableWithAggregatesFilter<"Match"> | string | null
    referee?: StringNullableWithAggregatesFilter<"Match"> | string | null
    assistant1?: StringNullableWithAggregatesFilter<"Match"> | string | null
    assistant2?: StringNullableWithAggregatesFilter<"Match"> | string | null
    fourthOfficial?: StringNullableWithAggregatesFilter<"Match"> | string | null
    attendance?: IntNullableWithAggregatesFilter<"Match"> | number | null
    weather?: StringNullableWithAggregatesFilter<"Match"> | string | null
    description?: StringNullableWithAggregatesFilter<"Match"> | string | null
    roundId?: StringNullableWithAggregatesFilter<"Match"> | string | null
    createdAt?: DateTimeWithAggregatesFilter<"Match"> | Date | string
  }

  export type RoundWhereInput = {
    AND?: RoundWhereInput | RoundWhereInput[]
    OR?: RoundWhereInput[]
    NOT?: RoundWhereInput | RoundWhereInput[]
    id?: StringFilter<"Round"> | string
    number?: IntFilter<"Round"> | number
    name?: StringFilter<"Round"> | string
    isActive?: BoolFilter<"Round"> | boolean
    deadline?: DateTimeFilter<"Round"> | Date | string
    createdAt?: DateTimeFilter<"Round"> | Date | string
    matches?: MatchListRelationFilter
  }

  export type RoundOrderByWithRelationInput = {
    id?: SortOrder
    number?: SortOrder
    name?: SortOrder
    isActive?: SortOrder
    deadline?: SortOrder
    createdAt?: SortOrder
    matches?: MatchOrderByRelationAggregateInput
  }

  export type RoundWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    number?: number
    AND?: RoundWhereInput | RoundWhereInput[]
    OR?: RoundWhereInput[]
    NOT?: RoundWhereInput | RoundWhereInput[]
    name?: StringFilter<"Round"> | string
    isActive?: BoolFilter<"Round"> | boolean
    deadline?: DateTimeFilter<"Round"> | Date | string
    createdAt?: DateTimeFilter<"Round"> | Date | string
    matches?: MatchListRelationFilter
  }, "id" | "number">

  export type RoundOrderByWithAggregationInput = {
    id?: SortOrder
    number?: SortOrder
    name?: SortOrder
    isActive?: SortOrder
    deadline?: SortOrder
    createdAt?: SortOrder
    _count?: RoundCountOrderByAggregateInput
    _avg?: RoundAvgOrderByAggregateInput
    _max?: RoundMaxOrderByAggregateInput
    _min?: RoundMinOrderByAggregateInput
    _sum?: RoundSumOrderByAggregateInput
  }

  export type RoundScalarWhereWithAggregatesInput = {
    AND?: RoundScalarWhereWithAggregatesInput | RoundScalarWhereWithAggregatesInput[]
    OR?: RoundScalarWhereWithAggregatesInput[]
    NOT?: RoundScalarWhereWithAggregatesInput | RoundScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"Round"> | string
    number?: IntWithAggregatesFilter<"Round"> | number
    name?: StringWithAggregatesFilter<"Round"> | string
    isActive?: BoolWithAggregatesFilter<"Round"> | boolean
    deadline?: DateTimeWithAggregatesFilter<"Round"> | Date | string
    createdAt?: DateTimeWithAggregatesFilter<"Round"> | Date | string
  }

  export type GameweekWhereInput = {
    AND?: GameweekWhereInput | GameweekWhereInput[]
    OR?: GameweekWhereInput[]
    NOT?: GameweekWhereInput | GameweekWhereInput[]
    id?: StringFilter<"Gameweek"> | string
    number?: IntFilter<"Gameweek"> | number
    name?: StringFilter<"Gameweek"> | string
    isActive?: BoolFilter<"Gameweek"> | boolean
    deadline?: DateTimeFilter<"Gameweek"> | Date | string
    createdAt?: DateTimeFilter<"Gameweek"> | Date | string
  }

  export type GameweekOrderByWithRelationInput = {
    id?: SortOrder
    number?: SortOrder
    name?: SortOrder
    isActive?: SortOrder
    deadline?: SortOrder
    createdAt?: SortOrder
  }

  export type GameweekWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    number?: number
    AND?: GameweekWhereInput | GameweekWhereInput[]
    OR?: GameweekWhereInput[]
    NOT?: GameweekWhereInput | GameweekWhereInput[]
    name?: StringFilter<"Gameweek"> | string
    isActive?: BoolFilter<"Gameweek"> | boolean
    deadline?: DateTimeFilter<"Gameweek"> | Date | string
    createdAt?: DateTimeFilter<"Gameweek"> | Date | string
  }, "id" | "number">

  export type GameweekOrderByWithAggregationInput = {
    id?: SortOrder
    number?: SortOrder
    name?: SortOrder
    isActive?: SortOrder
    deadline?: SortOrder
    createdAt?: SortOrder
    _count?: GameweekCountOrderByAggregateInput
    _avg?: GameweekAvgOrderByAggregateInput
    _max?: GameweekMaxOrderByAggregateInput
    _min?: GameweekMinOrderByAggregateInput
    _sum?: GameweekSumOrderByAggregateInput
  }

  export type GameweekScalarWhereWithAggregatesInput = {
    AND?: GameweekScalarWhereWithAggregatesInput | GameweekScalarWhereWithAggregatesInput[]
    OR?: GameweekScalarWhereWithAggregatesInput[]
    NOT?: GameweekScalarWhereWithAggregatesInput | GameweekScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"Gameweek"> | string
    number?: IntWithAggregatesFilter<"Gameweek"> | number
    name?: StringWithAggregatesFilter<"Gameweek"> | string
    isActive?: BoolWithAggregatesFilter<"Gameweek"> | boolean
    deadline?: DateTimeWithAggregatesFilter<"Gameweek"> | Date | string
    createdAt?: DateTimeWithAggregatesFilter<"Gameweek"> | Date | string
  }

  export type MatchEventWhereInput = {
    AND?: MatchEventWhereInput | MatchEventWhereInput[]
    OR?: MatchEventWhereInput[]
    NOT?: MatchEventWhereInput | MatchEventWhereInput[]
    id?: StringFilter<"MatchEvent"> | string
    matchId?: StringFilter<"MatchEvent"> | string
    playerId?: StringFilter<"MatchEvent"> | string
    type?: EnumEventTypeFilter<"MatchEvent"> | $Enums.EventType
    minute?: IntNullableFilter<"MatchEvent"> | number | null
    extraInfo?: StringNullableFilter<"MatchEvent"> | string | null
    createdAt?: DateTimeFilter<"MatchEvent"> | Date | string
    match?: XOR<MatchScalarRelationFilter, MatchWhereInput>
    player?: XOR<PlayerScalarRelationFilter, PlayerWhereInput>
  }

  export type MatchEventOrderByWithRelationInput = {
    id?: SortOrder
    matchId?: SortOrder
    playerId?: SortOrder
    type?: SortOrder
    minute?: SortOrderInput | SortOrder
    extraInfo?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    match?: MatchOrderByWithRelationInput
    player?: PlayerOrderByWithRelationInput
  }

  export type MatchEventWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: MatchEventWhereInput | MatchEventWhereInput[]
    OR?: MatchEventWhereInput[]
    NOT?: MatchEventWhereInput | MatchEventWhereInput[]
    matchId?: StringFilter<"MatchEvent"> | string
    playerId?: StringFilter<"MatchEvent"> | string
    type?: EnumEventTypeFilter<"MatchEvent"> | $Enums.EventType
    minute?: IntNullableFilter<"MatchEvent"> | number | null
    extraInfo?: StringNullableFilter<"MatchEvent"> | string | null
    createdAt?: DateTimeFilter<"MatchEvent"> | Date | string
    match?: XOR<MatchScalarRelationFilter, MatchWhereInput>
    player?: XOR<PlayerScalarRelationFilter, PlayerWhereInput>
  }, "id">

  export type MatchEventOrderByWithAggregationInput = {
    id?: SortOrder
    matchId?: SortOrder
    playerId?: SortOrder
    type?: SortOrder
    minute?: SortOrderInput | SortOrder
    extraInfo?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    _count?: MatchEventCountOrderByAggregateInput
    _avg?: MatchEventAvgOrderByAggregateInput
    _max?: MatchEventMaxOrderByAggregateInput
    _min?: MatchEventMinOrderByAggregateInput
    _sum?: MatchEventSumOrderByAggregateInput
  }

  export type MatchEventScalarWhereWithAggregatesInput = {
    AND?: MatchEventScalarWhereWithAggregatesInput | MatchEventScalarWhereWithAggregatesInput[]
    OR?: MatchEventScalarWhereWithAggregatesInput[]
    NOT?: MatchEventScalarWhereWithAggregatesInput | MatchEventScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"MatchEvent"> | string
    matchId?: StringWithAggregatesFilter<"MatchEvent"> | string
    playerId?: StringWithAggregatesFilter<"MatchEvent"> | string
    type?: EnumEventTypeWithAggregatesFilter<"MatchEvent"> | $Enums.EventType
    minute?: IntNullableWithAggregatesFilter<"MatchEvent"> | number | null
    extraInfo?: StringNullableWithAggregatesFilter<"MatchEvent"> | string | null
    createdAt?: DateTimeWithAggregatesFilter<"MatchEvent"> | Date | string
  }

  export type MatchLineupWhereInput = {
    AND?: MatchLineupWhereInput | MatchLineupWhereInput[]
    OR?: MatchLineupWhereInput[]
    NOT?: MatchLineupWhereInput | MatchLineupWhereInput[]
    id?: StringFilter<"MatchLineup"> | string
    matchId?: StringFilter<"MatchLineup"> | string
    countryId?: StringFilter<"MatchLineup"> | string
    formation?: StringFilter<"MatchLineup"> | string
    playerIds?: StringNullableListFilter<"MatchLineup">
    match?: XOR<MatchScalarRelationFilter, MatchWhereInput>
  }

  export type MatchLineupOrderByWithRelationInput = {
    id?: SortOrder
    matchId?: SortOrder
    countryId?: SortOrder
    formation?: SortOrder
    playerIds?: SortOrder
    match?: MatchOrderByWithRelationInput
  }

  export type MatchLineupWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: MatchLineupWhereInput | MatchLineupWhereInput[]
    OR?: MatchLineupWhereInput[]
    NOT?: MatchLineupWhereInput | MatchLineupWhereInput[]
    matchId?: StringFilter<"MatchLineup"> | string
    countryId?: StringFilter<"MatchLineup"> | string
    formation?: StringFilter<"MatchLineup"> | string
    playerIds?: StringNullableListFilter<"MatchLineup">
    match?: XOR<MatchScalarRelationFilter, MatchWhereInput>
  }, "id">

  export type MatchLineupOrderByWithAggregationInput = {
    id?: SortOrder
    matchId?: SortOrder
    countryId?: SortOrder
    formation?: SortOrder
    playerIds?: SortOrder
    _count?: MatchLineupCountOrderByAggregateInput
    _max?: MatchLineupMaxOrderByAggregateInput
    _min?: MatchLineupMinOrderByAggregateInput
  }

  export type MatchLineupScalarWhereWithAggregatesInput = {
    AND?: MatchLineupScalarWhereWithAggregatesInput | MatchLineupScalarWhereWithAggregatesInput[]
    OR?: MatchLineupScalarWhereWithAggregatesInput[]
    NOT?: MatchLineupScalarWhereWithAggregatesInput | MatchLineupScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"MatchLineup"> | string
    matchId?: StringWithAggregatesFilter<"MatchLineup"> | string
    countryId?: StringWithAggregatesFilter<"MatchLineup"> | string
    formation?: StringWithAggregatesFilter<"MatchLineup"> | string
    playerIds?: StringNullableListFilter<"MatchLineup">
  }

  export type PlayerMatchStatWhereInput = {
    AND?: PlayerMatchStatWhereInput | PlayerMatchStatWhereInput[]
    OR?: PlayerMatchStatWhereInput[]
    NOT?: PlayerMatchStatWhereInput | PlayerMatchStatWhereInput[]
    id?: StringFilter<"PlayerMatchStat"> | string
    playerId?: StringFilter<"PlayerMatchStat"> | string
    matchId?: StringFilter<"PlayerMatchStat"> | string
    goals?: IntFilter<"PlayerMatchStat"> | number
    assists?: IntFilter<"PlayerMatchStat"> | number
    yellowCards?: IntFilter<"PlayerMatchStat"> | number
    redCards?: IntFilter<"PlayerMatchStat"> | number
    minutesPlayed?: IntFilter<"PlayerMatchStat"> | number
    cleanSheet?: BoolFilter<"PlayerMatchStat"> | boolean
    penaltySaved?: IntFilter<"PlayerMatchStat"> | number
    penaltyMissed?: IntFilter<"PlayerMatchStat"> | number
    ownGoals?: IntFilter<"PlayerMatchStat"> | number
    isMotm?: BoolFilter<"PlayerMatchStat"> | boolean
    extraTimeBonus?: IntFilter<"PlayerMatchStat"> | number
    points?: IntFilter<"PlayerMatchStat"> | number
    player?: XOR<PlayerScalarRelationFilter, PlayerWhereInput>
    match?: XOR<MatchScalarRelationFilter, MatchWhereInput>
  }

  export type PlayerMatchStatOrderByWithRelationInput = {
    id?: SortOrder
    playerId?: SortOrder
    matchId?: SortOrder
    goals?: SortOrder
    assists?: SortOrder
    yellowCards?: SortOrder
    redCards?: SortOrder
    minutesPlayed?: SortOrder
    cleanSheet?: SortOrder
    penaltySaved?: SortOrder
    penaltyMissed?: SortOrder
    ownGoals?: SortOrder
    isMotm?: SortOrder
    extraTimeBonus?: SortOrder
    points?: SortOrder
    player?: PlayerOrderByWithRelationInput
    match?: MatchOrderByWithRelationInput
  }

  export type PlayerMatchStatWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    playerId_matchId?: PlayerMatchStatPlayerIdMatchIdCompoundUniqueInput
    AND?: PlayerMatchStatWhereInput | PlayerMatchStatWhereInput[]
    OR?: PlayerMatchStatWhereInput[]
    NOT?: PlayerMatchStatWhereInput | PlayerMatchStatWhereInput[]
    playerId?: StringFilter<"PlayerMatchStat"> | string
    matchId?: StringFilter<"PlayerMatchStat"> | string
    goals?: IntFilter<"PlayerMatchStat"> | number
    assists?: IntFilter<"PlayerMatchStat"> | number
    yellowCards?: IntFilter<"PlayerMatchStat"> | number
    redCards?: IntFilter<"PlayerMatchStat"> | number
    minutesPlayed?: IntFilter<"PlayerMatchStat"> | number
    cleanSheet?: BoolFilter<"PlayerMatchStat"> | boolean
    penaltySaved?: IntFilter<"PlayerMatchStat"> | number
    penaltyMissed?: IntFilter<"PlayerMatchStat"> | number
    ownGoals?: IntFilter<"PlayerMatchStat"> | number
    isMotm?: BoolFilter<"PlayerMatchStat"> | boolean
    extraTimeBonus?: IntFilter<"PlayerMatchStat"> | number
    points?: IntFilter<"PlayerMatchStat"> | number
    player?: XOR<PlayerScalarRelationFilter, PlayerWhereInput>
    match?: XOR<MatchScalarRelationFilter, MatchWhereInput>
  }, "id" | "playerId_matchId">

  export type PlayerMatchStatOrderByWithAggregationInput = {
    id?: SortOrder
    playerId?: SortOrder
    matchId?: SortOrder
    goals?: SortOrder
    assists?: SortOrder
    yellowCards?: SortOrder
    redCards?: SortOrder
    minutesPlayed?: SortOrder
    cleanSheet?: SortOrder
    penaltySaved?: SortOrder
    penaltyMissed?: SortOrder
    ownGoals?: SortOrder
    isMotm?: SortOrder
    extraTimeBonus?: SortOrder
    points?: SortOrder
    _count?: PlayerMatchStatCountOrderByAggregateInput
    _avg?: PlayerMatchStatAvgOrderByAggregateInput
    _max?: PlayerMatchStatMaxOrderByAggregateInput
    _min?: PlayerMatchStatMinOrderByAggregateInput
    _sum?: PlayerMatchStatSumOrderByAggregateInput
  }

  export type PlayerMatchStatScalarWhereWithAggregatesInput = {
    AND?: PlayerMatchStatScalarWhereWithAggregatesInput | PlayerMatchStatScalarWhereWithAggregatesInput[]
    OR?: PlayerMatchStatScalarWhereWithAggregatesInput[]
    NOT?: PlayerMatchStatScalarWhereWithAggregatesInput | PlayerMatchStatScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"PlayerMatchStat"> | string
    playerId?: StringWithAggregatesFilter<"PlayerMatchStat"> | string
    matchId?: StringWithAggregatesFilter<"PlayerMatchStat"> | string
    goals?: IntWithAggregatesFilter<"PlayerMatchStat"> | number
    assists?: IntWithAggregatesFilter<"PlayerMatchStat"> | number
    yellowCards?: IntWithAggregatesFilter<"PlayerMatchStat"> | number
    redCards?: IntWithAggregatesFilter<"PlayerMatchStat"> | number
    minutesPlayed?: IntWithAggregatesFilter<"PlayerMatchStat"> | number
    cleanSheet?: BoolWithAggregatesFilter<"PlayerMatchStat"> | boolean
    penaltySaved?: IntWithAggregatesFilter<"PlayerMatchStat"> | number
    penaltyMissed?: IntWithAggregatesFilter<"PlayerMatchStat"> | number
    ownGoals?: IntWithAggregatesFilter<"PlayerMatchStat"> | number
    isMotm?: BoolWithAggregatesFilter<"PlayerMatchStat"> | boolean
    extraTimeBonus?: IntWithAggregatesFilter<"PlayerMatchStat"> | number
    points?: IntWithAggregatesFilter<"PlayerMatchStat"> | number
  }

  export type ScoringRuleWhereInput = {
    AND?: ScoringRuleWhereInput | ScoringRuleWhereInput[]
    OR?: ScoringRuleWhereInput[]
    NOT?: ScoringRuleWhereInput | ScoringRuleWhereInput[]
    id?: StringFilter<"ScoringRule"> | string
    position?: EnumPositionFilter<"ScoringRule"> | $Enums.Position
    eventType?: EnumEventTypeFilter<"ScoringRule"> | $Enums.EventType
    points?: IntFilter<"ScoringRule"> | number
    updatedAt?: DateTimeFilter<"ScoringRule"> | Date | string
    updatedBy?: StringNullableFilter<"ScoringRule"> | string | null
  }

  export type ScoringRuleOrderByWithRelationInput = {
    id?: SortOrder
    position?: SortOrder
    eventType?: SortOrder
    points?: SortOrder
    updatedAt?: SortOrder
    updatedBy?: SortOrderInput | SortOrder
  }

  export type ScoringRuleWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    position_eventType?: ScoringRulePositionEventTypeCompoundUniqueInput
    AND?: ScoringRuleWhereInput | ScoringRuleWhereInput[]
    OR?: ScoringRuleWhereInput[]
    NOT?: ScoringRuleWhereInput | ScoringRuleWhereInput[]
    position?: EnumPositionFilter<"ScoringRule"> | $Enums.Position
    eventType?: EnumEventTypeFilter<"ScoringRule"> | $Enums.EventType
    points?: IntFilter<"ScoringRule"> | number
    updatedAt?: DateTimeFilter<"ScoringRule"> | Date | string
    updatedBy?: StringNullableFilter<"ScoringRule"> | string | null
  }, "id" | "position_eventType">

  export type ScoringRuleOrderByWithAggregationInput = {
    id?: SortOrder
    position?: SortOrder
    eventType?: SortOrder
    points?: SortOrder
    updatedAt?: SortOrder
    updatedBy?: SortOrderInput | SortOrder
    _count?: ScoringRuleCountOrderByAggregateInput
    _avg?: ScoringRuleAvgOrderByAggregateInput
    _max?: ScoringRuleMaxOrderByAggregateInput
    _min?: ScoringRuleMinOrderByAggregateInput
    _sum?: ScoringRuleSumOrderByAggregateInput
  }

  export type ScoringRuleScalarWhereWithAggregatesInput = {
    AND?: ScoringRuleScalarWhereWithAggregatesInput | ScoringRuleScalarWhereWithAggregatesInput[]
    OR?: ScoringRuleScalarWhereWithAggregatesInput[]
    NOT?: ScoringRuleScalarWhereWithAggregatesInput | ScoringRuleScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"ScoringRule"> | string
    position?: EnumPositionWithAggregatesFilter<"ScoringRule"> | $Enums.Position
    eventType?: EnumEventTypeWithAggregatesFilter<"ScoringRule"> | $Enums.EventType
    points?: IntWithAggregatesFilter<"ScoringRule"> | number
    updatedAt?: DateTimeWithAggregatesFilter<"ScoringRule"> | Date | string
    updatedBy?: StringNullableWithAggregatesFilter<"ScoringRule"> | string | null
  }

  export type UserWhereInput = {
    AND?: UserWhereInput | UserWhereInput[]
    OR?: UserWhereInput[]
    NOT?: UserWhereInput | UserWhereInput[]
    id?: StringFilter<"User"> | string
    name?: StringNullableFilter<"User"> | string | null
    email?: StringFilter<"User"> | string
    phone?: StringNullableFilter<"User"> | string | null
    password?: StringFilter<"User"> | string
    role?: EnumRoleFilter<"User"> | $Enums.Role
    createdAt?: DateTimeFilter<"User"> | Date | string
    team?: XOR<TeamNullableScalarRelationFilter, TeamWhereInput> | null
    sessions?: SessionListRelationFilter
    payments?: PaymentListRelationFilter
    quizSubmissions?: QuizSubmissionListRelationFilter
    goldenCards?: GoldenCardListRelationFilter
  }

  export type UserOrderByWithRelationInput = {
    id?: SortOrder
    name?: SortOrderInput | SortOrder
    email?: SortOrder
    phone?: SortOrderInput | SortOrder
    password?: SortOrder
    role?: SortOrder
    createdAt?: SortOrder
    team?: TeamOrderByWithRelationInput
    sessions?: SessionOrderByRelationAggregateInput
    payments?: PaymentOrderByRelationAggregateInput
    quizSubmissions?: QuizSubmissionOrderByRelationAggregateInput
    goldenCards?: GoldenCardOrderByRelationAggregateInput
  }

  export type UserWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    email?: string
    phone?: string
    AND?: UserWhereInput | UserWhereInput[]
    OR?: UserWhereInput[]
    NOT?: UserWhereInput | UserWhereInput[]
    name?: StringNullableFilter<"User"> | string | null
    password?: StringFilter<"User"> | string
    role?: EnumRoleFilter<"User"> | $Enums.Role
    createdAt?: DateTimeFilter<"User"> | Date | string
    team?: XOR<TeamNullableScalarRelationFilter, TeamWhereInput> | null
    sessions?: SessionListRelationFilter
    payments?: PaymentListRelationFilter
    quizSubmissions?: QuizSubmissionListRelationFilter
    goldenCards?: GoldenCardListRelationFilter
  }, "id" | "email" | "phone">

  export type UserOrderByWithAggregationInput = {
    id?: SortOrder
    name?: SortOrderInput | SortOrder
    email?: SortOrder
    phone?: SortOrderInput | SortOrder
    password?: SortOrder
    role?: SortOrder
    createdAt?: SortOrder
    _count?: UserCountOrderByAggregateInput
    _max?: UserMaxOrderByAggregateInput
    _min?: UserMinOrderByAggregateInput
  }

  export type UserScalarWhereWithAggregatesInput = {
    AND?: UserScalarWhereWithAggregatesInput | UserScalarWhereWithAggregatesInput[]
    OR?: UserScalarWhereWithAggregatesInput[]
    NOT?: UserScalarWhereWithAggregatesInput | UserScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"User"> | string
    name?: StringNullableWithAggregatesFilter<"User"> | string | null
    email?: StringWithAggregatesFilter<"User"> | string
    phone?: StringNullableWithAggregatesFilter<"User"> | string | null
    password?: StringWithAggregatesFilter<"User"> | string
    role?: EnumRoleWithAggregatesFilter<"User"> | $Enums.Role
    createdAt?: DateTimeWithAggregatesFilter<"User"> | Date | string
  }

  export type LoginOtpWhereInput = {
    AND?: LoginOtpWhereInput | LoginOtpWhereInput[]
    OR?: LoginOtpWhereInput[]
    NOT?: LoginOtpWhereInput | LoginOtpWhereInput[]
    id?: StringFilter<"LoginOtp"> | string
    phone?: StringFilter<"LoginOtp"> | string
    codeHash?: StringFilter<"LoginOtp"> | string
    attempts?: IntFilter<"LoginOtp"> | number
    expiresAt?: DateTimeFilter<"LoginOtp"> | Date | string
    consumedAt?: DateTimeNullableFilter<"LoginOtp"> | Date | string | null
    createdAt?: DateTimeFilter<"LoginOtp"> | Date | string
  }

  export type LoginOtpOrderByWithRelationInput = {
    id?: SortOrder
    phone?: SortOrder
    codeHash?: SortOrder
    attempts?: SortOrder
    expiresAt?: SortOrder
    consumedAt?: SortOrderInput | SortOrder
    createdAt?: SortOrder
  }

  export type LoginOtpWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: LoginOtpWhereInput | LoginOtpWhereInput[]
    OR?: LoginOtpWhereInput[]
    NOT?: LoginOtpWhereInput | LoginOtpWhereInput[]
    phone?: StringFilter<"LoginOtp"> | string
    codeHash?: StringFilter<"LoginOtp"> | string
    attempts?: IntFilter<"LoginOtp"> | number
    expiresAt?: DateTimeFilter<"LoginOtp"> | Date | string
    consumedAt?: DateTimeNullableFilter<"LoginOtp"> | Date | string | null
    createdAt?: DateTimeFilter<"LoginOtp"> | Date | string
  }, "id">

  export type LoginOtpOrderByWithAggregationInput = {
    id?: SortOrder
    phone?: SortOrder
    codeHash?: SortOrder
    attempts?: SortOrder
    expiresAt?: SortOrder
    consumedAt?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    _count?: LoginOtpCountOrderByAggregateInput
    _avg?: LoginOtpAvgOrderByAggregateInput
    _max?: LoginOtpMaxOrderByAggregateInput
    _min?: LoginOtpMinOrderByAggregateInput
    _sum?: LoginOtpSumOrderByAggregateInput
  }

  export type LoginOtpScalarWhereWithAggregatesInput = {
    AND?: LoginOtpScalarWhereWithAggregatesInput | LoginOtpScalarWhereWithAggregatesInput[]
    OR?: LoginOtpScalarWhereWithAggregatesInput[]
    NOT?: LoginOtpScalarWhereWithAggregatesInput | LoginOtpScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"LoginOtp"> | string
    phone?: StringWithAggregatesFilter<"LoginOtp"> | string
    codeHash?: StringWithAggregatesFilter<"LoginOtp"> | string
    attempts?: IntWithAggregatesFilter<"LoginOtp"> | number
    expiresAt?: DateTimeWithAggregatesFilter<"LoginOtp"> | Date | string
    consumedAt?: DateTimeNullableWithAggregatesFilter<"LoginOtp"> | Date | string | null
    createdAt?: DateTimeWithAggregatesFilter<"LoginOtp"> | Date | string
  }

  export type FantasyNewsWhereInput = {
    AND?: FantasyNewsWhereInput | FantasyNewsWhereInput[]
    OR?: FantasyNewsWhereInput[]
    NOT?: FantasyNewsWhereInput | FantasyNewsWhereInput[]
    id?: StringFilter<"FantasyNews"> | string
    icon?: StringFilter<"FantasyNews"> | string
    title?: StringFilter<"FantasyNews"> | string
    description?: StringFilter<"FantasyNews"> | string
    newsTime?: DateTimeFilter<"FantasyNews"> | Date | string
    createdAt?: DateTimeFilter<"FantasyNews"> | Date | string
    updatedAt?: DateTimeFilter<"FantasyNews"> | Date | string
  }

  export type FantasyNewsOrderByWithRelationInput = {
    id?: SortOrder
    icon?: SortOrder
    title?: SortOrder
    description?: SortOrder
    newsTime?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type FantasyNewsWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: FantasyNewsWhereInput | FantasyNewsWhereInput[]
    OR?: FantasyNewsWhereInput[]
    NOT?: FantasyNewsWhereInput | FantasyNewsWhereInput[]
    icon?: StringFilter<"FantasyNews"> | string
    title?: StringFilter<"FantasyNews"> | string
    description?: StringFilter<"FantasyNews"> | string
    newsTime?: DateTimeFilter<"FantasyNews"> | Date | string
    createdAt?: DateTimeFilter<"FantasyNews"> | Date | string
    updatedAt?: DateTimeFilter<"FantasyNews"> | Date | string
  }, "id">

  export type FantasyNewsOrderByWithAggregationInput = {
    id?: SortOrder
    icon?: SortOrder
    title?: SortOrder
    description?: SortOrder
    newsTime?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    _count?: FantasyNewsCountOrderByAggregateInput
    _max?: FantasyNewsMaxOrderByAggregateInput
    _min?: FantasyNewsMinOrderByAggregateInput
  }

  export type FantasyNewsScalarWhereWithAggregatesInput = {
    AND?: FantasyNewsScalarWhereWithAggregatesInput | FantasyNewsScalarWhereWithAggregatesInput[]
    OR?: FantasyNewsScalarWhereWithAggregatesInput[]
    NOT?: FantasyNewsScalarWhereWithAggregatesInput | FantasyNewsScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"FantasyNews"> | string
    icon?: StringWithAggregatesFilter<"FantasyNews"> | string
    title?: StringWithAggregatesFilter<"FantasyNews"> | string
    description?: StringWithAggregatesFilter<"FantasyNews"> | string
    newsTime?: DateTimeWithAggregatesFilter<"FantasyNews"> | Date | string
    createdAt?: DateTimeWithAggregatesFilter<"FantasyNews"> | Date | string
    updatedAt?: DateTimeWithAggregatesFilter<"FantasyNews"> | Date | string
  }

  export type DailyQuizWhereInput = {
    AND?: DailyQuizWhereInput | DailyQuizWhereInput[]
    OR?: DailyQuizWhereInput[]
    NOT?: DailyQuizWhereInput | DailyQuizWhereInput[]
    id?: StringFilter<"DailyQuiz"> | string
    date?: DateTimeFilter<"DailyQuiz"> | Date | string
    windowStart?: DateTimeFilter<"DailyQuiz"> | Date | string
    windowEnd?: DateTimeFilter<"DailyQuiz"> | Date | string
    goldWinnersCount?: IntFilter<"DailyQuiz"> | number
    silverWinnersCount?: IntFilter<"DailyQuiz"> | number
    bronzeWinnersCount?: IntFilter<"DailyQuiz"> | number
    goldMinCorrect?: IntNullableFilter<"DailyQuiz"> | number | null
    silverMinCorrect?: IntNullableFilter<"DailyQuiz"> | number | null
    bronzeMinCorrect?: IntNullableFilter<"DailyQuiz"> | number | null
    isProcessed?: BoolFilter<"DailyQuiz"> | boolean
    createdAt?: DateTimeFilter<"DailyQuiz"> | Date | string
    questions?: QuizQuestionListRelationFilter
    submissions?: QuizSubmissionListRelationFilter
    awardedCards?: GoldenCardListRelationFilter
  }

  export type DailyQuizOrderByWithRelationInput = {
    id?: SortOrder
    date?: SortOrder
    windowStart?: SortOrder
    windowEnd?: SortOrder
    goldWinnersCount?: SortOrder
    silverWinnersCount?: SortOrder
    bronzeWinnersCount?: SortOrder
    goldMinCorrect?: SortOrderInput | SortOrder
    silverMinCorrect?: SortOrderInput | SortOrder
    bronzeMinCorrect?: SortOrderInput | SortOrder
    isProcessed?: SortOrder
    createdAt?: SortOrder
    questions?: QuizQuestionOrderByRelationAggregateInput
    submissions?: QuizSubmissionOrderByRelationAggregateInput
    awardedCards?: GoldenCardOrderByRelationAggregateInput
  }

  export type DailyQuizWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    date?: Date | string
    AND?: DailyQuizWhereInput | DailyQuizWhereInput[]
    OR?: DailyQuizWhereInput[]
    NOT?: DailyQuizWhereInput | DailyQuizWhereInput[]
    windowStart?: DateTimeFilter<"DailyQuiz"> | Date | string
    windowEnd?: DateTimeFilter<"DailyQuiz"> | Date | string
    goldWinnersCount?: IntFilter<"DailyQuiz"> | number
    silverWinnersCount?: IntFilter<"DailyQuiz"> | number
    bronzeWinnersCount?: IntFilter<"DailyQuiz"> | number
    goldMinCorrect?: IntNullableFilter<"DailyQuiz"> | number | null
    silverMinCorrect?: IntNullableFilter<"DailyQuiz"> | number | null
    bronzeMinCorrect?: IntNullableFilter<"DailyQuiz"> | number | null
    isProcessed?: BoolFilter<"DailyQuiz"> | boolean
    createdAt?: DateTimeFilter<"DailyQuiz"> | Date | string
    questions?: QuizQuestionListRelationFilter
    submissions?: QuizSubmissionListRelationFilter
    awardedCards?: GoldenCardListRelationFilter
  }, "id" | "date">

  export type DailyQuizOrderByWithAggregationInput = {
    id?: SortOrder
    date?: SortOrder
    windowStart?: SortOrder
    windowEnd?: SortOrder
    goldWinnersCount?: SortOrder
    silverWinnersCount?: SortOrder
    bronzeWinnersCount?: SortOrder
    goldMinCorrect?: SortOrderInput | SortOrder
    silverMinCorrect?: SortOrderInput | SortOrder
    bronzeMinCorrect?: SortOrderInput | SortOrder
    isProcessed?: SortOrder
    createdAt?: SortOrder
    _count?: DailyQuizCountOrderByAggregateInput
    _avg?: DailyQuizAvgOrderByAggregateInput
    _max?: DailyQuizMaxOrderByAggregateInput
    _min?: DailyQuizMinOrderByAggregateInput
    _sum?: DailyQuizSumOrderByAggregateInput
  }

  export type DailyQuizScalarWhereWithAggregatesInput = {
    AND?: DailyQuizScalarWhereWithAggregatesInput | DailyQuizScalarWhereWithAggregatesInput[]
    OR?: DailyQuizScalarWhereWithAggregatesInput[]
    NOT?: DailyQuizScalarWhereWithAggregatesInput | DailyQuizScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"DailyQuiz"> | string
    date?: DateTimeWithAggregatesFilter<"DailyQuiz"> | Date | string
    windowStart?: DateTimeWithAggregatesFilter<"DailyQuiz"> | Date | string
    windowEnd?: DateTimeWithAggregatesFilter<"DailyQuiz"> | Date | string
    goldWinnersCount?: IntWithAggregatesFilter<"DailyQuiz"> | number
    silverWinnersCount?: IntWithAggregatesFilter<"DailyQuiz"> | number
    bronzeWinnersCount?: IntWithAggregatesFilter<"DailyQuiz"> | number
    goldMinCorrect?: IntNullableWithAggregatesFilter<"DailyQuiz"> | number | null
    silverMinCorrect?: IntNullableWithAggregatesFilter<"DailyQuiz"> | number | null
    bronzeMinCorrect?: IntNullableWithAggregatesFilter<"DailyQuiz"> | number | null
    isProcessed?: BoolWithAggregatesFilter<"DailyQuiz"> | boolean
    createdAt?: DateTimeWithAggregatesFilter<"DailyQuiz"> | Date | string
  }

  export type QuizQuestionWhereInput = {
    AND?: QuizQuestionWhereInput | QuizQuestionWhereInput[]
    OR?: QuizQuestionWhereInput[]
    NOT?: QuizQuestionWhereInput | QuizQuestionWhereInput[]
    id?: StringFilter<"QuizQuestion"> | string
    quizId?: StringFilter<"QuizQuestion"> | string
    questionText?: StringFilter<"QuizQuestion"> | string
    options?: StringNullableListFilter<"QuizQuestion">
    correctAnswer?: IntFilter<"QuizQuestion"> | number
    order?: IntFilter<"QuizQuestion"> | number
    quiz?: XOR<DailyQuizScalarRelationFilter, DailyQuizWhereInput>
  }

  export type QuizQuestionOrderByWithRelationInput = {
    id?: SortOrder
    quizId?: SortOrder
    questionText?: SortOrder
    options?: SortOrder
    correctAnswer?: SortOrder
    order?: SortOrder
    quiz?: DailyQuizOrderByWithRelationInput
  }

  export type QuizQuestionWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: QuizQuestionWhereInput | QuizQuestionWhereInput[]
    OR?: QuizQuestionWhereInput[]
    NOT?: QuizQuestionWhereInput | QuizQuestionWhereInput[]
    quizId?: StringFilter<"QuizQuestion"> | string
    questionText?: StringFilter<"QuizQuestion"> | string
    options?: StringNullableListFilter<"QuizQuestion">
    correctAnswer?: IntFilter<"QuizQuestion"> | number
    order?: IntFilter<"QuizQuestion"> | number
    quiz?: XOR<DailyQuizScalarRelationFilter, DailyQuizWhereInput>
  }, "id">

  export type QuizQuestionOrderByWithAggregationInput = {
    id?: SortOrder
    quizId?: SortOrder
    questionText?: SortOrder
    options?: SortOrder
    correctAnswer?: SortOrder
    order?: SortOrder
    _count?: QuizQuestionCountOrderByAggregateInput
    _avg?: QuizQuestionAvgOrderByAggregateInput
    _max?: QuizQuestionMaxOrderByAggregateInput
    _min?: QuizQuestionMinOrderByAggregateInput
    _sum?: QuizQuestionSumOrderByAggregateInput
  }

  export type QuizQuestionScalarWhereWithAggregatesInput = {
    AND?: QuizQuestionScalarWhereWithAggregatesInput | QuizQuestionScalarWhereWithAggregatesInput[]
    OR?: QuizQuestionScalarWhereWithAggregatesInput[]
    NOT?: QuizQuestionScalarWhereWithAggregatesInput | QuizQuestionScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"QuizQuestion"> | string
    quizId?: StringWithAggregatesFilter<"QuizQuestion"> | string
    questionText?: StringWithAggregatesFilter<"QuizQuestion"> | string
    options?: StringNullableListFilter<"QuizQuestion">
    correctAnswer?: IntWithAggregatesFilter<"QuizQuestion"> | number
    order?: IntWithAggregatesFilter<"QuizQuestion"> | number
  }

  export type QuizSubmissionWhereInput = {
    AND?: QuizSubmissionWhereInput | QuizSubmissionWhereInput[]
    OR?: QuizSubmissionWhereInput[]
    NOT?: QuizSubmissionWhereInput | QuizSubmissionWhereInput[]
    id?: StringFilter<"QuizSubmission"> | string
    userId?: StringFilter<"QuizSubmission"> | string
    quizId?: StringFilter<"QuizSubmission"> | string
    answers?: IntNullableListFilter<"QuizSubmission">
    correctAnswers?: IntFilter<"QuizSubmission"> | number
    score?: IntFilter<"QuizSubmission"> | number
    submittedAt?: DateTimeFilter<"QuizSubmission"> | Date | string
    user?: XOR<UserScalarRelationFilter, UserWhereInput>
    quiz?: XOR<DailyQuizScalarRelationFilter, DailyQuizWhereInput>
  }

  export type QuizSubmissionOrderByWithRelationInput = {
    id?: SortOrder
    userId?: SortOrder
    quizId?: SortOrder
    answers?: SortOrder
    correctAnswers?: SortOrder
    score?: SortOrder
    submittedAt?: SortOrder
    user?: UserOrderByWithRelationInput
    quiz?: DailyQuizOrderByWithRelationInput
  }

  export type QuizSubmissionWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    userId_quizId?: QuizSubmissionUserIdQuizIdCompoundUniqueInput
    AND?: QuizSubmissionWhereInput | QuizSubmissionWhereInput[]
    OR?: QuizSubmissionWhereInput[]
    NOT?: QuizSubmissionWhereInput | QuizSubmissionWhereInput[]
    userId?: StringFilter<"QuizSubmission"> | string
    quizId?: StringFilter<"QuizSubmission"> | string
    answers?: IntNullableListFilter<"QuizSubmission">
    correctAnswers?: IntFilter<"QuizSubmission"> | number
    score?: IntFilter<"QuizSubmission"> | number
    submittedAt?: DateTimeFilter<"QuizSubmission"> | Date | string
    user?: XOR<UserScalarRelationFilter, UserWhereInput>
    quiz?: XOR<DailyQuizScalarRelationFilter, DailyQuizWhereInput>
  }, "id" | "userId_quizId">

  export type QuizSubmissionOrderByWithAggregationInput = {
    id?: SortOrder
    userId?: SortOrder
    quizId?: SortOrder
    answers?: SortOrder
    correctAnswers?: SortOrder
    score?: SortOrder
    submittedAt?: SortOrder
    _count?: QuizSubmissionCountOrderByAggregateInput
    _avg?: QuizSubmissionAvgOrderByAggregateInput
    _max?: QuizSubmissionMaxOrderByAggregateInput
    _min?: QuizSubmissionMinOrderByAggregateInput
    _sum?: QuizSubmissionSumOrderByAggregateInput
  }

  export type QuizSubmissionScalarWhereWithAggregatesInput = {
    AND?: QuizSubmissionScalarWhereWithAggregatesInput | QuizSubmissionScalarWhereWithAggregatesInput[]
    OR?: QuizSubmissionScalarWhereWithAggregatesInput[]
    NOT?: QuizSubmissionScalarWhereWithAggregatesInput | QuizSubmissionScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"QuizSubmission"> | string
    userId?: StringWithAggregatesFilter<"QuizSubmission"> | string
    quizId?: StringWithAggregatesFilter<"QuizSubmission"> | string
    answers?: IntNullableListFilter<"QuizSubmission">
    correctAnswers?: IntWithAggregatesFilter<"QuizSubmission"> | number
    score?: IntWithAggregatesFilter<"QuizSubmission"> | number
    submittedAt?: DateTimeWithAggregatesFilter<"QuizSubmission"> | Date | string
  }

  export type GoldenCardWhereInput = {
    AND?: GoldenCardWhereInput | GoldenCardWhereInput[]
    OR?: GoldenCardWhereInput[]
    NOT?: GoldenCardWhereInput | GoldenCardWhereInput[]
    id?: StringFilter<"GoldenCard"> | string
    userId?: StringFilter<"GoldenCard"> | string
    quizId?: StringNullableFilter<"GoldenCard"> | string | null
    playerId?: StringFilter<"GoldenCard"> | string
    cardTier?: EnumCardTierFilter<"GoldenCard"> | $Enums.CardTier
    status?: EnumGoldenCardStatusFilter<"GoldenCard"> | $Enums.GoldenCardStatus
    state?: EnumSpecialCardStateFilter<"GoldenCard"> | $Enums.SpecialCardState
    acquiredDate?: DateTimeFilter<"GoldenCard"> | Date | string
    openedAt?: DateTimeNullableFilter<"GoldenCard"> | Date | string | null
    user?: XOR<UserScalarRelationFilter, UserWhereInput>
    quiz?: XOR<DailyQuizNullableScalarRelationFilter, DailyQuizWhereInput> | null
    player?: XOR<PlayerScalarRelationFilter, PlayerWhereInput>
    teamPlayer?: XOR<TeamPlayerNullableScalarRelationFilter, TeamPlayerWhereInput> | null
  }

  export type GoldenCardOrderByWithRelationInput = {
    id?: SortOrder
    userId?: SortOrder
    quizId?: SortOrderInput | SortOrder
    playerId?: SortOrder
    cardTier?: SortOrder
    status?: SortOrder
    state?: SortOrder
    acquiredDate?: SortOrder
    openedAt?: SortOrderInput | SortOrder
    user?: UserOrderByWithRelationInput
    quiz?: DailyQuizOrderByWithRelationInput
    player?: PlayerOrderByWithRelationInput
    teamPlayer?: TeamPlayerOrderByWithRelationInput
  }

  export type GoldenCardWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: GoldenCardWhereInput | GoldenCardWhereInput[]
    OR?: GoldenCardWhereInput[]
    NOT?: GoldenCardWhereInput | GoldenCardWhereInput[]
    userId?: StringFilter<"GoldenCard"> | string
    quizId?: StringNullableFilter<"GoldenCard"> | string | null
    playerId?: StringFilter<"GoldenCard"> | string
    cardTier?: EnumCardTierFilter<"GoldenCard"> | $Enums.CardTier
    status?: EnumGoldenCardStatusFilter<"GoldenCard"> | $Enums.GoldenCardStatus
    state?: EnumSpecialCardStateFilter<"GoldenCard"> | $Enums.SpecialCardState
    acquiredDate?: DateTimeFilter<"GoldenCard"> | Date | string
    openedAt?: DateTimeNullableFilter<"GoldenCard"> | Date | string | null
    user?: XOR<UserScalarRelationFilter, UserWhereInput>
    quiz?: XOR<DailyQuizNullableScalarRelationFilter, DailyQuizWhereInput> | null
    player?: XOR<PlayerScalarRelationFilter, PlayerWhereInput>
    teamPlayer?: XOR<TeamPlayerNullableScalarRelationFilter, TeamPlayerWhereInput> | null
  }, "id">

  export type GoldenCardOrderByWithAggregationInput = {
    id?: SortOrder
    userId?: SortOrder
    quizId?: SortOrderInput | SortOrder
    playerId?: SortOrder
    cardTier?: SortOrder
    status?: SortOrder
    state?: SortOrder
    acquiredDate?: SortOrder
    openedAt?: SortOrderInput | SortOrder
    _count?: GoldenCardCountOrderByAggregateInput
    _max?: GoldenCardMaxOrderByAggregateInput
    _min?: GoldenCardMinOrderByAggregateInput
  }

  export type GoldenCardScalarWhereWithAggregatesInput = {
    AND?: GoldenCardScalarWhereWithAggregatesInput | GoldenCardScalarWhereWithAggregatesInput[]
    OR?: GoldenCardScalarWhereWithAggregatesInput[]
    NOT?: GoldenCardScalarWhereWithAggregatesInput | GoldenCardScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"GoldenCard"> | string
    userId?: StringWithAggregatesFilter<"GoldenCard"> | string
    quizId?: StringNullableWithAggregatesFilter<"GoldenCard"> | string | null
    playerId?: StringWithAggregatesFilter<"GoldenCard"> | string
    cardTier?: EnumCardTierWithAggregatesFilter<"GoldenCard"> | $Enums.CardTier
    status?: EnumGoldenCardStatusWithAggregatesFilter<"GoldenCard"> | $Enums.GoldenCardStatus
    state?: EnumSpecialCardStateWithAggregatesFilter<"GoldenCard"> | $Enums.SpecialCardState
    acquiredDate?: DateTimeWithAggregatesFilter<"GoldenCard"> | Date | string
    openedAt?: DateTimeNullableWithAggregatesFilter<"GoldenCard"> | Date | string | null
  }

  export type SessionWhereInput = {
    AND?: SessionWhereInput | SessionWhereInput[]
    OR?: SessionWhereInput[]
    NOT?: SessionWhereInput | SessionWhereInput[]
    id?: StringFilter<"Session"> | string
    sessionToken?: StringFilter<"Session"> | string
    userId?: StringFilter<"Session"> | string
    expires?: DateTimeFilter<"Session"> | Date | string
    user?: XOR<UserScalarRelationFilter, UserWhereInput>
  }

  export type SessionOrderByWithRelationInput = {
    id?: SortOrder
    sessionToken?: SortOrder
    userId?: SortOrder
    expires?: SortOrder
    user?: UserOrderByWithRelationInput
  }

  export type SessionWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    sessionToken?: string
    AND?: SessionWhereInput | SessionWhereInput[]
    OR?: SessionWhereInput[]
    NOT?: SessionWhereInput | SessionWhereInput[]
    userId?: StringFilter<"Session"> | string
    expires?: DateTimeFilter<"Session"> | Date | string
    user?: XOR<UserScalarRelationFilter, UserWhereInput>
  }, "id" | "sessionToken">

  export type SessionOrderByWithAggregationInput = {
    id?: SortOrder
    sessionToken?: SortOrder
    userId?: SortOrder
    expires?: SortOrder
    _count?: SessionCountOrderByAggregateInput
    _max?: SessionMaxOrderByAggregateInput
    _min?: SessionMinOrderByAggregateInput
  }

  export type SessionScalarWhereWithAggregatesInput = {
    AND?: SessionScalarWhereWithAggregatesInput | SessionScalarWhereWithAggregatesInput[]
    OR?: SessionScalarWhereWithAggregatesInput[]
    NOT?: SessionScalarWhereWithAggregatesInput | SessionScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"Session"> | string
    sessionToken?: StringWithAggregatesFilter<"Session"> | string
    userId?: StringWithAggregatesFilter<"Session"> | string
    expires?: DateTimeWithAggregatesFilter<"Session"> | Date | string
  }

  export type TeamWhereInput = {
    AND?: TeamWhereInput | TeamWhereInput[]
    OR?: TeamWhereInput[]
    NOT?: TeamWhereInput | TeamWhereInput[]
    id?: StringFilter<"Team"> | string
    name?: StringFilter<"Team"> | string
    userId?: StringFilter<"Team"> | string
    budget?: FloatFilter<"Team"> | number
    totalPoints?: IntFilter<"Team"> | number
    formation?: StringFilter<"Team"> | string
    status?: EnumTeamStatusFilter<"Team"> | $Enums.TeamStatus
    createdAt?: DateTimeFilter<"Team"> | Date | string
    user?: XOR<UserScalarRelationFilter, UserWhereInput>
    players?: TeamPlayerListRelationFilter
  }

  export type TeamOrderByWithRelationInput = {
    id?: SortOrder
    name?: SortOrder
    userId?: SortOrder
    budget?: SortOrder
    totalPoints?: SortOrder
    formation?: SortOrder
    status?: SortOrder
    createdAt?: SortOrder
    user?: UserOrderByWithRelationInput
    players?: TeamPlayerOrderByRelationAggregateInput
  }

  export type TeamWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    userId?: string
    AND?: TeamWhereInput | TeamWhereInput[]
    OR?: TeamWhereInput[]
    NOT?: TeamWhereInput | TeamWhereInput[]
    name?: StringFilter<"Team"> | string
    budget?: FloatFilter<"Team"> | number
    totalPoints?: IntFilter<"Team"> | number
    formation?: StringFilter<"Team"> | string
    status?: EnumTeamStatusFilter<"Team"> | $Enums.TeamStatus
    createdAt?: DateTimeFilter<"Team"> | Date | string
    user?: XOR<UserScalarRelationFilter, UserWhereInput>
    players?: TeamPlayerListRelationFilter
  }, "id" | "userId">

  export type TeamOrderByWithAggregationInput = {
    id?: SortOrder
    name?: SortOrder
    userId?: SortOrder
    budget?: SortOrder
    totalPoints?: SortOrder
    formation?: SortOrder
    status?: SortOrder
    createdAt?: SortOrder
    _count?: TeamCountOrderByAggregateInput
    _avg?: TeamAvgOrderByAggregateInput
    _max?: TeamMaxOrderByAggregateInput
    _min?: TeamMinOrderByAggregateInput
    _sum?: TeamSumOrderByAggregateInput
  }

  export type TeamScalarWhereWithAggregatesInput = {
    AND?: TeamScalarWhereWithAggregatesInput | TeamScalarWhereWithAggregatesInput[]
    OR?: TeamScalarWhereWithAggregatesInput[]
    NOT?: TeamScalarWhereWithAggregatesInput | TeamScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"Team"> | string
    name?: StringWithAggregatesFilter<"Team"> | string
    userId?: StringWithAggregatesFilter<"Team"> | string
    budget?: FloatWithAggregatesFilter<"Team"> | number
    totalPoints?: IntWithAggregatesFilter<"Team"> | number
    formation?: StringWithAggregatesFilter<"Team"> | string
    status?: EnumTeamStatusWithAggregatesFilter<"Team"> | $Enums.TeamStatus
    createdAt?: DateTimeWithAggregatesFilter<"Team"> | Date | string
  }

  export type TeamPlayerWhereInput = {
    AND?: TeamPlayerWhereInput | TeamPlayerWhereInput[]
    OR?: TeamPlayerWhereInput[]
    NOT?: TeamPlayerWhereInput | TeamPlayerWhereInput[]
    teamId?: StringFilter<"TeamPlayer"> | string
    playerId?: StringFilter<"TeamPlayer"> | string
    goldenCardId?: StringNullableFilter<"TeamPlayer"> | string | null
    isCaptain?: BoolFilter<"TeamPlayer"> | boolean
    isViceCaptain?: BoolFilter<"TeamPlayer"> | boolean
    isBench?: BoolFilter<"TeamPlayer"> | boolean
    positionIndex?: IntFilter<"TeamPlayer"> | number
    team?: XOR<TeamScalarRelationFilter, TeamWhereInput>
    player?: XOR<PlayerScalarRelationFilter, PlayerWhereInput>
    goldenCard?: XOR<GoldenCardNullableScalarRelationFilter, GoldenCardWhereInput> | null
  }

  export type TeamPlayerOrderByWithRelationInput = {
    teamId?: SortOrder
    playerId?: SortOrder
    goldenCardId?: SortOrderInput | SortOrder
    isCaptain?: SortOrder
    isViceCaptain?: SortOrder
    isBench?: SortOrder
    positionIndex?: SortOrder
    team?: TeamOrderByWithRelationInput
    player?: PlayerOrderByWithRelationInput
    goldenCard?: GoldenCardOrderByWithRelationInput
  }

  export type TeamPlayerWhereUniqueInput = Prisma.AtLeast<{
    goldenCardId?: string
    teamId_playerId?: TeamPlayerTeamIdPlayerIdCompoundUniqueInput
    AND?: TeamPlayerWhereInput | TeamPlayerWhereInput[]
    OR?: TeamPlayerWhereInput[]
    NOT?: TeamPlayerWhereInput | TeamPlayerWhereInput[]
    teamId?: StringFilter<"TeamPlayer"> | string
    playerId?: StringFilter<"TeamPlayer"> | string
    isCaptain?: BoolFilter<"TeamPlayer"> | boolean
    isViceCaptain?: BoolFilter<"TeamPlayer"> | boolean
    isBench?: BoolFilter<"TeamPlayer"> | boolean
    positionIndex?: IntFilter<"TeamPlayer"> | number
    team?: XOR<TeamScalarRelationFilter, TeamWhereInput>
    player?: XOR<PlayerScalarRelationFilter, PlayerWhereInput>
    goldenCard?: XOR<GoldenCardNullableScalarRelationFilter, GoldenCardWhereInput> | null
  }, "teamId_playerId" | "goldenCardId">

  export type TeamPlayerOrderByWithAggregationInput = {
    teamId?: SortOrder
    playerId?: SortOrder
    goldenCardId?: SortOrderInput | SortOrder
    isCaptain?: SortOrder
    isViceCaptain?: SortOrder
    isBench?: SortOrder
    positionIndex?: SortOrder
    _count?: TeamPlayerCountOrderByAggregateInput
    _avg?: TeamPlayerAvgOrderByAggregateInput
    _max?: TeamPlayerMaxOrderByAggregateInput
    _min?: TeamPlayerMinOrderByAggregateInput
    _sum?: TeamPlayerSumOrderByAggregateInput
  }

  export type TeamPlayerScalarWhereWithAggregatesInput = {
    AND?: TeamPlayerScalarWhereWithAggregatesInput | TeamPlayerScalarWhereWithAggregatesInput[]
    OR?: TeamPlayerScalarWhereWithAggregatesInput[]
    NOT?: TeamPlayerScalarWhereWithAggregatesInput | TeamPlayerScalarWhereWithAggregatesInput[]
    teamId?: StringWithAggregatesFilter<"TeamPlayer"> | string
    playerId?: StringWithAggregatesFilter<"TeamPlayer"> | string
    goldenCardId?: StringNullableWithAggregatesFilter<"TeamPlayer"> | string | null
    isCaptain?: BoolWithAggregatesFilter<"TeamPlayer"> | boolean
    isViceCaptain?: BoolWithAggregatesFilter<"TeamPlayer"> | boolean
    isBench?: BoolWithAggregatesFilter<"TeamPlayer"> | boolean
    positionIndex?: IntWithAggregatesFilter<"TeamPlayer"> | number
  }

  export type PackageWhereInput = {
    AND?: PackageWhereInput | PackageWhereInput[]
    OR?: PackageWhereInput[]
    NOT?: PackageWhereInput | PackageWhereInput[]
    id?: StringFilter<"Package"> | string
    name?: StringFilter<"Package"> | string
    budgetBonus?: FloatFilter<"Package"> | number
    price?: IntFilter<"Package"> | number
    description?: StringNullableFilter<"Package"> | string | null
    isActive?: BoolFilter<"Package"> | boolean
    payments?: PaymentListRelationFilter
  }

  export type PackageOrderByWithRelationInput = {
    id?: SortOrder
    name?: SortOrder
    budgetBonus?: SortOrder
    price?: SortOrder
    description?: SortOrderInput | SortOrder
    isActive?: SortOrder
    payments?: PaymentOrderByRelationAggregateInput
  }

  export type PackageWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: PackageWhereInput | PackageWhereInput[]
    OR?: PackageWhereInput[]
    NOT?: PackageWhereInput | PackageWhereInput[]
    name?: StringFilter<"Package"> | string
    budgetBonus?: FloatFilter<"Package"> | number
    price?: IntFilter<"Package"> | number
    description?: StringNullableFilter<"Package"> | string | null
    isActive?: BoolFilter<"Package"> | boolean
    payments?: PaymentListRelationFilter
  }, "id">

  export type PackageOrderByWithAggregationInput = {
    id?: SortOrder
    name?: SortOrder
    budgetBonus?: SortOrder
    price?: SortOrder
    description?: SortOrderInput | SortOrder
    isActive?: SortOrder
    _count?: PackageCountOrderByAggregateInput
    _avg?: PackageAvgOrderByAggregateInput
    _max?: PackageMaxOrderByAggregateInput
    _min?: PackageMinOrderByAggregateInput
    _sum?: PackageSumOrderByAggregateInput
  }

  export type PackageScalarWhereWithAggregatesInput = {
    AND?: PackageScalarWhereWithAggregatesInput | PackageScalarWhereWithAggregatesInput[]
    OR?: PackageScalarWhereWithAggregatesInput[]
    NOT?: PackageScalarWhereWithAggregatesInput | PackageScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"Package"> | string
    name?: StringWithAggregatesFilter<"Package"> | string
    budgetBonus?: FloatWithAggregatesFilter<"Package"> | number
    price?: IntWithAggregatesFilter<"Package"> | number
    description?: StringNullableWithAggregatesFilter<"Package"> | string | null
    isActive?: BoolWithAggregatesFilter<"Package"> | boolean
  }

  export type PaymentWhereInput = {
    AND?: PaymentWhereInput | PaymentWhereInput[]
    OR?: PaymentWhereInput[]
    NOT?: PaymentWhereInput | PaymentWhereInput[]
    id?: StringFilter<"Payment"> | string
    userId?: StringFilter<"Payment"> | string
    packageId?: StringFilter<"Payment"> | string
    amount?: IntFilter<"Payment"> | number
    authority?: StringNullableFilter<"Payment"> | string | null
    refId?: StringNullableFilter<"Payment"> | string | null
    status?: EnumPaymentStatusFilter<"Payment"> | $Enums.PaymentStatus
    createdAt?: DateTimeFilter<"Payment"> | Date | string
    updatedAt?: DateTimeFilter<"Payment"> | Date | string
    user?: XOR<UserScalarRelationFilter, UserWhereInput>
    package?: XOR<PackageScalarRelationFilter, PackageWhereInput>
  }

  export type PaymentOrderByWithRelationInput = {
    id?: SortOrder
    userId?: SortOrder
    packageId?: SortOrder
    amount?: SortOrder
    authority?: SortOrderInput | SortOrder
    refId?: SortOrderInput | SortOrder
    status?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    user?: UserOrderByWithRelationInput
    package?: PackageOrderByWithRelationInput
  }

  export type PaymentWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    authority?: string
    AND?: PaymentWhereInput | PaymentWhereInput[]
    OR?: PaymentWhereInput[]
    NOT?: PaymentWhereInput | PaymentWhereInput[]
    userId?: StringFilter<"Payment"> | string
    packageId?: StringFilter<"Payment"> | string
    amount?: IntFilter<"Payment"> | number
    refId?: StringNullableFilter<"Payment"> | string | null
    status?: EnumPaymentStatusFilter<"Payment"> | $Enums.PaymentStatus
    createdAt?: DateTimeFilter<"Payment"> | Date | string
    updatedAt?: DateTimeFilter<"Payment"> | Date | string
    user?: XOR<UserScalarRelationFilter, UserWhereInput>
    package?: XOR<PackageScalarRelationFilter, PackageWhereInput>
  }, "id" | "authority">

  export type PaymentOrderByWithAggregationInput = {
    id?: SortOrder
    userId?: SortOrder
    packageId?: SortOrder
    amount?: SortOrder
    authority?: SortOrderInput | SortOrder
    refId?: SortOrderInput | SortOrder
    status?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    _count?: PaymentCountOrderByAggregateInput
    _avg?: PaymentAvgOrderByAggregateInput
    _max?: PaymentMaxOrderByAggregateInput
    _min?: PaymentMinOrderByAggregateInput
    _sum?: PaymentSumOrderByAggregateInput
  }

  export type PaymentScalarWhereWithAggregatesInput = {
    AND?: PaymentScalarWhereWithAggregatesInput | PaymentScalarWhereWithAggregatesInput[]
    OR?: PaymentScalarWhereWithAggregatesInput[]
    NOT?: PaymentScalarWhereWithAggregatesInput | PaymentScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"Payment"> | string
    userId?: StringWithAggregatesFilter<"Payment"> | string
    packageId?: StringWithAggregatesFilter<"Payment"> | string
    amount?: IntWithAggregatesFilter<"Payment"> | number
    authority?: StringNullableWithAggregatesFilter<"Payment"> | string | null
    refId?: StringNullableWithAggregatesFilter<"Payment"> | string | null
    status?: EnumPaymentStatusWithAggregatesFilter<"Payment"> | $Enums.PaymentStatus
    createdAt?: DateTimeWithAggregatesFilter<"Payment"> | Date | string
    updatedAt?: DateTimeWithAggregatesFilter<"Payment"> | Date | string
  }

  export type CountryCreateInput = {
    id?: string
    name: string
    code: string
    flagUrl?: string | null
    flagImage?: string | null
    confederation?: string | null
    qualificationMethod?: string | null
    qualificationDate?: string | null
    participationHistory?: string | null
    bestResult?: string | null
    description?: string | null
    defaultFormation?: string
    defaultLineupPlayerIds?: CountryCreatedefaultLineupPlayerIdsInput | string[]
    defaultCaptainId?: string | null
    isEliminated?: boolean
    group?: GroupCreateNestedOneWithoutCountriesInput
    players?: PlayerCreateNestedManyWithoutCountryInput
    homeMatches?: MatchCreateNestedManyWithoutHomeTeamInput
    awayMatches?: MatchCreateNestedManyWithoutAwayTeamInput
  }

  export type CountryUncheckedCreateInput = {
    id?: string
    name: string
    code: string
    flagUrl?: string | null
    flagImage?: string | null
    confederation?: string | null
    qualificationMethod?: string | null
    qualificationDate?: string | null
    participationHistory?: string | null
    bestResult?: string | null
    description?: string | null
    defaultFormation?: string
    defaultLineupPlayerIds?: CountryCreatedefaultLineupPlayerIdsInput | string[]
    defaultCaptainId?: string | null
    groupId?: string | null
    isEliminated?: boolean
    players?: PlayerUncheckedCreateNestedManyWithoutCountryInput
    homeMatches?: MatchUncheckedCreateNestedManyWithoutHomeTeamInput
    awayMatches?: MatchUncheckedCreateNestedManyWithoutAwayTeamInput
  }

  export type CountryUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    code?: StringFieldUpdateOperationsInput | string
    flagUrl?: NullableStringFieldUpdateOperationsInput | string | null
    flagImage?: NullableStringFieldUpdateOperationsInput | string | null
    confederation?: NullableStringFieldUpdateOperationsInput | string | null
    qualificationMethod?: NullableStringFieldUpdateOperationsInput | string | null
    qualificationDate?: NullableStringFieldUpdateOperationsInput | string | null
    participationHistory?: NullableStringFieldUpdateOperationsInput | string | null
    bestResult?: NullableStringFieldUpdateOperationsInput | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    defaultFormation?: StringFieldUpdateOperationsInput | string
    defaultLineupPlayerIds?: CountryUpdatedefaultLineupPlayerIdsInput | string[]
    defaultCaptainId?: NullableStringFieldUpdateOperationsInput | string | null
    isEliminated?: BoolFieldUpdateOperationsInput | boolean
    group?: GroupUpdateOneWithoutCountriesNestedInput
    players?: PlayerUpdateManyWithoutCountryNestedInput
    homeMatches?: MatchUpdateManyWithoutHomeTeamNestedInput
    awayMatches?: MatchUpdateManyWithoutAwayTeamNestedInput
  }

  export type CountryUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    code?: StringFieldUpdateOperationsInput | string
    flagUrl?: NullableStringFieldUpdateOperationsInput | string | null
    flagImage?: NullableStringFieldUpdateOperationsInput | string | null
    confederation?: NullableStringFieldUpdateOperationsInput | string | null
    qualificationMethod?: NullableStringFieldUpdateOperationsInput | string | null
    qualificationDate?: NullableStringFieldUpdateOperationsInput | string | null
    participationHistory?: NullableStringFieldUpdateOperationsInput | string | null
    bestResult?: NullableStringFieldUpdateOperationsInput | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    defaultFormation?: StringFieldUpdateOperationsInput | string
    defaultLineupPlayerIds?: CountryUpdatedefaultLineupPlayerIdsInput | string[]
    defaultCaptainId?: NullableStringFieldUpdateOperationsInput | string | null
    groupId?: NullableStringFieldUpdateOperationsInput | string | null
    isEliminated?: BoolFieldUpdateOperationsInput | boolean
    players?: PlayerUncheckedUpdateManyWithoutCountryNestedInput
    homeMatches?: MatchUncheckedUpdateManyWithoutHomeTeamNestedInput
    awayMatches?: MatchUncheckedUpdateManyWithoutAwayTeamNestedInput
  }

  export type CountryCreateManyInput = {
    id?: string
    name: string
    code: string
    flagUrl?: string | null
    flagImage?: string | null
    confederation?: string | null
    qualificationMethod?: string | null
    qualificationDate?: string | null
    participationHistory?: string | null
    bestResult?: string | null
    description?: string | null
    defaultFormation?: string
    defaultLineupPlayerIds?: CountryCreatedefaultLineupPlayerIdsInput | string[]
    defaultCaptainId?: string | null
    groupId?: string | null
    isEliminated?: boolean
  }

  export type CountryUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    code?: StringFieldUpdateOperationsInput | string
    flagUrl?: NullableStringFieldUpdateOperationsInput | string | null
    flagImage?: NullableStringFieldUpdateOperationsInput | string | null
    confederation?: NullableStringFieldUpdateOperationsInput | string | null
    qualificationMethod?: NullableStringFieldUpdateOperationsInput | string | null
    qualificationDate?: NullableStringFieldUpdateOperationsInput | string | null
    participationHistory?: NullableStringFieldUpdateOperationsInput | string | null
    bestResult?: NullableStringFieldUpdateOperationsInput | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    defaultFormation?: StringFieldUpdateOperationsInput | string
    defaultLineupPlayerIds?: CountryUpdatedefaultLineupPlayerIdsInput | string[]
    defaultCaptainId?: NullableStringFieldUpdateOperationsInput | string | null
    isEliminated?: BoolFieldUpdateOperationsInput | boolean
  }

  export type CountryUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    code?: StringFieldUpdateOperationsInput | string
    flagUrl?: NullableStringFieldUpdateOperationsInput | string | null
    flagImage?: NullableStringFieldUpdateOperationsInput | string | null
    confederation?: NullableStringFieldUpdateOperationsInput | string | null
    qualificationMethod?: NullableStringFieldUpdateOperationsInput | string | null
    qualificationDate?: NullableStringFieldUpdateOperationsInput | string | null
    participationHistory?: NullableStringFieldUpdateOperationsInput | string | null
    bestResult?: NullableStringFieldUpdateOperationsInput | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    defaultFormation?: StringFieldUpdateOperationsInput | string
    defaultLineupPlayerIds?: CountryUpdatedefaultLineupPlayerIdsInput | string[]
    defaultCaptainId?: NullableStringFieldUpdateOperationsInput | string | null
    groupId?: NullableStringFieldUpdateOperationsInput | string | null
    isEliminated?: BoolFieldUpdateOperationsInput | boolean
  }

  export type GroupCreateInput = {
    id?: string
    name: string
    countries?: CountryCreateNestedManyWithoutGroupInput
  }

  export type GroupUncheckedCreateInput = {
    id?: string
    name: string
    countries?: CountryUncheckedCreateNestedManyWithoutGroupInput
  }

  export type GroupUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    countries?: CountryUpdateManyWithoutGroupNestedInput
  }

  export type GroupUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    countries?: CountryUncheckedUpdateManyWithoutGroupNestedInput
  }

  export type GroupCreateManyInput = {
    id?: string
    name: string
  }

  export type GroupUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
  }

  export type GroupUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
  }

  export type PlayerCreateInput = {
    id?: string
    name: string
    image?: string | null
    position: $Enums.Position
    price?: number
    totalPoints?: number
    isActive?: boolean
    isGoldenCardEligible?: boolean
    cardTier?: $Enums.CardTier
    createdAt?: Date | string
    updatedAt?: Date | string
    country: CountryCreateNestedOneWithoutPlayersInput
    matchStats?: PlayerMatchStatCreateNestedManyWithoutPlayerInput
    teamPlayers?: TeamPlayerCreateNestedManyWithoutPlayerInput
    events?: MatchEventCreateNestedManyWithoutPlayerInput
    goldenCards?: GoldenCardCreateNestedManyWithoutPlayerInput
  }

  export type PlayerUncheckedCreateInput = {
    id?: string
    name: string
    image?: string | null
    position: $Enums.Position
    countryId: string
    price?: number
    totalPoints?: number
    isActive?: boolean
    isGoldenCardEligible?: boolean
    cardTier?: $Enums.CardTier
    createdAt?: Date | string
    updatedAt?: Date | string
    matchStats?: PlayerMatchStatUncheckedCreateNestedManyWithoutPlayerInput
    teamPlayers?: TeamPlayerUncheckedCreateNestedManyWithoutPlayerInput
    events?: MatchEventUncheckedCreateNestedManyWithoutPlayerInput
    goldenCards?: GoldenCardUncheckedCreateNestedManyWithoutPlayerInput
  }

  export type PlayerUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    image?: NullableStringFieldUpdateOperationsInput | string | null
    position?: EnumPositionFieldUpdateOperationsInput | $Enums.Position
    price?: FloatFieldUpdateOperationsInput | number
    totalPoints?: IntFieldUpdateOperationsInput | number
    isActive?: BoolFieldUpdateOperationsInput | boolean
    isGoldenCardEligible?: BoolFieldUpdateOperationsInput | boolean
    cardTier?: EnumCardTierFieldUpdateOperationsInput | $Enums.CardTier
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    country?: CountryUpdateOneRequiredWithoutPlayersNestedInput
    matchStats?: PlayerMatchStatUpdateManyWithoutPlayerNestedInput
    teamPlayers?: TeamPlayerUpdateManyWithoutPlayerNestedInput
    events?: MatchEventUpdateManyWithoutPlayerNestedInput
    goldenCards?: GoldenCardUpdateManyWithoutPlayerNestedInput
  }

  export type PlayerUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    image?: NullableStringFieldUpdateOperationsInput | string | null
    position?: EnumPositionFieldUpdateOperationsInput | $Enums.Position
    countryId?: StringFieldUpdateOperationsInput | string
    price?: FloatFieldUpdateOperationsInput | number
    totalPoints?: IntFieldUpdateOperationsInput | number
    isActive?: BoolFieldUpdateOperationsInput | boolean
    isGoldenCardEligible?: BoolFieldUpdateOperationsInput | boolean
    cardTier?: EnumCardTierFieldUpdateOperationsInput | $Enums.CardTier
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    matchStats?: PlayerMatchStatUncheckedUpdateManyWithoutPlayerNestedInput
    teamPlayers?: TeamPlayerUncheckedUpdateManyWithoutPlayerNestedInput
    events?: MatchEventUncheckedUpdateManyWithoutPlayerNestedInput
    goldenCards?: GoldenCardUncheckedUpdateManyWithoutPlayerNestedInput
  }

  export type PlayerCreateManyInput = {
    id?: string
    name: string
    image?: string | null
    position: $Enums.Position
    countryId: string
    price?: number
    totalPoints?: number
    isActive?: boolean
    isGoldenCardEligible?: boolean
    cardTier?: $Enums.CardTier
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type PlayerUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    image?: NullableStringFieldUpdateOperationsInput | string | null
    position?: EnumPositionFieldUpdateOperationsInput | $Enums.Position
    price?: FloatFieldUpdateOperationsInput | number
    totalPoints?: IntFieldUpdateOperationsInput | number
    isActive?: BoolFieldUpdateOperationsInput | boolean
    isGoldenCardEligible?: BoolFieldUpdateOperationsInput | boolean
    cardTier?: EnumCardTierFieldUpdateOperationsInput | $Enums.CardTier
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type PlayerUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    image?: NullableStringFieldUpdateOperationsInput | string | null
    position?: EnumPositionFieldUpdateOperationsInput | $Enums.Position
    countryId?: StringFieldUpdateOperationsInput | string
    price?: FloatFieldUpdateOperationsInput | number
    totalPoints?: IntFieldUpdateOperationsInput | number
    isActive?: BoolFieldUpdateOperationsInput | boolean
    isGoldenCardEligible?: BoolFieldUpdateOperationsInput | boolean
    cardTier?: EnumCardTierFieldUpdateOperationsInput | $Enums.CardTier
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type MatchCreateInput = {
    id?: string
    homeScore?: number | null
    awayScore?: number | null
    stage?: $Enums.MatchStage
    status?: $Enums.MatchStatus
    matchDate: Date | string
    matchDatePersian?: string | null
    stadium?: string | null
    city?: string | null
    referee?: string | null
    assistant1?: string | null
    assistant2?: string | null
    fourthOfficial?: string | null
    attendance?: number | null
    weather?: string | null
    description?: string | null
    createdAt?: Date | string
    homeTeam: CountryCreateNestedOneWithoutHomeMatchesInput
    awayTeam: CountryCreateNestedOneWithoutAwayMatchesInput
    round?: RoundCreateNestedOneWithoutMatchesInput
    playerStats?: PlayerMatchStatCreateNestedManyWithoutMatchInput
    events?: MatchEventCreateNestedManyWithoutMatchInput
    lineups?: MatchLineupCreateNestedManyWithoutMatchInput
  }

  export type MatchUncheckedCreateInput = {
    id?: string
    homeTeamId: string
    awayTeamId: string
    homeScore?: number | null
    awayScore?: number | null
    stage?: $Enums.MatchStage
    status?: $Enums.MatchStatus
    matchDate: Date | string
    matchDatePersian?: string | null
    stadium?: string | null
    city?: string | null
    referee?: string | null
    assistant1?: string | null
    assistant2?: string | null
    fourthOfficial?: string | null
    attendance?: number | null
    weather?: string | null
    description?: string | null
    roundId?: string | null
    createdAt?: Date | string
    playerStats?: PlayerMatchStatUncheckedCreateNestedManyWithoutMatchInput
    events?: MatchEventUncheckedCreateNestedManyWithoutMatchInput
    lineups?: MatchLineupUncheckedCreateNestedManyWithoutMatchInput
  }

  export type MatchUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    homeScore?: NullableIntFieldUpdateOperationsInput | number | null
    awayScore?: NullableIntFieldUpdateOperationsInput | number | null
    stage?: EnumMatchStageFieldUpdateOperationsInput | $Enums.MatchStage
    status?: EnumMatchStatusFieldUpdateOperationsInput | $Enums.MatchStatus
    matchDate?: DateTimeFieldUpdateOperationsInput | Date | string
    matchDatePersian?: NullableStringFieldUpdateOperationsInput | string | null
    stadium?: NullableStringFieldUpdateOperationsInput | string | null
    city?: NullableStringFieldUpdateOperationsInput | string | null
    referee?: NullableStringFieldUpdateOperationsInput | string | null
    assistant1?: NullableStringFieldUpdateOperationsInput | string | null
    assistant2?: NullableStringFieldUpdateOperationsInput | string | null
    fourthOfficial?: NullableStringFieldUpdateOperationsInput | string | null
    attendance?: NullableIntFieldUpdateOperationsInput | number | null
    weather?: NullableStringFieldUpdateOperationsInput | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    homeTeam?: CountryUpdateOneRequiredWithoutHomeMatchesNestedInput
    awayTeam?: CountryUpdateOneRequiredWithoutAwayMatchesNestedInput
    round?: RoundUpdateOneWithoutMatchesNestedInput
    playerStats?: PlayerMatchStatUpdateManyWithoutMatchNestedInput
    events?: MatchEventUpdateManyWithoutMatchNestedInput
    lineups?: MatchLineupUpdateManyWithoutMatchNestedInput
  }

  export type MatchUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    homeTeamId?: StringFieldUpdateOperationsInput | string
    awayTeamId?: StringFieldUpdateOperationsInput | string
    homeScore?: NullableIntFieldUpdateOperationsInput | number | null
    awayScore?: NullableIntFieldUpdateOperationsInput | number | null
    stage?: EnumMatchStageFieldUpdateOperationsInput | $Enums.MatchStage
    status?: EnumMatchStatusFieldUpdateOperationsInput | $Enums.MatchStatus
    matchDate?: DateTimeFieldUpdateOperationsInput | Date | string
    matchDatePersian?: NullableStringFieldUpdateOperationsInput | string | null
    stadium?: NullableStringFieldUpdateOperationsInput | string | null
    city?: NullableStringFieldUpdateOperationsInput | string | null
    referee?: NullableStringFieldUpdateOperationsInput | string | null
    assistant1?: NullableStringFieldUpdateOperationsInput | string | null
    assistant2?: NullableStringFieldUpdateOperationsInput | string | null
    fourthOfficial?: NullableStringFieldUpdateOperationsInput | string | null
    attendance?: NullableIntFieldUpdateOperationsInput | number | null
    weather?: NullableStringFieldUpdateOperationsInput | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    roundId?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    playerStats?: PlayerMatchStatUncheckedUpdateManyWithoutMatchNestedInput
    events?: MatchEventUncheckedUpdateManyWithoutMatchNestedInput
    lineups?: MatchLineupUncheckedUpdateManyWithoutMatchNestedInput
  }

  export type MatchCreateManyInput = {
    id?: string
    homeTeamId: string
    awayTeamId: string
    homeScore?: number | null
    awayScore?: number | null
    stage?: $Enums.MatchStage
    status?: $Enums.MatchStatus
    matchDate: Date | string
    matchDatePersian?: string | null
    stadium?: string | null
    city?: string | null
    referee?: string | null
    assistant1?: string | null
    assistant2?: string | null
    fourthOfficial?: string | null
    attendance?: number | null
    weather?: string | null
    description?: string | null
    roundId?: string | null
    createdAt?: Date | string
  }

  export type MatchUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    homeScore?: NullableIntFieldUpdateOperationsInput | number | null
    awayScore?: NullableIntFieldUpdateOperationsInput | number | null
    stage?: EnumMatchStageFieldUpdateOperationsInput | $Enums.MatchStage
    status?: EnumMatchStatusFieldUpdateOperationsInput | $Enums.MatchStatus
    matchDate?: DateTimeFieldUpdateOperationsInput | Date | string
    matchDatePersian?: NullableStringFieldUpdateOperationsInput | string | null
    stadium?: NullableStringFieldUpdateOperationsInput | string | null
    city?: NullableStringFieldUpdateOperationsInput | string | null
    referee?: NullableStringFieldUpdateOperationsInput | string | null
    assistant1?: NullableStringFieldUpdateOperationsInput | string | null
    assistant2?: NullableStringFieldUpdateOperationsInput | string | null
    fourthOfficial?: NullableStringFieldUpdateOperationsInput | string | null
    attendance?: NullableIntFieldUpdateOperationsInput | number | null
    weather?: NullableStringFieldUpdateOperationsInput | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type MatchUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    homeTeamId?: StringFieldUpdateOperationsInput | string
    awayTeamId?: StringFieldUpdateOperationsInput | string
    homeScore?: NullableIntFieldUpdateOperationsInput | number | null
    awayScore?: NullableIntFieldUpdateOperationsInput | number | null
    stage?: EnumMatchStageFieldUpdateOperationsInput | $Enums.MatchStage
    status?: EnumMatchStatusFieldUpdateOperationsInput | $Enums.MatchStatus
    matchDate?: DateTimeFieldUpdateOperationsInput | Date | string
    matchDatePersian?: NullableStringFieldUpdateOperationsInput | string | null
    stadium?: NullableStringFieldUpdateOperationsInput | string | null
    city?: NullableStringFieldUpdateOperationsInput | string | null
    referee?: NullableStringFieldUpdateOperationsInput | string | null
    assistant1?: NullableStringFieldUpdateOperationsInput | string | null
    assistant2?: NullableStringFieldUpdateOperationsInput | string | null
    fourthOfficial?: NullableStringFieldUpdateOperationsInput | string | null
    attendance?: NullableIntFieldUpdateOperationsInput | number | null
    weather?: NullableStringFieldUpdateOperationsInput | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    roundId?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type RoundCreateInput = {
    id?: string
    number: number
    name: string
    isActive?: boolean
    deadline: Date | string
    createdAt?: Date | string
    matches?: MatchCreateNestedManyWithoutRoundInput
  }

  export type RoundUncheckedCreateInput = {
    id?: string
    number: number
    name: string
    isActive?: boolean
    deadline: Date | string
    createdAt?: Date | string
    matches?: MatchUncheckedCreateNestedManyWithoutRoundInput
  }

  export type RoundUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    number?: IntFieldUpdateOperationsInput | number
    name?: StringFieldUpdateOperationsInput | string
    isActive?: BoolFieldUpdateOperationsInput | boolean
    deadline?: DateTimeFieldUpdateOperationsInput | Date | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    matches?: MatchUpdateManyWithoutRoundNestedInput
  }

  export type RoundUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    number?: IntFieldUpdateOperationsInput | number
    name?: StringFieldUpdateOperationsInput | string
    isActive?: BoolFieldUpdateOperationsInput | boolean
    deadline?: DateTimeFieldUpdateOperationsInput | Date | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    matches?: MatchUncheckedUpdateManyWithoutRoundNestedInput
  }

  export type RoundCreateManyInput = {
    id?: string
    number: number
    name: string
    isActive?: boolean
    deadline: Date | string
    createdAt?: Date | string
  }

  export type RoundUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    number?: IntFieldUpdateOperationsInput | number
    name?: StringFieldUpdateOperationsInput | string
    isActive?: BoolFieldUpdateOperationsInput | boolean
    deadline?: DateTimeFieldUpdateOperationsInput | Date | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type RoundUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    number?: IntFieldUpdateOperationsInput | number
    name?: StringFieldUpdateOperationsInput | string
    isActive?: BoolFieldUpdateOperationsInput | boolean
    deadline?: DateTimeFieldUpdateOperationsInput | Date | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type GameweekCreateInput = {
    id?: string
    number: number
    name: string
    isActive?: boolean
    deadline: Date | string
    createdAt?: Date | string
  }

  export type GameweekUncheckedCreateInput = {
    id?: string
    number: number
    name: string
    isActive?: boolean
    deadline: Date | string
    createdAt?: Date | string
  }

  export type GameweekUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    number?: IntFieldUpdateOperationsInput | number
    name?: StringFieldUpdateOperationsInput | string
    isActive?: BoolFieldUpdateOperationsInput | boolean
    deadline?: DateTimeFieldUpdateOperationsInput | Date | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type GameweekUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    number?: IntFieldUpdateOperationsInput | number
    name?: StringFieldUpdateOperationsInput | string
    isActive?: BoolFieldUpdateOperationsInput | boolean
    deadline?: DateTimeFieldUpdateOperationsInput | Date | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type GameweekCreateManyInput = {
    id?: string
    number: number
    name: string
    isActive?: boolean
    deadline: Date | string
    createdAt?: Date | string
  }

  export type GameweekUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    number?: IntFieldUpdateOperationsInput | number
    name?: StringFieldUpdateOperationsInput | string
    isActive?: BoolFieldUpdateOperationsInput | boolean
    deadline?: DateTimeFieldUpdateOperationsInput | Date | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type GameweekUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    number?: IntFieldUpdateOperationsInput | number
    name?: StringFieldUpdateOperationsInput | string
    isActive?: BoolFieldUpdateOperationsInput | boolean
    deadline?: DateTimeFieldUpdateOperationsInput | Date | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type MatchEventCreateInput = {
    id?: string
    type: $Enums.EventType
    minute?: number | null
    extraInfo?: string | null
    createdAt?: Date | string
    match: MatchCreateNestedOneWithoutEventsInput
    player: PlayerCreateNestedOneWithoutEventsInput
  }

  export type MatchEventUncheckedCreateInput = {
    id?: string
    matchId: string
    playerId: string
    type: $Enums.EventType
    minute?: number | null
    extraInfo?: string | null
    createdAt?: Date | string
  }

  export type MatchEventUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    type?: EnumEventTypeFieldUpdateOperationsInput | $Enums.EventType
    minute?: NullableIntFieldUpdateOperationsInput | number | null
    extraInfo?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    match?: MatchUpdateOneRequiredWithoutEventsNestedInput
    player?: PlayerUpdateOneRequiredWithoutEventsNestedInput
  }

  export type MatchEventUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    matchId?: StringFieldUpdateOperationsInput | string
    playerId?: StringFieldUpdateOperationsInput | string
    type?: EnumEventTypeFieldUpdateOperationsInput | $Enums.EventType
    minute?: NullableIntFieldUpdateOperationsInput | number | null
    extraInfo?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type MatchEventCreateManyInput = {
    id?: string
    matchId: string
    playerId: string
    type: $Enums.EventType
    minute?: number | null
    extraInfo?: string | null
    createdAt?: Date | string
  }

  export type MatchEventUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    type?: EnumEventTypeFieldUpdateOperationsInput | $Enums.EventType
    minute?: NullableIntFieldUpdateOperationsInput | number | null
    extraInfo?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type MatchEventUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    matchId?: StringFieldUpdateOperationsInput | string
    playerId?: StringFieldUpdateOperationsInput | string
    type?: EnumEventTypeFieldUpdateOperationsInput | $Enums.EventType
    minute?: NullableIntFieldUpdateOperationsInput | number | null
    extraInfo?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type MatchLineupCreateInput = {
    id?: string
    countryId: string
    formation: string
    playerIds?: MatchLineupCreateplayerIdsInput | string[]
    match: MatchCreateNestedOneWithoutLineupsInput
  }

  export type MatchLineupUncheckedCreateInput = {
    id?: string
    matchId: string
    countryId: string
    formation: string
    playerIds?: MatchLineupCreateplayerIdsInput | string[]
  }

  export type MatchLineupUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    countryId?: StringFieldUpdateOperationsInput | string
    formation?: StringFieldUpdateOperationsInput | string
    playerIds?: MatchLineupUpdateplayerIdsInput | string[]
    match?: MatchUpdateOneRequiredWithoutLineupsNestedInput
  }

  export type MatchLineupUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    matchId?: StringFieldUpdateOperationsInput | string
    countryId?: StringFieldUpdateOperationsInput | string
    formation?: StringFieldUpdateOperationsInput | string
    playerIds?: MatchLineupUpdateplayerIdsInput | string[]
  }

  export type MatchLineupCreateManyInput = {
    id?: string
    matchId: string
    countryId: string
    formation: string
    playerIds?: MatchLineupCreateplayerIdsInput | string[]
  }

  export type MatchLineupUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    countryId?: StringFieldUpdateOperationsInput | string
    formation?: StringFieldUpdateOperationsInput | string
    playerIds?: MatchLineupUpdateplayerIdsInput | string[]
  }

  export type MatchLineupUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    matchId?: StringFieldUpdateOperationsInput | string
    countryId?: StringFieldUpdateOperationsInput | string
    formation?: StringFieldUpdateOperationsInput | string
    playerIds?: MatchLineupUpdateplayerIdsInput | string[]
  }

  export type PlayerMatchStatCreateInput = {
    id?: string
    goals?: number
    assists?: number
    yellowCards?: number
    redCards?: number
    minutesPlayed?: number
    cleanSheet?: boolean
    penaltySaved?: number
    penaltyMissed?: number
    ownGoals?: number
    isMotm?: boolean
    extraTimeBonus?: number
    points?: number
    player: PlayerCreateNestedOneWithoutMatchStatsInput
    match: MatchCreateNestedOneWithoutPlayerStatsInput
  }

  export type PlayerMatchStatUncheckedCreateInput = {
    id?: string
    playerId: string
    matchId: string
    goals?: number
    assists?: number
    yellowCards?: number
    redCards?: number
    minutesPlayed?: number
    cleanSheet?: boolean
    penaltySaved?: number
    penaltyMissed?: number
    ownGoals?: number
    isMotm?: boolean
    extraTimeBonus?: number
    points?: number
  }

  export type PlayerMatchStatUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    goals?: IntFieldUpdateOperationsInput | number
    assists?: IntFieldUpdateOperationsInput | number
    yellowCards?: IntFieldUpdateOperationsInput | number
    redCards?: IntFieldUpdateOperationsInput | number
    minutesPlayed?: IntFieldUpdateOperationsInput | number
    cleanSheet?: BoolFieldUpdateOperationsInput | boolean
    penaltySaved?: IntFieldUpdateOperationsInput | number
    penaltyMissed?: IntFieldUpdateOperationsInput | number
    ownGoals?: IntFieldUpdateOperationsInput | number
    isMotm?: BoolFieldUpdateOperationsInput | boolean
    extraTimeBonus?: IntFieldUpdateOperationsInput | number
    points?: IntFieldUpdateOperationsInput | number
    player?: PlayerUpdateOneRequiredWithoutMatchStatsNestedInput
    match?: MatchUpdateOneRequiredWithoutPlayerStatsNestedInput
  }

  export type PlayerMatchStatUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    playerId?: StringFieldUpdateOperationsInput | string
    matchId?: StringFieldUpdateOperationsInput | string
    goals?: IntFieldUpdateOperationsInput | number
    assists?: IntFieldUpdateOperationsInput | number
    yellowCards?: IntFieldUpdateOperationsInput | number
    redCards?: IntFieldUpdateOperationsInput | number
    minutesPlayed?: IntFieldUpdateOperationsInput | number
    cleanSheet?: BoolFieldUpdateOperationsInput | boolean
    penaltySaved?: IntFieldUpdateOperationsInput | number
    penaltyMissed?: IntFieldUpdateOperationsInput | number
    ownGoals?: IntFieldUpdateOperationsInput | number
    isMotm?: BoolFieldUpdateOperationsInput | boolean
    extraTimeBonus?: IntFieldUpdateOperationsInput | number
    points?: IntFieldUpdateOperationsInput | number
  }

  export type PlayerMatchStatCreateManyInput = {
    id?: string
    playerId: string
    matchId: string
    goals?: number
    assists?: number
    yellowCards?: number
    redCards?: number
    minutesPlayed?: number
    cleanSheet?: boolean
    penaltySaved?: number
    penaltyMissed?: number
    ownGoals?: number
    isMotm?: boolean
    extraTimeBonus?: number
    points?: number
  }

  export type PlayerMatchStatUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    goals?: IntFieldUpdateOperationsInput | number
    assists?: IntFieldUpdateOperationsInput | number
    yellowCards?: IntFieldUpdateOperationsInput | number
    redCards?: IntFieldUpdateOperationsInput | number
    minutesPlayed?: IntFieldUpdateOperationsInput | number
    cleanSheet?: BoolFieldUpdateOperationsInput | boolean
    penaltySaved?: IntFieldUpdateOperationsInput | number
    penaltyMissed?: IntFieldUpdateOperationsInput | number
    ownGoals?: IntFieldUpdateOperationsInput | number
    isMotm?: BoolFieldUpdateOperationsInput | boolean
    extraTimeBonus?: IntFieldUpdateOperationsInput | number
    points?: IntFieldUpdateOperationsInput | number
  }

  export type PlayerMatchStatUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    playerId?: StringFieldUpdateOperationsInput | string
    matchId?: StringFieldUpdateOperationsInput | string
    goals?: IntFieldUpdateOperationsInput | number
    assists?: IntFieldUpdateOperationsInput | number
    yellowCards?: IntFieldUpdateOperationsInput | number
    redCards?: IntFieldUpdateOperationsInput | number
    minutesPlayed?: IntFieldUpdateOperationsInput | number
    cleanSheet?: BoolFieldUpdateOperationsInput | boolean
    penaltySaved?: IntFieldUpdateOperationsInput | number
    penaltyMissed?: IntFieldUpdateOperationsInput | number
    ownGoals?: IntFieldUpdateOperationsInput | number
    isMotm?: BoolFieldUpdateOperationsInput | boolean
    extraTimeBonus?: IntFieldUpdateOperationsInput | number
    points?: IntFieldUpdateOperationsInput | number
  }

  export type ScoringRuleCreateInput = {
    id?: string
    position: $Enums.Position
    eventType: $Enums.EventType
    points: number
    updatedAt?: Date | string
    updatedBy?: string | null
  }

  export type ScoringRuleUncheckedCreateInput = {
    id?: string
    position: $Enums.Position
    eventType: $Enums.EventType
    points: number
    updatedAt?: Date | string
    updatedBy?: string | null
  }

  export type ScoringRuleUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    position?: EnumPositionFieldUpdateOperationsInput | $Enums.Position
    eventType?: EnumEventTypeFieldUpdateOperationsInput | $Enums.EventType
    points?: IntFieldUpdateOperationsInput | number
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedBy?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type ScoringRuleUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    position?: EnumPositionFieldUpdateOperationsInput | $Enums.Position
    eventType?: EnumEventTypeFieldUpdateOperationsInput | $Enums.EventType
    points?: IntFieldUpdateOperationsInput | number
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedBy?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type ScoringRuleCreateManyInput = {
    id?: string
    position: $Enums.Position
    eventType: $Enums.EventType
    points: number
    updatedAt?: Date | string
    updatedBy?: string | null
  }

  export type ScoringRuleUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    position?: EnumPositionFieldUpdateOperationsInput | $Enums.Position
    eventType?: EnumEventTypeFieldUpdateOperationsInput | $Enums.EventType
    points?: IntFieldUpdateOperationsInput | number
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedBy?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type ScoringRuleUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    position?: EnumPositionFieldUpdateOperationsInput | $Enums.Position
    eventType?: EnumEventTypeFieldUpdateOperationsInput | $Enums.EventType
    points?: IntFieldUpdateOperationsInput | number
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedBy?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type UserCreateInput = {
    id?: string
    name?: string | null
    email: string
    phone?: string | null
    password: string
    role?: $Enums.Role
    createdAt?: Date | string
    team?: TeamCreateNestedOneWithoutUserInput
    sessions?: SessionCreateNestedManyWithoutUserInput
    payments?: PaymentCreateNestedManyWithoutUserInput
    quizSubmissions?: QuizSubmissionCreateNestedManyWithoutUserInput
    goldenCards?: GoldenCardCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateInput = {
    id?: string
    name?: string | null
    email: string
    phone?: string | null
    password: string
    role?: $Enums.Role
    createdAt?: Date | string
    team?: TeamUncheckedCreateNestedOneWithoutUserInput
    sessions?: SessionUncheckedCreateNestedManyWithoutUserInput
    payments?: PaymentUncheckedCreateNestedManyWithoutUserInput
    quizSubmissions?: QuizSubmissionUncheckedCreateNestedManyWithoutUserInput
    goldenCards?: GoldenCardUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: NullableStringFieldUpdateOperationsInput | string | null
    email?: StringFieldUpdateOperationsInput | string
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    password?: StringFieldUpdateOperationsInput | string
    role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    team?: TeamUpdateOneWithoutUserNestedInput
    sessions?: SessionUpdateManyWithoutUserNestedInput
    payments?: PaymentUpdateManyWithoutUserNestedInput
    quizSubmissions?: QuizSubmissionUpdateManyWithoutUserNestedInput
    goldenCards?: GoldenCardUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: NullableStringFieldUpdateOperationsInput | string | null
    email?: StringFieldUpdateOperationsInput | string
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    password?: StringFieldUpdateOperationsInput | string
    role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    team?: TeamUncheckedUpdateOneWithoutUserNestedInput
    sessions?: SessionUncheckedUpdateManyWithoutUserNestedInput
    payments?: PaymentUncheckedUpdateManyWithoutUserNestedInput
    quizSubmissions?: QuizSubmissionUncheckedUpdateManyWithoutUserNestedInput
    goldenCards?: GoldenCardUncheckedUpdateManyWithoutUserNestedInput
  }

  export type UserCreateManyInput = {
    id?: string
    name?: string | null
    email: string
    phone?: string | null
    password: string
    role?: $Enums.Role
    createdAt?: Date | string
  }

  export type UserUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: NullableStringFieldUpdateOperationsInput | string | null
    email?: StringFieldUpdateOperationsInput | string
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    password?: StringFieldUpdateOperationsInput | string
    role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type UserUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: NullableStringFieldUpdateOperationsInput | string | null
    email?: StringFieldUpdateOperationsInput | string
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    password?: StringFieldUpdateOperationsInput | string
    role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type LoginOtpCreateInput = {
    id?: string
    phone: string
    codeHash: string
    attempts?: number
    expiresAt: Date | string
    consumedAt?: Date | string | null
    createdAt?: Date | string
  }

  export type LoginOtpUncheckedCreateInput = {
    id?: string
    phone: string
    codeHash: string
    attempts?: number
    expiresAt: Date | string
    consumedAt?: Date | string | null
    createdAt?: Date | string
  }

  export type LoginOtpUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    phone?: StringFieldUpdateOperationsInput | string
    codeHash?: StringFieldUpdateOperationsInput | string
    attempts?: IntFieldUpdateOperationsInput | number
    expiresAt?: DateTimeFieldUpdateOperationsInput | Date | string
    consumedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type LoginOtpUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    phone?: StringFieldUpdateOperationsInput | string
    codeHash?: StringFieldUpdateOperationsInput | string
    attempts?: IntFieldUpdateOperationsInput | number
    expiresAt?: DateTimeFieldUpdateOperationsInput | Date | string
    consumedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type LoginOtpCreateManyInput = {
    id?: string
    phone: string
    codeHash: string
    attempts?: number
    expiresAt: Date | string
    consumedAt?: Date | string | null
    createdAt?: Date | string
  }

  export type LoginOtpUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    phone?: StringFieldUpdateOperationsInput | string
    codeHash?: StringFieldUpdateOperationsInput | string
    attempts?: IntFieldUpdateOperationsInput | number
    expiresAt?: DateTimeFieldUpdateOperationsInput | Date | string
    consumedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type LoginOtpUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    phone?: StringFieldUpdateOperationsInput | string
    codeHash?: StringFieldUpdateOperationsInput | string
    attempts?: IntFieldUpdateOperationsInput | number
    expiresAt?: DateTimeFieldUpdateOperationsInput | Date | string
    consumedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type FantasyNewsCreateInput = {
    id?: string
    icon: string
    title: string
    description: string
    newsTime: Date | string
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type FantasyNewsUncheckedCreateInput = {
    id?: string
    icon: string
    title: string
    description: string
    newsTime: Date | string
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type FantasyNewsUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    icon?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    description?: StringFieldUpdateOperationsInput | string
    newsTime?: DateTimeFieldUpdateOperationsInput | Date | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type FantasyNewsUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    icon?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    description?: StringFieldUpdateOperationsInput | string
    newsTime?: DateTimeFieldUpdateOperationsInput | Date | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type FantasyNewsCreateManyInput = {
    id?: string
    icon: string
    title: string
    description: string
    newsTime: Date | string
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type FantasyNewsUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    icon?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    description?: StringFieldUpdateOperationsInput | string
    newsTime?: DateTimeFieldUpdateOperationsInput | Date | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type FantasyNewsUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    icon?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    description?: StringFieldUpdateOperationsInput | string
    newsTime?: DateTimeFieldUpdateOperationsInput | Date | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type DailyQuizCreateInput = {
    id?: string
    date: Date | string
    windowStart: Date | string
    windowEnd: Date | string
    goldWinnersCount?: number
    silverWinnersCount?: number
    bronzeWinnersCount?: number
    goldMinCorrect?: number | null
    silverMinCorrect?: number | null
    bronzeMinCorrect?: number | null
    isProcessed?: boolean
    createdAt?: Date | string
    questions?: QuizQuestionCreateNestedManyWithoutQuizInput
    submissions?: QuizSubmissionCreateNestedManyWithoutQuizInput
    awardedCards?: GoldenCardCreateNestedManyWithoutQuizInput
  }

  export type DailyQuizUncheckedCreateInput = {
    id?: string
    date: Date | string
    windowStart: Date | string
    windowEnd: Date | string
    goldWinnersCount?: number
    silverWinnersCount?: number
    bronzeWinnersCount?: number
    goldMinCorrect?: number | null
    silverMinCorrect?: number | null
    bronzeMinCorrect?: number | null
    isProcessed?: boolean
    createdAt?: Date | string
    questions?: QuizQuestionUncheckedCreateNestedManyWithoutQuizInput
    submissions?: QuizSubmissionUncheckedCreateNestedManyWithoutQuizInput
    awardedCards?: GoldenCardUncheckedCreateNestedManyWithoutQuizInput
  }

  export type DailyQuizUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    windowStart?: DateTimeFieldUpdateOperationsInput | Date | string
    windowEnd?: DateTimeFieldUpdateOperationsInput | Date | string
    goldWinnersCount?: IntFieldUpdateOperationsInput | number
    silverWinnersCount?: IntFieldUpdateOperationsInput | number
    bronzeWinnersCount?: IntFieldUpdateOperationsInput | number
    goldMinCorrect?: NullableIntFieldUpdateOperationsInput | number | null
    silverMinCorrect?: NullableIntFieldUpdateOperationsInput | number | null
    bronzeMinCorrect?: NullableIntFieldUpdateOperationsInput | number | null
    isProcessed?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    questions?: QuizQuestionUpdateManyWithoutQuizNestedInput
    submissions?: QuizSubmissionUpdateManyWithoutQuizNestedInput
    awardedCards?: GoldenCardUpdateManyWithoutQuizNestedInput
  }

  export type DailyQuizUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    windowStart?: DateTimeFieldUpdateOperationsInput | Date | string
    windowEnd?: DateTimeFieldUpdateOperationsInput | Date | string
    goldWinnersCount?: IntFieldUpdateOperationsInput | number
    silverWinnersCount?: IntFieldUpdateOperationsInput | number
    bronzeWinnersCount?: IntFieldUpdateOperationsInput | number
    goldMinCorrect?: NullableIntFieldUpdateOperationsInput | number | null
    silverMinCorrect?: NullableIntFieldUpdateOperationsInput | number | null
    bronzeMinCorrect?: NullableIntFieldUpdateOperationsInput | number | null
    isProcessed?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    questions?: QuizQuestionUncheckedUpdateManyWithoutQuizNestedInput
    submissions?: QuizSubmissionUncheckedUpdateManyWithoutQuizNestedInput
    awardedCards?: GoldenCardUncheckedUpdateManyWithoutQuizNestedInput
  }

  export type DailyQuizCreateManyInput = {
    id?: string
    date: Date | string
    windowStart: Date | string
    windowEnd: Date | string
    goldWinnersCount?: number
    silverWinnersCount?: number
    bronzeWinnersCount?: number
    goldMinCorrect?: number | null
    silverMinCorrect?: number | null
    bronzeMinCorrect?: number | null
    isProcessed?: boolean
    createdAt?: Date | string
  }

  export type DailyQuizUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    windowStart?: DateTimeFieldUpdateOperationsInput | Date | string
    windowEnd?: DateTimeFieldUpdateOperationsInput | Date | string
    goldWinnersCount?: IntFieldUpdateOperationsInput | number
    silverWinnersCount?: IntFieldUpdateOperationsInput | number
    bronzeWinnersCount?: IntFieldUpdateOperationsInput | number
    goldMinCorrect?: NullableIntFieldUpdateOperationsInput | number | null
    silverMinCorrect?: NullableIntFieldUpdateOperationsInput | number | null
    bronzeMinCorrect?: NullableIntFieldUpdateOperationsInput | number | null
    isProcessed?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type DailyQuizUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    windowStart?: DateTimeFieldUpdateOperationsInput | Date | string
    windowEnd?: DateTimeFieldUpdateOperationsInput | Date | string
    goldWinnersCount?: IntFieldUpdateOperationsInput | number
    silverWinnersCount?: IntFieldUpdateOperationsInput | number
    bronzeWinnersCount?: IntFieldUpdateOperationsInput | number
    goldMinCorrect?: NullableIntFieldUpdateOperationsInput | number | null
    silverMinCorrect?: NullableIntFieldUpdateOperationsInput | number | null
    bronzeMinCorrect?: NullableIntFieldUpdateOperationsInput | number | null
    isProcessed?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type QuizQuestionCreateInput = {
    id?: string
    questionText: string
    options?: QuizQuestionCreateoptionsInput | string[]
    correctAnswer: number
    order?: number
    quiz: DailyQuizCreateNestedOneWithoutQuestionsInput
  }

  export type QuizQuestionUncheckedCreateInput = {
    id?: string
    quizId: string
    questionText: string
    options?: QuizQuestionCreateoptionsInput | string[]
    correctAnswer: number
    order?: number
  }

  export type QuizQuestionUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    questionText?: StringFieldUpdateOperationsInput | string
    options?: QuizQuestionUpdateoptionsInput | string[]
    correctAnswer?: IntFieldUpdateOperationsInput | number
    order?: IntFieldUpdateOperationsInput | number
    quiz?: DailyQuizUpdateOneRequiredWithoutQuestionsNestedInput
  }

  export type QuizQuestionUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    quizId?: StringFieldUpdateOperationsInput | string
    questionText?: StringFieldUpdateOperationsInput | string
    options?: QuizQuestionUpdateoptionsInput | string[]
    correctAnswer?: IntFieldUpdateOperationsInput | number
    order?: IntFieldUpdateOperationsInput | number
  }

  export type QuizQuestionCreateManyInput = {
    id?: string
    quizId: string
    questionText: string
    options?: QuizQuestionCreateoptionsInput | string[]
    correctAnswer: number
    order?: number
  }

  export type QuizQuestionUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    questionText?: StringFieldUpdateOperationsInput | string
    options?: QuizQuestionUpdateoptionsInput | string[]
    correctAnswer?: IntFieldUpdateOperationsInput | number
    order?: IntFieldUpdateOperationsInput | number
  }

  export type QuizQuestionUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    quizId?: StringFieldUpdateOperationsInput | string
    questionText?: StringFieldUpdateOperationsInput | string
    options?: QuizQuestionUpdateoptionsInput | string[]
    correctAnswer?: IntFieldUpdateOperationsInput | number
    order?: IntFieldUpdateOperationsInput | number
  }

  export type QuizSubmissionCreateInput = {
    id?: string
    answers?: QuizSubmissionCreateanswersInput | number[]
    correctAnswers?: number
    score?: number
    submittedAt?: Date | string
    user: UserCreateNestedOneWithoutQuizSubmissionsInput
    quiz: DailyQuizCreateNestedOneWithoutSubmissionsInput
  }

  export type QuizSubmissionUncheckedCreateInput = {
    id?: string
    userId: string
    quizId: string
    answers?: QuizSubmissionCreateanswersInput | number[]
    correctAnswers?: number
    score?: number
    submittedAt?: Date | string
  }

  export type QuizSubmissionUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    answers?: QuizSubmissionUpdateanswersInput | number[]
    correctAnswers?: IntFieldUpdateOperationsInput | number
    score?: IntFieldUpdateOperationsInput | number
    submittedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    user?: UserUpdateOneRequiredWithoutQuizSubmissionsNestedInput
    quiz?: DailyQuizUpdateOneRequiredWithoutSubmissionsNestedInput
  }

  export type QuizSubmissionUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    quizId?: StringFieldUpdateOperationsInput | string
    answers?: QuizSubmissionUpdateanswersInput | number[]
    correctAnswers?: IntFieldUpdateOperationsInput | number
    score?: IntFieldUpdateOperationsInput | number
    submittedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type QuizSubmissionCreateManyInput = {
    id?: string
    userId: string
    quizId: string
    answers?: QuizSubmissionCreateanswersInput | number[]
    correctAnswers?: number
    score?: number
    submittedAt?: Date | string
  }

  export type QuizSubmissionUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    answers?: QuizSubmissionUpdateanswersInput | number[]
    correctAnswers?: IntFieldUpdateOperationsInput | number
    score?: IntFieldUpdateOperationsInput | number
    submittedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type QuizSubmissionUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    quizId?: StringFieldUpdateOperationsInput | string
    answers?: QuizSubmissionUpdateanswersInput | number[]
    correctAnswers?: IntFieldUpdateOperationsInput | number
    score?: IntFieldUpdateOperationsInput | number
    submittedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type GoldenCardCreateInput = {
    id?: string
    cardTier?: $Enums.CardTier
    status?: $Enums.GoldenCardStatus
    state?: $Enums.SpecialCardState
    acquiredDate?: Date | string
    openedAt?: Date | string | null
    user: UserCreateNestedOneWithoutGoldenCardsInput
    quiz?: DailyQuizCreateNestedOneWithoutAwardedCardsInput
    player: PlayerCreateNestedOneWithoutGoldenCardsInput
    teamPlayer?: TeamPlayerCreateNestedOneWithoutGoldenCardInput
  }

  export type GoldenCardUncheckedCreateInput = {
    id?: string
    userId: string
    quizId?: string | null
    playerId: string
    cardTier?: $Enums.CardTier
    status?: $Enums.GoldenCardStatus
    state?: $Enums.SpecialCardState
    acquiredDate?: Date | string
    openedAt?: Date | string | null
    teamPlayer?: TeamPlayerUncheckedCreateNestedOneWithoutGoldenCardInput
  }

  export type GoldenCardUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    cardTier?: EnumCardTierFieldUpdateOperationsInput | $Enums.CardTier
    status?: EnumGoldenCardStatusFieldUpdateOperationsInput | $Enums.GoldenCardStatus
    state?: EnumSpecialCardStateFieldUpdateOperationsInput | $Enums.SpecialCardState
    acquiredDate?: DateTimeFieldUpdateOperationsInput | Date | string
    openedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    user?: UserUpdateOneRequiredWithoutGoldenCardsNestedInput
    quiz?: DailyQuizUpdateOneWithoutAwardedCardsNestedInput
    player?: PlayerUpdateOneRequiredWithoutGoldenCardsNestedInput
    teamPlayer?: TeamPlayerUpdateOneWithoutGoldenCardNestedInput
  }

  export type GoldenCardUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    quizId?: NullableStringFieldUpdateOperationsInput | string | null
    playerId?: StringFieldUpdateOperationsInput | string
    cardTier?: EnumCardTierFieldUpdateOperationsInput | $Enums.CardTier
    status?: EnumGoldenCardStatusFieldUpdateOperationsInput | $Enums.GoldenCardStatus
    state?: EnumSpecialCardStateFieldUpdateOperationsInput | $Enums.SpecialCardState
    acquiredDate?: DateTimeFieldUpdateOperationsInput | Date | string
    openedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    teamPlayer?: TeamPlayerUncheckedUpdateOneWithoutGoldenCardNestedInput
  }

  export type GoldenCardCreateManyInput = {
    id?: string
    userId: string
    quizId?: string | null
    playerId: string
    cardTier?: $Enums.CardTier
    status?: $Enums.GoldenCardStatus
    state?: $Enums.SpecialCardState
    acquiredDate?: Date | string
    openedAt?: Date | string | null
  }

  export type GoldenCardUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    cardTier?: EnumCardTierFieldUpdateOperationsInput | $Enums.CardTier
    status?: EnumGoldenCardStatusFieldUpdateOperationsInput | $Enums.GoldenCardStatus
    state?: EnumSpecialCardStateFieldUpdateOperationsInput | $Enums.SpecialCardState
    acquiredDate?: DateTimeFieldUpdateOperationsInput | Date | string
    openedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type GoldenCardUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    quizId?: NullableStringFieldUpdateOperationsInput | string | null
    playerId?: StringFieldUpdateOperationsInput | string
    cardTier?: EnumCardTierFieldUpdateOperationsInput | $Enums.CardTier
    status?: EnumGoldenCardStatusFieldUpdateOperationsInput | $Enums.GoldenCardStatus
    state?: EnumSpecialCardStateFieldUpdateOperationsInput | $Enums.SpecialCardState
    acquiredDate?: DateTimeFieldUpdateOperationsInput | Date | string
    openedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type SessionCreateInput = {
    id?: string
    sessionToken: string
    expires: Date | string
    user: UserCreateNestedOneWithoutSessionsInput
  }

  export type SessionUncheckedCreateInput = {
    id?: string
    sessionToken: string
    userId: string
    expires: Date | string
  }

  export type SessionUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    sessionToken?: StringFieldUpdateOperationsInput | string
    expires?: DateTimeFieldUpdateOperationsInput | Date | string
    user?: UserUpdateOneRequiredWithoutSessionsNestedInput
  }

  export type SessionUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    sessionToken?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    expires?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type SessionCreateManyInput = {
    id?: string
    sessionToken: string
    userId: string
    expires: Date | string
  }

  export type SessionUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    sessionToken?: StringFieldUpdateOperationsInput | string
    expires?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type SessionUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    sessionToken?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    expires?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type TeamCreateInput = {
    id?: string
    name: string
    budget?: number
    totalPoints?: number
    formation?: string
    status?: $Enums.TeamStatus
    createdAt?: Date | string
    user: UserCreateNestedOneWithoutTeamInput
    players?: TeamPlayerCreateNestedManyWithoutTeamInput
  }

  export type TeamUncheckedCreateInput = {
    id?: string
    name: string
    userId: string
    budget?: number
    totalPoints?: number
    formation?: string
    status?: $Enums.TeamStatus
    createdAt?: Date | string
    players?: TeamPlayerUncheckedCreateNestedManyWithoutTeamInput
  }

  export type TeamUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    budget?: FloatFieldUpdateOperationsInput | number
    totalPoints?: IntFieldUpdateOperationsInput | number
    formation?: StringFieldUpdateOperationsInput | string
    status?: EnumTeamStatusFieldUpdateOperationsInput | $Enums.TeamStatus
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    user?: UserUpdateOneRequiredWithoutTeamNestedInput
    players?: TeamPlayerUpdateManyWithoutTeamNestedInput
  }

  export type TeamUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    budget?: FloatFieldUpdateOperationsInput | number
    totalPoints?: IntFieldUpdateOperationsInput | number
    formation?: StringFieldUpdateOperationsInput | string
    status?: EnumTeamStatusFieldUpdateOperationsInput | $Enums.TeamStatus
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    players?: TeamPlayerUncheckedUpdateManyWithoutTeamNestedInput
  }

  export type TeamCreateManyInput = {
    id?: string
    name: string
    userId: string
    budget?: number
    totalPoints?: number
    formation?: string
    status?: $Enums.TeamStatus
    createdAt?: Date | string
  }

  export type TeamUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    budget?: FloatFieldUpdateOperationsInput | number
    totalPoints?: IntFieldUpdateOperationsInput | number
    formation?: StringFieldUpdateOperationsInput | string
    status?: EnumTeamStatusFieldUpdateOperationsInput | $Enums.TeamStatus
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type TeamUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    budget?: FloatFieldUpdateOperationsInput | number
    totalPoints?: IntFieldUpdateOperationsInput | number
    formation?: StringFieldUpdateOperationsInput | string
    status?: EnumTeamStatusFieldUpdateOperationsInput | $Enums.TeamStatus
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type TeamPlayerCreateInput = {
    isCaptain?: boolean
    isViceCaptain?: boolean
    isBench?: boolean
    positionIndex?: number
    team: TeamCreateNestedOneWithoutPlayersInput
    player: PlayerCreateNestedOneWithoutTeamPlayersInput
    goldenCard?: GoldenCardCreateNestedOneWithoutTeamPlayerInput
  }

  export type TeamPlayerUncheckedCreateInput = {
    teamId: string
    playerId: string
    goldenCardId?: string | null
    isCaptain?: boolean
    isViceCaptain?: boolean
    isBench?: boolean
    positionIndex?: number
  }

  export type TeamPlayerUpdateInput = {
    isCaptain?: BoolFieldUpdateOperationsInput | boolean
    isViceCaptain?: BoolFieldUpdateOperationsInput | boolean
    isBench?: BoolFieldUpdateOperationsInput | boolean
    positionIndex?: IntFieldUpdateOperationsInput | number
    team?: TeamUpdateOneRequiredWithoutPlayersNestedInput
    player?: PlayerUpdateOneRequiredWithoutTeamPlayersNestedInput
    goldenCard?: GoldenCardUpdateOneWithoutTeamPlayerNestedInput
  }

  export type TeamPlayerUncheckedUpdateInput = {
    teamId?: StringFieldUpdateOperationsInput | string
    playerId?: StringFieldUpdateOperationsInput | string
    goldenCardId?: NullableStringFieldUpdateOperationsInput | string | null
    isCaptain?: BoolFieldUpdateOperationsInput | boolean
    isViceCaptain?: BoolFieldUpdateOperationsInput | boolean
    isBench?: BoolFieldUpdateOperationsInput | boolean
    positionIndex?: IntFieldUpdateOperationsInput | number
  }

  export type TeamPlayerCreateManyInput = {
    teamId: string
    playerId: string
    goldenCardId?: string | null
    isCaptain?: boolean
    isViceCaptain?: boolean
    isBench?: boolean
    positionIndex?: number
  }

  export type TeamPlayerUpdateManyMutationInput = {
    isCaptain?: BoolFieldUpdateOperationsInput | boolean
    isViceCaptain?: BoolFieldUpdateOperationsInput | boolean
    isBench?: BoolFieldUpdateOperationsInput | boolean
    positionIndex?: IntFieldUpdateOperationsInput | number
  }

  export type TeamPlayerUncheckedUpdateManyInput = {
    teamId?: StringFieldUpdateOperationsInput | string
    playerId?: StringFieldUpdateOperationsInput | string
    goldenCardId?: NullableStringFieldUpdateOperationsInput | string | null
    isCaptain?: BoolFieldUpdateOperationsInput | boolean
    isViceCaptain?: BoolFieldUpdateOperationsInput | boolean
    isBench?: BoolFieldUpdateOperationsInput | boolean
    positionIndex?: IntFieldUpdateOperationsInput | number
  }

  export type PackageCreateInput = {
    id?: string
    name: string
    budgetBonus: number
    price: number
    description?: string | null
    isActive?: boolean
    payments?: PaymentCreateNestedManyWithoutPackageInput
  }

  export type PackageUncheckedCreateInput = {
    id?: string
    name: string
    budgetBonus: number
    price: number
    description?: string | null
    isActive?: boolean
    payments?: PaymentUncheckedCreateNestedManyWithoutPackageInput
  }

  export type PackageUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    budgetBonus?: FloatFieldUpdateOperationsInput | number
    price?: IntFieldUpdateOperationsInput | number
    description?: NullableStringFieldUpdateOperationsInput | string | null
    isActive?: BoolFieldUpdateOperationsInput | boolean
    payments?: PaymentUpdateManyWithoutPackageNestedInput
  }

  export type PackageUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    budgetBonus?: FloatFieldUpdateOperationsInput | number
    price?: IntFieldUpdateOperationsInput | number
    description?: NullableStringFieldUpdateOperationsInput | string | null
    isActive?: BoolFieldUpdateOperationsInput | boolean
    payments?: PaymentUncheckedUpdateManyWithoutPackageNestedInput
  }

  export type PackageCreateManyInput = {
    id?: string
    name: string
    budgetBonus: number
    price: number
    description?: string | null
    isActive?: boolean
  }

  export type PackageUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    budgetBonus?: FloatFieldUpdateOperationsInput | number
    price?: IntFieldUpdateOperationsInput | number
    description?: NullableStringFieldUpdateOperationsInput | string | null
    isActive?: BoolFieldUpdateOperationsInput | boolean
  }

  export type PackageUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    budgetBonus?: FloatFieldUpdateOperationsInput | number
    price?: IntFieldUpdateOperationsInput | number
    description?: NullableStringFieldUpdateOperationsInput | string | null
    isActive?: BoolFieldUpdateOperationsInput | boolean
  }

  export type PaymentCreateInput = {
    id?: string
    amount: number
    authority?: string | null
    refId?: string | null
    status?: $Enums.PaymentStatus
    createdAt?: Date | string
    updatedAt?: Date | string
    user: UserCreateNestedOneWithoutPaymentsInput
    package: PackageCreateNestedOneWithoutPaymentsInput
  }

  export type PaymentUncheckedCreateInput = {
    id?: string
    userId: string
    packageId: string
    amount: number
    authority?: string | null
    refId?: string | null
    status?: $Enums.PaymentStatus
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type PaymentUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    amount?: IntFieldUpdateOperationsInput | number
    authority?: NullableStringFieldUpdateOperationsInput | string | null
    refId?: NullableStringFieldUpdateOperationsInput | string | null
    status?: EnumPaymentStatusFieldUpdateOperationsInput | $Enums.PaymentStatus
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    user?: UserUpdateOneRequiredWithoutPaymentsNestedInput
    package?: PackageUpdateOneRequiredWithoutPaymentsNestedInput
  }

  export type PaymentUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    packageId?: StringFieldUpdateOperationsInput | string
    amount?: IntFieldUpdateOperationsInput | number
    authority?: NullableStringFieldUpdateOperationsInput | string | null
    refId?: NullableStringFieldUpdateOperationsInput | string | null
    status?: EnumPaymentStatusFieldUpdateOperationsInput | $Enums.PaymentStatus
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type PaymentCreateManyInput = {
    id?: string
    userId: string
    packageId: string
    amount: number
    authority?: string | null
    refId?: string | null
    status?: $Enums.PaymentStatus
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type PaymentUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    amount?: IntFieldUpdateOperationsInput | number
    authority?: NullableStringFieldUpdateOperationsInput | string | null
    refId?: NullableStringFieldUpdateOperationsInput | string | null
    status?: EnumPaymentStatusFieldUpdateOperationsInput | $Enums.PaymentStatus
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type PaymentUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    packageId?: StringFieldUpdateOperationsInput | string
    amount?: IntFieldUpdateOperationsInput | number
    authority?: NullableStringFieldUpdateOperationsInput | string | null
    refId?: NullableStringFieldUpdateOperationsInput | string | null
    status?: EnumPaymentStatusFieldUpdateOperationsInput | $Enums.PaymentStatus
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type StringFilter<$PrismaModel = never> = {
    equals?: string | StringFieldRefInput<$PrismaModel>
    in?: string[] | ListStringFieldRefInput<$PrismaModel>
    notIn?: string[] | ListStringFieldRefInput<$PrismaModel>
    lt?: string | StringFieldRefInput<$PrismaModel>
    lte?: string | StringFieldRefInput<$PrismaModel>
    gt?: string | StringFieldRefInput<$PrismaModel>
    gte?: string | StringFieldRefInput<$PrismaModel>
    contains?: string | StringFieldRefInput<$PrismaModel>
    startsWith?: string | StringFieldRefInput<$PrismaModel>
    endsWith?: string | StringFieldRefInput<$PrismaModel>
    mode?: QueryMode
    not?: NestedStringFilter<$PrismaModel> | string
  }

  export type StringNullableFilter<$PrismaModel = never> = {
    equals?: string | StringFieldRefInput<$PrismaModel> | null
    in?: string[] | ListStringFieldRefInput<$PrismaModel> | null
    notIn?: string[] | ListStringFieldRefInput<$PrismaModel> | null
    lt?: string | StringFieldRefInput<$PrismaModel>
    lte?: string | StringFieldRefInput<$PrismaModel>
    gt?: string | StringFieldRefInput<$PrismaModel>
    gte?: string | StringFieldRefInput<$PrismaModel>
    contains?: string | StringFieldRefInput<$PrismaModel>
    startsWith?: string | StringFieldRefInput<$PrismaModel>
    endsWith?: string | StringFieldRefInput<$PrismaModel>
    mode?: QueryMode
    not?: NestedStringNullableFilter<$PrismaModel> | string | null
  }

  export type StringNullableListFilter<$PrismaModel = never> = {
    equals?: string[] | ListStringFieldRefInput<$PrismaModel> | null
    has?: string | StringFieldRefInput<$PrismaModel> | null
    hasEvery?: string[] | ListStringFieldRefInput<$PrismaModel>
    hasSome?: string[] | ListStringFieldRefInput<$PrismaModel>
    isEmpty?: boolean
  }

  export type BoolFilter<$PrismaModel = never> = {
    equals?: boolean | BooleanFieldRefInput<$PrismaModel>
    not?: NestedBoolFilter<$PrismaModel> | boolean
  }

  export type GroupNullableScalarRelationFilter = {
    is?: GroupWhereInput | null
    isNot?: GroupWhereInput | null
  }

  export type PlayerListRelationFilter = {
    every?: PlayerWhereInput
    some?: PlayerWhereInput
    none?: PlayerWhereInput
  }

  export type MatchListRelationFilter = {
    every?: MatchWhereInput
    some?: MatchWhereInput
    none?: MatchWhereInput
  }

  export type SortOrderInput = {
    sort: SortOrder
    nulls?: NullsOrder
  }

  export type PlayerOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type MatchOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type CountryCountOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    code?: SortOrder
    flagUrl?: SortOrder
    flagImage?: SortOrder
    confederation?: SortOrder
    qualificationMethod?: SortOrder
    qualificationDate?: SortOrder
    participationHistory?: SortOrder
    bestResult?: SortOrder
    description?: SortOrder
    defaultFormation?: SortOrder
    defaultLineupPlayerIds?: SortOrder
    defaultCaptainId?: SortOrder
    groupId?: SortOrder
    isEliminated?: SortOrder
  }

  export type CountryMaxOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    code?: SortOrder
    flagUrl?: SortOrder
    flagImage?: SortOrder
    confederation?: SortOrder
    qualificationMethod?: SortOrder
    qualificationDate?: SortOrder
    participationHistory?: SortOrder
    bestResult?: SortOrder
    description?: SortOrder
    defaultFormation?: SortOrder
    defaultCaptainId?: SortOrder
    groupId?: SortOrder
    isEliminated?: SortOrder
  }

  export type CountryMinOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    code?: SortOrder
    flagUrl?: SortOrder
    flagImage?: SortOrder
    confederation?: SortOrder
    qualificationMethod?: SortOrder
    qualificationDate?: SortOrder
    participationHistory?: SortOrder
    bestResult?: SortOrder
    description?: SortOrder
    defaultFormation?: SortOrder
    defaultCaptainId?: SortOrder
    groupId?: SortOrder
    isEliminated?: SortOrder
  }

  export type StringWithAggregatesFilter<$PrismaModel = never> = {
    equals?: string | StringFieldRefInput<$PrismaModel>
    in?: string[] | ListStringFieldRefInput<$PrismaModel>
    notIn?: string[] | ListStringFieldRefInput<$PrismaModel>
    lt?: string | StringFieldRefInput<$PrismaModel>
    lte?: string | StringFieldRefInput<$PrismaModel>
    gt?: string | StringFieldRefInput<$PrismaModel>
    gte?: string | StringFieldRefInput<$PrismaModel>
    contains?: string | StringFieldRefInput<$PrismaModel>
    startsWith?: string | StringFieldRefInput<$PrismaModel>
    endsWith?: string | StringFieldRefInput<$PrismaModel>
    mode?: QueryMode
    not?: NestedStringWithAggregatesFilter<$PrismaModel> | string
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedStringFilter<$PrismaModel>
    _max?: NestedStringFilter<$PrismaModel>
  }

  export type StringNullableWithAggregatesFilter<$PrismaModel = never> = {
    equals?: string | StringFieldRefInput<$PrismaModel> | null
    in?: string[] | ListStringFieldRefInput<$PrismaModel> | null
    notIn?: string[] | ListStringFieldRefInput<$PrismaModel> | null
    lt?: string | StringFieldRefInput<$PrismaModel>
    lte?: string | StringFieldRefInput<$PrismaModel>
    gt?: string | StringFieldRefInput<$PrismaModel>
    gte?: string | StringFieldRefInput<$PrismaModel>
    contains?: string | StringFieldRefInput<$PrismaModel>
    startsWith?: string | StringFieldRefInput<$PrismaModel>
    endsWith?: string | StringFieldRefInput<$PrismaModel>
    mode?: QueryMode
    not?: NestedStringNullableWithAggregatesFilter<$PrismaModel> | string | null
    _count?: NestedIntNullableFilter<$PrismaModel>
    _min?: NestedStringNullableFilter<$PrismaModel>
    _max?: NestedStringNullableFilter<$PrismaModel>
  }

  export type BoolWithAggregatesFilter<$PrismaModel = never> = {
    equals?: boolean | BooleanFieldRefInput<$PrismaModel>
    not?: NestedBoolWithAggregatesFilter<$PrismaModel> | boolean
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedBoolFilter<$PrismaModel>
    _max?: NestedBoolFilter<$PrismaModel>
  }

  export type CountryListRelationFilter = {
    every?: CountryWhereInput
    some?: CountryWhereInput
    none?: CountryWhereInput
  }

  export type CountryOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type GroupCountOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
  }

  export type GroupMaxOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
  }

  export type GroupMinOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
  }

  export type EnumPositionFilter<$PrismaModel = never> = {
    equals?: $Enums.Position | EnumPositionFieldRefInput<$PrismaModel>
    in?: $Enums.Position[] | ListEnumPositionFieldRefInput<$PrismaModel>
    notIn?: $Enums.Position[] | ListEnumPositionFieldRefInput<$PrismaModel>
    not?: NestedEnumPositionFilter<$PrismaModel> | $Enums.Position
  }

  export type FloatFilter<$PrismaModel = never> = {
    equals?: number | FloatFieldRefInput<$PrismaModel>
    in?: number[] | ListFloatFieldRefInput<$PrismaModel>
    notIn?: number[] | ListFloatFieldRefInput<$PrismaModel>
    lt?: number | FloatFieldRefInput<$PrismaModel>
    lte?: number | FloatFieldRefInput<$PrismaModel>
    gt?: number | FloatFieldRefInput<$PrismaModel>
    gte?: number | FloatFieldRefInput<$PrismaModel>
    not?: NestedFloatFilter<$PrismaModel> | number
  }

  export type IntFilter<$PrismaModel = never> = {
    equals?: number | IntFieldRefInput<$PrismaModel>
    in?: number[] | ListIntFieldRefInput<$PrismaModel>
    notIn?: number[] | ListIntFieldRefInput<$PrismaModel>
    lt?: number | IntFieldRefInput<$PrismaModel>
    lte?: number | IntFieldRefInput<$PrismaModel>
    gt?: number | IntFieldRefInput<$PrismaModel>
    gte?: number | IntFieldRefInput<$PrismaModel>
    not?: NestedIntFilter<$PrismaModel> | number
  }

  export type EnumCardTierFilter<$PrismaModel = never> = {
    equals?: $Enums.CardTier | EnumCardTierFieldRefInput<$PrismaModel>
    in?: $Enums.CardTier[] | ListEnumCardTierFieldRefInput<$PrismaModel>
    notIn?: $Enums.CardTier[] | ListEnumCardTierFieldRefInput<$PrismaModel>
    not?: NestedEnumCardTierFilter<$PrismaModel> | $Enums.CardTier
  }

  export type DateTimeFilter<$PrismaModel = never> = {
    equals?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    in?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel>
    notIn?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel>
    lt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    lte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    not?: NestedDateTimeFilter<$PrismaModel> | Date | string
  }

  export type CountryScalarRelationFilter = {
    is?: CountryWhereInput
    isNot?: CountryWhereInput
  }

  export type PlayerMatchStatListRelationFilter = {
    every?: PlayerMatchStatWhereInput
    some?: PlayerMatchStatWhereInput
    none?: PlayerMatchStatWhereInput
  }

  export type TeamPlayerListRelationFilter = {
    every?: TeamPlayerWhereInput
    some?: TeamPlayerWhereInput
    none?: TeamPlayerWhereInput
  }

  export type MatchEventListRelationFilter = {
    every?: MatchEventWhereInput
    some?: MatchEventWhereInput
    none?: MatchEventWhereInput
  }

  export type GoldenCardListRelationFilter = {
    every?: GoldenCardWhereInput
    some?: GoldenCardWhereInput
    none?: GoldenCardWhereInput
  }

  export type PlayerMatchStatOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type TeamPlayerOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type MatchEventOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type GoldenCardOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type PlayerCountOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    image?: SortOrder
    position?: SortOrder
    countryId?: SortOrder
    price?: SortOrder
    totalPoints?: SortOrder
    isActive?: SortOrder
    isGoldenCardEligible?: SortOrder
    cardTier?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type PlayerAvgOrderByAggregateInput = {
    price?: SortOrder
    totalPoints?: SortOrder
  }

  export type PlayerMaxOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    image?: SortOrder
    position?: SortOrder
    countryId?: SortOrder
    price?: SortOrder
    totalPoints?: SortOrder
    isActive?: SortOrder
    isGoldenCardEligible?: SortOrder
    cardTier?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type PlayerMinOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    image?: SortOrder
    position?: SortOrder
    countryId?: SortOrder
    price?: SortOrder
    totalPoints?: SortOrder
    isActive?: SortOrder
    isGoldenCardEligible?: SortOrder
    cardTier?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type PlayerSumOrderByAggregateInput = {
    price?: SortOrder
    totalPoints?: SortOrder
  }

  export type EnumPositionWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.Position | EnumPositionFieldRefInput<$PrismaModel>
    in?: $Enums.Position[] | ListEnumPositionFieldRefInput<$PrismaModel>
    notIn?: $Enums.Position[] | ListEnumPositionFieldRefInput<$PrismaModel>
    not?: NestedEnumPositionWithAggregatesFilter<$PrismaModel> | $Enums.Position
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumPositionFilter<$PrismaModel>
    _max?: NestedEnumPositionFilter<$PrismaModel>
  }

  export type FloatWithAggregatesFilter<$PrismaModel = never> = {
    equals?: number | FloatFieldRefInput<$PrismaModel>
    in?: number[] | ListFloatFieldRefInput<$PrismaModel>
    notIn?: number[] | ListFloatFieldRefInput<$PrismaModel>
    lt?: number | FloatFieldRefInput<$PrismaModel>
    lte?: number | FloatFieldRefInput<$PrismaModel>
    gt?: number | FloatFieldRefInput<$PrismaModel>
    gte?: number | FloatFieldRefInput<$PrismaModel>
    not?: NestedFloatWithAggregatesFilter<$PrismaModel> | number
    _count?: NestedIntFilter<$PrismaModel>
    _avg?: NestedFloatFilter<$PrismaModel>
    _sum?: NestedFloatFilter<$PrismaModel>
    _min?: NestedFloatFilter<$PrismaModel>
    _max?: NestedFloatFilter<$PrismaModel>
  }

  export type IntWithAggregatesFilter<$PrismaModel = never> = {
    equals?: number | IntFieldRefInput<$PrismaModel>
    in?: number[] | ListIntFieldRefInput<$PrismaModel>
    notIn?: number[] | ListIntFieldRefInput<$PrismaModel>
    lt?: number | IntFieldRefInput<$PrismaModel>
    lte?: number | IntFieldRefInput<$PrismaModel>
    gt?: number | IntFieldRefInput<$PrismaModel>
    gte?: number | IntFieldRefInput<$PrismaModel>
    not?: NestedIntWithAggregatesFilter<$PrismaModel> | number
    _count?: NestedIntFilter<$PrismaModel>
    _avg?: NestedFloatFilter<$PrismaModel>
    _sum?: NestedIntFilter<$PrismaModel>
    _min?: NestedIntFilter<$PrismaModel>
    _max?: NestedIntFilter<$PrismaModel>
  }

  export type EnumCardTierWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.CardTier | EnumCardTierFieldRefInput<$PrismaModel>
    in?: $Enums.CardTier[] | ListEnumCardTierFieldRefInput<$PrismaModel>
    notIn?: $Enums.CardTier[] | ListEnumCardTierFieldRefInput<$PrismaModel>
    not?: NestedEnumCardTierWithAggregatesFilter<$PrismaModel> | $Enums.CardTier
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumCardTierFilter<$PrismaModel>
    _max?: NestedEnumCardTierFilter<$PrismaModel>
  }

  export type DateTimeWithAggregatesFilter<$PrismaModel = never> = {
    equals?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    in?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel>
    notIn?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel>
    lt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    lte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    not?: NestedDateTimeWithAggregatesFilter<$PrismaModel> | Date | string
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedDateTimeFilter<$PrismaModel>
    _max?: NestedDateTimeFilter<$PrismaModel>
  }

  export type IntNullableFilter<$PrismaModel = never> = {
    equals?: number | IntFieldRefInput<$PrismaModel> | null
    in?: number[] | ListIntFieldRefInput<$PrismaModel> | null
    notIn?: number[] | ListIntFieldRefInput<$PrismaModel> | null
    lt?: number | IntFieldRefInput<$PrismaModel>
    lte?: number | IntFieldRefInput<$PrismaModel>
    gt?: number | IntFieldRefInput<$PrismaModel>
    gte?: number | IntFieldRefInput<$PrismaModel>
    not?: NestedIntNullableFilter<$PrismaModel> | number | null
  }

  export type EnumMatchStageFilter<$PrismaModel = never> = {
    equals?: $Enums.MatchStage | EnumMatchStageFieldRefInput<$PrismaModel>
    in?: $Enums.MatchStage[] | ListEnumMatchStageFieldRefInput<$PrismaModel>
    notIn?: $Enums.MatchStage[] | ListEnumMatchStageFieldRefInput<$PrismaModel>
    not?: NestedEnumMatchStageFilter<$PrismaModel> | $Enums.MatchStage
  }

  export type EnumMatchStatusFilter<$PrismaModel = never> = {
    equals?: $Enums.MatchStatus | EnumMatchStatusFieldRefInput<$PrismaModel>
    in?: $Enums.MatchStatus[] | ListEnumMatchStatusFieldRefInput<$PrismaModel>
    notIn?: $Enums.MatchStatus[] | ListEnumMatchStatusFieldRefInput<$PrismaModel>
    not?: NestedEnumMatchStatusFilter<$PrismaModel> | $Enums.MatchStatus
  }

  export type RoundNullableScalarRelationFilter = {
    is?: RoundWhereInput | null
    isNot?: RoundWhereInput | null
  }

  export type MatchLineupListRelationFilter = {
    every?: MatchLineupWhereInput
    some?: MatchLineupWhereInput
    none?: MatchLineupWhereInput
  }

  export type MatchLineupOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type MatchCountOrderByAggregateInput = {
    id?: SortOrder
    homeTeamId?: SortOrder
    awayTeamId?: SortOrder
    homeScore?: SortOrder
    awayScore?: SortOrder
    stage?: SortOrder
    status?: SortOrder
    matchDate?: SortOrder
    matchDatePersian?: SortOrder
    stadium?: SortOrder
    city?: SortOrder
    referee?: SortOrder
    assistant1?: SortOrder
    assistant2?: SortOrder
    fourthOfficial?: SortOrder
    attendance?: SortOrder
    weather?: SortOrder
    description?: SortOrder
    roundId?: SortOrder
    createdAt?: SortOrder
  }

  export type MatchAvgOrderByAggregateInput = {
    homeScore?: SortOrder
    awayScore?: SortOrder
    attendance?: SortOrder
  }

  export type MatchMaxOrderByAggregateInput = {
    id?: SortOrder
    homeTeamId?: SortOrder
    awayTeamId?: SortOrder
    homeScore?: SortOrder
    awayScore?: SortOrder
    stage?: SortOrder
    status?: SortOrder
    matchDate?: SortOrder
    matchDatePersian?: SortOrder
    stadium?: SortOrder
    city?: SortOrder
    referee?: SortOrder
    assistant1?: SortOrder
    assistant2?: SortOrder
    fourthOfficial?: SortOrder
    attendance?: SortOrder
    weather?: SortOrder
    description?: SortOrder
    roundId?: SortOrder
    createdAt?: SortOrder
  }

  export type MatchMinOrderByAggregateInput = {
    id?: SortOrder
    homeTeamId?: SortOrder
    awayTeamId?: SortOrder
    homeScore?: SortOrder
    awayScore?: SortOrder
    stage?: SortOrder
    status?: SortOrder
    matchDate?: SortOrder
    matchDatePersian?: SortOrder
    stadium?: SortOrder
    city?: SortOrder
    referee?: SortOrder
    assistant1?: SortOrder
    assistant2?: SortOrder
    fourthOfficial?: SortOrder
    attendance?: SortOrder
    weather?: SortOrder
    description?: SortOrder
    roundId?: SortOrder
    createdAt?: SortOrder
  }

  export type MatchSumOrderByAggregateInput = {
    homeScore?: SortOrder
    awayScore?: SortOrder
    attendance?: SortOrder
  }

  export type IntNullableWithAggregatesFilter<$PrismaModel = never> = {
    equals?: number | IntFieldRefInput<$PrismaModel> | null
    in?: number[] | ListIntFieldRefInput<$PrismaModel> | null
    notIn?: number[] | ListIntFieldRefInput<$PrismaModel> | null
    lt?: number | IntFieldRefInput<$PrismaModel>
    lte?: number | IntFieldRefInput<$PrismaModel>
    gt?: number | IntFieldRefInput<$PrismaModel>
    gte?: number | IntFieldRefInput<$PrismaModel>
    not?: NestedIntNullableWithAggregatesFilter<$PrismaModel> | number | null
    _count?: NestedIntNullableFilter<$PrismaModel>
    _avg?: NestedFloatNullableFilter<$PrismaModel>
    _sum?: NestedIntNullableFilter<$PrismaModel>
    _min?: NestedIntNullableFilter<$PrismaModel>
    _max?: NestedIntNullableFilter<$PrismaModel>
  }

  export type EnumMatchStageWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.MatchStage | EnumMatchStageFieldRefInput<$PrismaModel>
    in?: $Enums.MatchStage[] | ListEnumMatchStageFieldRefInput<$PrismaModel>
    notIn?: $Enums.MatchStage[] | ListEnumMatchStageFieldRefInput<$PrismaModel>
    not?: NestedEnumMatchStageWithAggregatesFilter<$PrismaModel> | $Enums.MatchStage
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumMatchStageFilter<$PrismaModel>
    _max?: NestedEnumMatchStageFilter<$PrismaModel>
  }

  export type EnumMatchStatusWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.MatchStatus | EnumMatchStatusFieldRefInput<$PrismaModel>
    in?: $Enums.MatchStatus[] | ListEnumMatchStatusFieldRefInput<$PrismaModel>
    notIn?: $Enums.MatchStatus[] | ListEnumMatchStatusFieldRefInput<$PrismaModel>
    not?: NestedEnumMatchStatusWithAggregatesFilter<$PrismaModel> | $Enums.MatchStatus
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumMatchStatusFilter<$PrismaModel>
    _max?: NestedEnumMatchStatusFilter<$PrismaModel>
  }

  export type RoundCountOrderByAggregateInput = {
    id?: SortOrder
    number?: SortOrder
    name?: SortOrder
    isActive?: SortOrder
    deadline?: SortOrder
    createdAt?: SortOrder
  }

  export type RoundAvgOrderByAggregateInput = {
    number?: SortOrder
  }

  export type RoundMaxOrderByAggregateInput = {
    id?: SortOrder
    number?: SortOrder
    name?: SortOrder
    isActive?: SortOrder
    deadline?: SortOrder
    createdAt?: SortOrder
  }

  export type RoundMinOrderByAggregateInput = {
    id?: SortOrder
    number?: SortOrder
    name?: SortOrder
    isActive?: SortOrder
    deadline?: SortOrder
    createdAt?: SortOrder
  }

  export type RoundSumOrderByAggregateInput = {
    number?: SortOrder
  }

  export type GameweekCountOrderByAggregateInput = {
    id?: SortOrder
    number?: SortOrder
    name?: SortOrder
    isActive?: SortOrder
    deadline?: SortOrder
    createdAt?: SortOrder
  }

  export type GameweekAvgOrderByAggregateInput = {
    number?: SortOrder
  }

  export type GameweekMaxOrderByAggregateInput = {
    id?: SortOrder
    number?: SortOrder
    name?: SortOrder
    isActive?: SortOrder
    deadline?: SortOrder
    createdAt?: SortOrder
  }

  export type GameweekMinOrderByAggregateInput = {
    id?: SortOrder
    number?: SortOrder
    name?: SortOrder
    isActive?: SortOrder
    deadline?: SortOrder
    createdAt?: SortOrder
  }

  export type GameweekSumOrderByAggregateInput = {
    number?: SortOrder
  }

  export type EnumEventTypeFilter<$PrismaModel = never> = {
    equals?: $Enums.EventType | EnumEventTypeFieldRefInput<$PrismaModel>
    in?: $Enums.EventType[] | ListEnumEventTypeFieldRefInput<$PrismaModel>
    notIn?: $Enums.EventType[] | ListEnumEventTypeFieldRefInput<$PrismaModel>
    not?: NestedEnumEventTypeFilter<$PrismaModel> | $Enums.EventType
  }

  export type MatchScalarRelationFilter = {
    is?: MatchWhereInput
    isNot?: MatchWhereInput
  }

  export type PlayerScalarRelationFilter = {
    is?: PlayerWhereInput
    isNot?: PlayerWhereInput
  }

  export type MatchEventCountOrderByAggregateInput = {
    id?: SortOrder
    matchId?: SortOrder
    playerId?: SortOrder
    type?: SortOrder
    minute?: SortOrder
    extraInfo?: SortOrder
    createdAt?: SortOrder
  }

  export type MatchEventAvgOrderByAggregateInput = {
    minute?: SortOrder
  }

  export type MatchEventMaxOrderByAggregateInput = {
    id?: SortOrder
    matchId?: SortOrder
    playerId?: SortOrder
    type?: SortOrder
    minute?: SortOrder
    extraInfo?: SortOrder
    createdAt?: SortOrder
  }

  export type MatchEventMinOrderByAggregateInput = {
    id?: SortOrder
    matchId?: SortOrder
    playerId?: SortOrder
    type?: SortOrder
    minute?: SortOrder
    extraInfo?: SortOrder
    createdAt?: SortOrder
  }

  export type MatchEventSumOrderByAggregateInput = {
    minute?: SortOrder
  }

  export type EnumEventTypeWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.EventType | EnumEventTypeFieldRefInput<$PrismaModel>
    in?: $Enums.EventType[] | ListEnumEventTypeFieldRefInput<$PrismaModel>
    notIn?: $Enums.EventType[] | ListEnumEventTypeFieldRefInput<$PrismaModel>
    not?: NestedEnumEventTypeWithAggregatesFilter<$PrismaModel> | $Enums.EventType
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumEventTypeFilter<$PrismaModel>
    _max?: NestedEnumEventTypeFilter<$PrismaModel>
  }

  export type MatchLineupCountOrderByAggregateInput = {
    id?: SortOrder
    matchId?: SortOrder
    countryId?: SortOrder
    formation?: SortOrder
    playerIds?: SortOrder
  }

  export type MatchLineupMaxOrderByAggregateInput = {
    id?: SortOrder
    matchId?: SortOrder
    countryId?: SortOrder
    formation?: SortOrder
  }

  export type MatchLineupMinOrderByAggregateInput = {
    id?: SortOrder
    matchId?: SortOrder
    countryId?: SortOrder
    formation?: SortOrder
  }

  export type PlayerMatchStatPlayerIdMatchIdCompoundUniqueInput = {
    playerId: string
    matchId: string
  }

  export type PlayerMatchStatCountOrderByAggregateInput = {
    id?: SortOrder
    playerId?: SortOrder
    matchId?: SortOrder
    goals?: SortOrder
    assists?: SortOrder
    yellowCards?: SortOrder
    redCards?: SortOrder
    minutesPlayed?: SortOrder
    cleanSheet?: SortOrder
    penaltySaved?: SortOrder
    penaltyMissed?: SortOrder
    ownGoals?: SortOrder
    isMotm?: SortOrder
    extraTimeBonus?: SortOrder
    points?: SortOrder
  }

  export type PlayerMatchStatAvgOrderByAggregateInput = {
    goals?: SortOrder
    assists?: SortOrder
    yellowCards?: SortOrder
    redCards?: SortOrder
    minutesPlayed?: SortOrder
    penaltySaved?: SortOrder
    penaltyMissed?: SortOrder
    ownGoals?: SortOrder
    extraTimeBonus?: SortOrder
    points?: SortOrder
  }

  export type PlayerMatchStatMaxOrderByAggregateInput = {
    id?: SortOrder
    playerId?: SortOrder
    matchId?: SortOrder
    goals?: SortOrder
    assists?: SortOrder
    yellowCards?: SortOrder
    redCards?: SortOrder
    minutesPlayed?: SortOrder
    cleanSheet?: SortOrder
    penaltySaved?: SortOrder
    penaltyMissed?: SortOrder
    ownGoals?: SortOrder
    isMotm?: SortOrder
    extraTimeBonus?: SortOrder
    points?: SortOrder
  }

  export type PlayerMatchStatMinOrderByAggregateInput = {
    id?: SortOrder
    playerId?: SortOrder
    matchId?: SortOrder
    goals?: SortOrder
    assists?: SortOrder
    yellowCards?: SortOrder
    redCards?: SortOrder
    minutesPlayed?: SortOrder
    cleanSheet?: SortOrder
    penaltySaved?: SortOrder
    penaltyMissed?: SortOrder
    ownGoals?: SortOrder
    isMotm?: SortOrder
    extraTimeBonus?: SortOrder
    points?: SortOrder
  }

  export type PlayerMatchStatSumOrderByAggregateInput = {
    goals?: SortOrder
    assists?: SortOrder
    yellowCards?: SortOrder
    redCards?: SortOrder
    minutesPlayed?: SortOrder
    penaltySaved?: SortOrder
    penaltyMissed?: SortOrder
    ownGoals?: SortOrder
    extraTimeBonus?: SortOrder
    points?: SortOrder
  }

  export type ScoringRulePositionEventTypeCompoundUniqueInput = {
    position: $Enums.Position
    eventType: $Enums.EventType
  }

  export type ScoringRuleCountOrderByAggregateInput = {
    id?: SortOrder
    position?: SortOrder
    eventType?: SortOrder
    points?: SortOrder
    updatedAt?: SortOrder
    updatedBy?: SortOrder
  }

  export type ScoringRuleAvgOrderByAggregateInput = {
    points?: SortOrder
  }

  export type ScoringRuleMaxOrderByAggregateInput = {
    id?: SortOrder
    position?: SortOrder
    eventType?: SortOrder
    points?: SortOrder
    updatedAt?: SortOrder
    updatedBy?: SortOrder
  }

  export type ScoringRuleMinOrderByAggregateInput = {
    id?: SortOrder
    position?: SortOrder
    eventType?: SortOrder
    points?: SortOrder
    updatedAt?: SortOrder
    updatedBy?: SortOrder
  }

  export type ScoringRuleSumOrderByAggregateInput = {
    points?: SortOrder
  }

  export type EnumRoleFilter<$PrismaModel = never> = {
    equals?: $Enums.Role | EnumRoleFieldRefInput<$PrismaModel>
    in?: $Enums.Role[] | ListEnumRoleFieldRefInput<$PrismaModel>
    notIn?: $Enums.Role[] | ListEnumRoleFieldRefInput<$PrismaModel>
    not?: NestedEnumRoleFilter<$PrismaModel> | $Enums.Role
  }

  export type TeamNullableScalarRelationFilter = {
    is?: TeamWhereInput | null
    isNot?: TeamWhereInput | null
  }

  export type SessionListRelationFilter = {
    every?: SessionWhereInput
    some?: SessionWhereInput
    none?: SessionWhereInput
  }

  export type PaymentListRelationFilter = {
    every?: PaymentWhereInput
    some?: PaymentWhereInput
    none?: PaymentWhereInput
  }

  export type QuizSubmissionListRelationFilter = {
    every?: QuizSubmissionWhereInput
    some?: QuizSubmissionWhereInput
    none?: QuizSubmissionWhereInput
  }

  export type SessionOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type PaymentOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type QuizSubmissionOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type UserCountOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    email?: SortOrder
    phone?: SortOrder
    password?: SortOrder
    role?: SortOrder
    createdAt?: SortOrder
  }

  export type UserMaxOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    email?: SortOrder
    phone?: SortOrder
    password?: SortOrder
    role?: SortOrder
    createdAt?: SortOrder
  }

  export type UserMinOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    email?: SortOrder
    phone?: SortOrder
    password?: SortOrder
    role?: SortOrder
    createdAt?: SortOrder
  }

  export type EnumRoleWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.Role | EnumRoleFieldRefInput<$PrismaModel>
    in?: $Enums.Role[] | ListEnumRoleFieldRefInput<$PrismaModel>
    notIn?: $Enums.Role[] | ListEnumRoleFieldRefInput<$PrismaModel>
    not?: NestedEnumRoleWithAggregatesFilter<$PrismaModel> | $Enums.Role
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumRoleFilter<$PrismaModel>
    _max?: NestedEnumRoleFilter<$PrismaModel>
  }

  export type DateTimeNullableFilter<$PrismaModel = never> = {
    equals?: Date | string | DateTimeFieldRefInput<$PrismaModel> | null
    in?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel> | null
    notIn?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel> | null
    lt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    lte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    not?: NestedDateTimeNullableFilter<$PrismaModel> | Date | string | null
  }

  export type LoginOtpCountOrderByAggregateInput = {
    id?: SortOrder
    phone?: SortOrder
    codeHash?: SortOrder
    attempts?: SortOrder
    expiresAt?: SortOrder
    consumedAt?: SortOrder
    createdAt?: SortOrder
  }

  export type LoginOtpAvgOrderByAggregateInput = {
    attempts?: SortOrder
  }

  export type LoginOtpMaxOrderByAggregateInput = {
    id?: SortOrder
    phone?: SortOrder
    codeHash?: SortOrder
    attempts?: SortOrder
    expiresAt?: SortOrder
    consumedAt?: SortOrder
    createdAt?: SortOrder
  }

  export type LoginOtpMinOrderByAggregateInput = {
    id?: SortOrder
    phone?: SortOrder
    codeHash?: SortOrder
    attempts?: SortOrder
    expiresAt?: SortOrder
    consumedAt?: SortOrder
    createdAt?: SortOrder
  }

  export type LoginOtpSumOrderByAggregateInput = {
    attempts?: SortOrder
  }

  export type DateTimeNullableWithAggregatesFilter<$PrismaModel = never> = {
    equals?: Date | string | DateTimeFieldRefInput<$PrismaModel> | null
    in?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel> | null
    notIn?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel> | null
    lt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    lte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    not?: NestedDateTimeNullableWithAggregatesFilter<$PrismaModel> | Date | string | null
    _count?: NestedIntNullableFilter<$PrismaModel>
    _min?: NestedDateTimeNullableFilter<$PrismaModel>
    _max?: NestedDateTimeNullableFilter<$PrismaModel>
  }

  export type FantasyNewsCountOrderByAggregateInput = {
    id?: SortOrder
    icon?: SortOrder
    title?: SortOrder
    description?: SortOrder
    newsTime?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type FantasyNewsMaxOrderByAggregateInput = {
    id?: SortOrder
    icon?: SortOrder
    title?: SortOrder
    description?: SortOrder
    newsTime?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type FantasyNewsMinOrderByAggregateInput = {
    id?: SortOrder
    icon?: SortOrder
    title?: SortOrder
    description?: SortOrder
    newsTime?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type QuizQuestionListRelationFilter = {
    every?: QuizQuestionWhereInput
    some?: QuizQuestionWhereInput
    none?: QuizQuestionWhereInput
  }

  export type QuizQuestionOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type DailyQuizCountOrderByAggregateInput = {
    id?: SortOrder
    date?: SortOrder
    windowStart?: SortOrder
    windowEnd?: SortOrder
    goldWinnersCount?: SortOrder
    silverWinnersCount?: SortOrder
    bronzeWinnersCount?: SortOrder
    goldMinCorrect?: SortOrder
    silverMinCorrect?: SortOrder
    bronzeMinCorrect?: SortOrder
    isProcessed?: SortOrder
    createdAt?: SortOrder
  }

  export type DailyQuizAvgOrderByAggregateInput = {
    goldWinnersCount?: SortOrder
    silverWinnersCount?: SortOrder
    bronzeWinnersCount?: SortOrder
    goldMinCorrect?: SortOrder
    silverMinCorrect?: SortOrder
    bronzeMinCorrect?: SortOrder
  }

  export type DailyQuizMaxOrderByAggregateInput = {
    id?: SortOrder
    date?: SortOrder
    windowStart?: SortOrder
    windowEnd?: SortOrder
    goldWinnersCount?: SortOrder
    silverWinnersCount?: SortOrder
    bronzeWinnersCount?: SortOrder
    goldMinCorrect?: SortOrder
    silverMinCorrect?: SortOrder
    bronzeMinCorrect?: SortOrder
    isProcessed?: SortOrder
    createdAt?: SortOrder
  }

  export type DailyQuizMinOrderByAggregateInput = {
    id?: SortOrder
    date?: SortOrder
    windowStart?: SortOrder
    windowEnd?: SortOrder
    goldWinnersCount?: SortOrder
    silverWinnersCount?: SortOrder
    bronzeWinnersCount?: SortOrder
    goldMinCorrect?: SortOrder
    silverMinCorrect?: SortOrder
    bronzeMinCorrect?: SortOrder
    isProcessed?: SortOrder
    createdAt?: SortOrder
  }

  export type DailyQuizSumOrderByAggregateInput = {
    goldWinnersCount?: SortOrder
    silverWinnersCount?: SortOrder
    bronzeWinnersCount?: SortOrder
    goldMinCorrect?: SortOrder
    silverMinCorrect?: SortOrder
    bronzeMinCorrect?: SortOrder
  }

  export type DailyQuizScalarRelationFilter = {
    is?: DailyQuizWhereInput
    isNot?: DailyQuizWhereInput
  }

  export type QuizQuestionCountOrderByAggregateInput = {
    id?: SortOrder
    quizId?: SortOrder
    questionText?: SortOrder
    options?: SortOrder
    correctAnswer?: SortOrder
    order?: SortOrder
  }

  export type QuizQuestionAvgOrderByAggregateInput = {
    correctAnswer?: SortOrder
    order?: SortOrder
  }

  export type QuizQuestionMaxOrderByAggregateInput = {
    id?: SortOrder
    quizId?: SortOrder
    questionText?: SortOrder
    correctAnswer?: SortOrder
    order?: SortOrder
  }

  export type QuizQuestionMinOrderByAggregateInput = {
    id?: SortOrder
    quizId?: SortOrder
    questionText?: SortOrder
    correctAnswer?: SortOrder
    order?: SortOrder
  }

  export type QuizQuestionSumOrderByAggregateInput = {
    correctAnswer?: SortOrder
    order?: SortOrder
  }

  export type IntNullableListFilter<$PrismaModel = never> = {
    equals?: number[] | ListIntFieldRefInput<$PrismaModel> | null
    has?: number | IntFieldRefInput<$PrismaModel> | null
    hasEvery?: number[] | ListIntFieldRefInput<$PrismaModel>
    hasSome?: number[] | ListIntFieldRefInput<$PrismaModel>
    isEmpty?: boolean
  }

  export type UserScalarRelationFilter = {
    is?: UserWhereInput
    isNot?: UserWhereInput
  }

  export type QuizSubmissionUserIdQuizIdCompoundUniqueInput = {
    userId: string
    quizId: string
  }

  export type QuizSubmissionCountOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    quizId?: SortOrder
    answers?: SortOrder
    correctAnswers?: SortOrder
    score?: SortOrder
    submittedAt?: SortOrder
  }

  export type QuizSubmissionAvgOrderByAggregateInput = {
    answers?: SortOrder
    correctAnswers?: SortOrder
    score?: SortOrder
  }

  export type QuizSubmissionMaxOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    quizId?: SortOrder
    correctAnswers?: SortOrder
    score?: SortOrder
    submittedAt?: SortOrder
  }

  export type QuizSubmissionMinOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    quizId?: SortOrder
    correctAnswers?: SortOrder
    score?: SortOrder
    submittedAt?: SortOrder
  }

  export type QuizSubmissionSumOrderByAggregateInput = {
    answers?: SortOrder
    correctAnswers?: SortOrder
    score?: SortOrder
  }

  export type EnumGoldenCardStatusFilter<$PrismaModel = never> = {
    equals?: $Enums.GoldenCardStatus | EnumGoldenCardStatusFieldRefInput<$PrismaModel>
    in?: $Enums.GoldenCardStatus[] | ListEnumGoldenCardStatusFieldRefInput<$PrismaModel>
    notIn?: $Enums.GoldenCardStatus[] | ListEnumGoldenCardStatusFieldRefInput<$PrismaModel>
    not?: NestedEnumGoldenCardStatusFilter<$PrismaModel> | $Enums.GoldenCardStatus
  }

  export type EnumSpecialCardStateFilter<$PrismaModel = never> = {
    equals?: $Enums.SpecialCardState | EnumSpecialCardStateFieldRefInput<$PrismaModel>
    in?: $Enums.SpecialCardState[] | ListEnumSpecialCardStateFieldRefInput<$PrismaModel>
    notIn?: $Enums.SpecialCardState[] | ListEnumSpecialCardStateFieldRefInput<$PrismaModel>
    not?: NestedEnumSpecialCardStateFilter<$PrismaModel> | $Enums.SpecialCardState
  }

  export type DailyQuizNullableScalarRelationFilter = {
    is?: DailyQuizWhereInput | null
    isNot?: DailyQuizWhereInput | null
  }

  export type TeamPlayerNullableScalarRelationFilter = {
    is?: TeamPlayerWhereInput | null
    isNot?: TeamPlayerWhereInput | null
  }

  export type GoldenCardCountOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    quizId?: SortOrder
    playerId?: SortOrder
    cardTier?: SortOrder
    status?: SortOrder
    state?: SortOrder
    acquiredDate?: SortOrder
    openedAt?: SortOrder
  }

  export type GoldenCardMaxOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    quizId?: SortOrder
    playerId?: SortOrder
    cardTier?: SortOrder
    status?: SortOrder
    state?: SortOrder
    acquiredDate?: SortOrder
    openedAt?: SortOrder
  }

  export type GoldenCardMinOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    quizId?: SortOrder
    playerId?: SortOrder
    cardTier?: SortOrder
    status?: SortOrder
    state?: SortOrder
    acquiredDate?: SortOrder
    openedAt?: SortOrder
  }

  export type EnumGoldenCardStatusWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.GoldenCardStatus | EnumGoldenCardStatusFieldRefInput<$PrismaModel>
    in?: $Enums.GoldenCardStatus[] | ListEnumGoldenCardStatusFieldRefInput<$PrismaModel>
    notIn?: $Enums.GoldenCardStatus[] | ListEnumGoldenCardStatusFieldRefInput<$PrismaModel>
    not?: NestedEnumGoldenCardStatusWithAggregatesFilter<$PrismaModel> | $Enums.GoldenCardStatus
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumGoldenCardStatusFilter<$PrismaModel>
    _max?: NestedEnumGoldenCardStatusFilter<$PrismaModel>
  }

  export type EnumSpecialCardStateWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.SpecialCardState | EnumSpecialCardStateFieldRefInput<$PrismaModel>
    in?: $Enums.SpecialCardState[] | ListEnumSpecialCardStateFieldRefInput<$PrismaModel>
    notIn?: $Enums.SpecialCardState[] | ListEnumSpecialCardStateFieldRefInput<$PrismaModel>
    not?: NestedEnumSpecialCardStateWithAggregatesFilter<$PrismaModel> | $Enums.SpecialCardState
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumSpecialCardStateFilter<$PrismaModel>
    _max?: NestedEnumSpecialCardStateFilter<$PrismaModel>
  }

  export type SessionCountOrderByAggregateInput = {
    id?: SortOrder
    sessionToken?: SortOrder
    userId?: SortOrder
    expires?: SortOrder
  }

  export type SessionMaxOrderByAggregateInput = {
    id?: SortOrder
    sessionToken?: SortOrder
    userId?: SortOrder
    expires?: SortOrder
  }

  export type SessionMinOrderByAggregateInput = {
    id?: SortOrder
    sessionToken?: SortOrder
    userId?: SortOrder
    expires?: SortOrder
  }

  export type EnumTeamStatusFilter<$PrismaModel = never> = {
    equals?: $Enums.TeamStatus | EnumTeamStatusFieldRefInput<$PrismaModel>
    in?: $Enums.TeamStatus[] | ListEnumTeamStatusFieldRefInput<$PrismaModel>
    notIn?: $Enums.TeamStatus[] | ListEnumTeamStatusFieldRefInput<$PrismaModel>
    not?: NestedEnumTeamStatusFilter<$PrismaModel> | $Enums.TeamStatus
  }

  export type TeamCountOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    userId?: SortOrder
    budget?: SortOrder
    totalPoints?: SortOrder
    formation?: SortOrder
    status?: SortOrder
    createdAt?: SortOrder
  }

  export type TeamAvgOrderByAggregateInput = {
    budget?: SortOrder
    totalPoints?: SortOrder
  }

  export type TeamMaxOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    userId?: SortOrder
    budget?: SortOrder
    totalPoints?: SortOrder
    formation?: SortOrder
    status?: SortOrder
    createdAt?: SortOrder
  }

  export type TeamMinOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    userId?: SortOrder
    budget?: SortOrder
    totalPoints?: SortOrder
    formation?: SortOrder
    status?: SortOrder
    createdAt?: SortOrder
  }

  export type TeamSumOrderByAggregateInput = {
    budget?: SortOrder
    totalPoints?: SortOrder
  }

  export type EnumTeamStatusWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.TeamStatus | EnumTeamStatusFieldRefInput<$PrismaModel>
    in?: $Enums.TeamStatus[] | ListEnumTeamStatusFieldRefInput<$PrismaModel>
    notIn?: $Enums.TeamStatus[] | ListEnumTeamStatusFieldRefInput<$PrismaModel>
    not?: NestedEnumTeamStatusWithAggregatesFilter<$PrismaModel> | $Enums.TeamStatus
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumTeamStatusFilter<$PrismaModel>
    _max?: NestedEnumTeamStatusFilter<$PrismaModel>
  }

  export type TeamScalarRelationFilter = {
    is?: TeamWhereInput
    isNot?: TeamWhereInput
  }

  export type GoldenCardNullableScalarRelationFilter = {
    is?: GoldenCardWhereInput | null
    isNot?: GoldenCardWhereInput | null
  }

  export type TeamPlayerTeamIdPlayerIdCompoundUniqueInput = {
    teamId: string
    playerId: string
  }

  export type TeamPlayerCountOrderByAggregateInput = {
    teamId?: SortOrder
    playerId?: SortOrder
    goldenCardId?: SortOrder
    isCaptain?: SortOrder
    isViceCaptain?: SortOrder
    isBench?: SortOrder
    positionIndex?: SortOrder
  }

  export type TeamPlayerAvgOrderByAggregateInput = {
    positionIndex?: SortOrder
  }

  export type TeamPlayerMaxOrderByAggregateInput = {
    teamId?: SortOrder
    playerId?: SortOrder
    goldenCardId?: SortOrder
    isCaptain?: SortOrder
    isViceCaptain?: SortOrder
    isBench?: SortOrder
    positionIndex?: SortOrder
  }

  export type TeamPlayerMinOrderByAggregateInput = {
    teamId?: SortOrder
    playerId?: SortOrder
    goldenCardId?: SortOrder
    isCaptain?: SortOrder
    isViceCaptain?: SortOrder
    isBench?: SortOrder
    positionIndex?: SortOrder
  }

  export type TeamPlayerSumOrderByAggregateInput = {
    positionIndex?: SortOrder
  }

  export type PackageCountOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    budgetBonus?: SortOrder
    price?: SortOrder
    description?: SortOrder
    isActive?: SortOrder
  }

  export type PackageAvgOrderByAggregateInput = {
    budgetBonus?: SortOrder
    price?: SortOrder
  }

  export type PackageMaxOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    budgetBonus?: SortOrder
    price?: SortOrder
    description?: SortOrder
    isActive?: SortOrder
  }

  export type PackageMinOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    budgetBonus?: SortOrder
    price?: SortOrder
    description?: SortOrder
    isActive?: SortOrder
  }

  export type PackageSumOrderByAggregateInput = {
    budgetBonus?: SortOrder
    price?: SortOrder
  }

  export type EnumPaymentStatusFilter<$PrismaModel = never> = {
    equals?: $Enums.PaymentStatus | EnumPaymentStatusFieldRefInput<$PrismaModel>
    in?: $Enums.PaymentStatus[] | ListEnumPaymentStatusFieldRefInput<$PrismaModel>
    notIn?: $Enums.PaymentStatus[] | ListEnumPaymentStatusFieldRefInput<$PrismaModel>
    not?: NestedEnumPaymentStatusFilter<$PrismaModel> | $Enums.PaymentStatus
  }

  export type PackageScalarRelationFilter = {
    is?: PackageWhereInput
    isNot?: PackageWhereInput
  }

  export type PaymentCountOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    packageId?: SortOrder
    amount?: SortOrder
    authority?: SortOrder
    refId?: SortOrder
    status?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type PaymentAvgOrderByAggregateInput = {
    amount?: SortOrder
  }

  export type PaymentMaxOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    packageId?: SortOrder
    amount?: SortOrder
    authority?: SortOrder
    refId?: SortOrder
    status?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type PaymentMinOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    packageId?: SortOrder
    amount?: SortOrder
    authority?: SortOrder
    refId?: SortOrder
    status?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type PaymentSumOrderByAggregateInput = {
    amount?: SortOrder
  }

  export type EnumPaymentStatusWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.PaymentStatus | EnumPaymentStatusFieldRefInput<$PrismaModel>
    in?: $Enums.PaymentStatus[] | ListEnumPaymentStatusFieldRefInput<$PrismaModel>
    notIn?: $Enums.PaymentStatus[] | ListEnumPaymentStatusFieldRefInput<$PrismaModel>
    not?: NestedEnumPaymentStatusWithAggregatesFilter<$PrismaModel> | $Enums.PaymentStatus
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumPaymentStatusFilter<$PrismaModel>
    _max?: NestedEnumPaymentStatusFilter<$PrismaModel>
  }

  export type CountryCreatedefaultLineupPlayerIdsInput = {
    set: string[]
  }

  export type GroupCreateNestedOneWithoutCountriesInput = {
    create?: XOR<GroupCreateWithoutCountriesInput, GroupUncheckedCreateWithoutCountriesInput>
    connectOrCreate?: GroupCreateOrConnectWithoutCountriesInput
    connect?: GroupWhereUniqueInput
  }

  export type PlayerCreateNestedManyWithoutCountryInput = {
    create?: XOR<PlayerCreateWithoutCountryInput, PlayerUncheckedCreateWithoutCountryInput> | PlayerCreateWithoutCountryInput[] | PlayerUncheckedCreateWithoutCountryInput[]
    connectOrCreate?: PlayerCreateOrConnectWithoutCountryInput | PlayerCreateOrConnectWithoutCountryInput[]
    createMany?: PlayerCreateManyCountryInputEnvelope
    connect?: PlayerWhereUniqueInput | PlayerWhereUniqueInput[]
  }

  export type MatchCreateNestedManyWithoutHomeTeamInput = {
    create?: XOR<MatchCreateWithoutHomeTeamInput, MatchUncheckedCreateWithoutHomeTeamInput> | MatchCreateWithoutHomeTeamInput[] | MatchUncheckedCreateWithoutHomeTeamInput[]
    connectOrCreate?: MatchCreateOrConnectWithoutHomeTeamInput | MatchCreateOrConnectWithoutHomeTeamInput[]
    createMany?: MatchCreateManyHomeTeamInputEnvelope
    connect?: MatchWhereUniqueInput | MatchWhereUniqueInput[]
  }

  export type MatchCreateNestedManyWithoutAwayTeamInput = {
    create?: XOR<MatchCreateWithoutAwayTeamInput, MatchUncheckedCreateWithoutAwayTeamInput> | MatchCreateWithoutAwayTeamInput[] | MatchUncheckedCreateWithoutAwayTeamInput[]
    connectOrCreate?: MatchCreateOrConnectWithoutAwayTeamInput | MatchCreateOrConnectWithoutAwayTeamInput[]
    createMany?: MatchCreateManyAwayTeamInputEnvelope
    connect?: MatchWhereUniqueInput | MatchWhereUniqueInput[]
  }

  export type PlayerUncheckedCreateNestedManyWithoutCountryInput = {
    create?: XOR<PlayerCreateWithoutCountryInput, PlayerUncheckedCreateWithoutCountryInput> | PlayerCreateWithoutCountryInput[] | PlayerUncheckedCreateWithoutCountryInput[]
    connectOrCreate?: PlayerCreateOrConnectWithoutCountryInput | PlayerCreateOrConnectWithoutCountryInput[]
    createMany?: PlayerCreateManyCountryInputEnvelope
    connect?: PlayerWhereUniqueInput | PlayerWhereUniqueInput[]
  }

  export type MatchUncheckedCreateNestedManyWithoutHomeTeamInput = {
    create?: XOR<MatchCreateWithoutHomeTeamInput, MatchUncheckedCreateWithoutHomeTeamInput> | MatchCreateWithoutHomeTeamInput[] | MatchUncheckedCreateWithoutHomeTeamInput[]
    connectOrCreate?: MatchCreateOrConnectWithoutHomeTeamInput | MatchCreateOrConnectWithoutHomeTeamInput[]
    createMany?: MatchCreateManyHomeTeamInputEnvelope
    connect?: MatchWhereUniqueInput | MatchWhereUniqueInput[]
  }

  export type MatchUncheckedCreateNestedManyWithoutAwayTeamInput = {
    create?: XOR<MatchCreateWithoutAwayTeamInput, MatchUncheckedCreateWithoutAwayTeamInput> | MatchCreateWithoutAwayTeamInput[] | MatchUncheckedCreateWithoutAwayTeamInput[]
    connectOrCreate?: MatchCreateOrConnectWithoutAwayTeamInput | MatchCreateOrConnectWithoutAwayTeamInput[]
    createMany?: MatchCreateManyAwayTeamInputEnvelope
    connect?: MatchWhereUniqueInput | MatchWhereUniqueInput[]
  }

  export type StringFieldUpdateOperationsInput = {
    set?: string
  }

  export type NullableStringFieldUpdateOperationsInput = {
    set?: string | null
  }

  export type CountryUpdatedefaultLineupPlayerIdsInput = {
    set?: string[]
    push?: string | string[]
  }

  export type BoolFieldUpdateOperationsInput = {
    set?: boolean
  }

  export type GroupUpdateOneWithoutCountriesNestedInput = {
    create?: XOR<GroupCreateWithoutCountriesInput, GroupUncheckedCreateWithoutCountriesInput>
    connectOrCreate?: GroupCreateOrConnectWithoutCountriesInput
    upsert?: GroupUpsertWithoutCountriesInput
    disconnect?: GroupWhereInput | boolean
    delete?: GroupWhereInput | boolean
    connect?: GroupWhereUniqueInput
    update?: XOR<XOR<GroupUpdateToOneWithWhereWithoutCountriesInput, GroupUpdateWithoutCountriesInput>, GroupUncheckedUpdateWithoutCountriesInput>
  }

  export type PlayerUpdateManyWithoutCountryNestedInput = {
    create?: XOR<PlayerCreateWithoutCountryInput, PlayerUncheckedCreateWithoutCountryInput> | PlayerCreateWithoutCountryInput[] | PlayerUncheckedCreateWithoutCountryInput[]
    connectOrCreate?: PlayerCreateOrConnectWithoutCountryInput | PlayerCreateOrConnectWithoutCountryInput[]
    upsert?: PlayerUpsertWithWhereUniqueWithoutCountryInput | PlayerUpsertWithWhereUniqueWithoutCountryInput[]
    createMany?: PlayerCreateManyCountryInputEnvelope
    set?: PlayerWhereUniqueInput | PlayerWhereUniqueInput[]
    disconnect?: PlayerWhereUniqueInput | PlayerWhereUniqueInput[]
    delete?: PlayerWhereUniqueInput | PlayerWhereUniqueInput[]
    connect?: PlayerWhereUniqueInput | PlayerWhereUniqueInput[]
    update?: PlayerUpdateWithWhereUniqueWithoutCountryInput | PlayerUpdateWithWhereUniqueWithoutCountryInput[]
    updateMany?: PlayerUpdateManyWithWhereWithoutCountryInput | PlayerUpdateManyWithWhereWithoutCountryInput[]
    deleteMany?: PlayerScalarWhereInput | PlayerScalarWhereInput[]
  }

  export type MatchUpdateManyWithoutHomeTeamNestedInput = {
    create?: XOR<MatchCreateWithoutHomeTeamInput, MatchUncheckedCreateWithoutHomeTeamInput> | MatchCreateWithoutHomeTeamInput[] | MatchUncheckedCreateWithoutHomeTeamInput[]
    connectOrCreate?: MatchCreateOrConnectWithoutHomeTeamInput | MatchCreateOrConnectWithoutHomeTeamInput[]
    upsert?: MatchUpsertWithWhereUniqueWithoutHomeTeamInput | MatchUpsertWithWhereUniqueWithoutHomeTeamInput[]
    createMany?: MatchCreateManyHomeTeamInputEnvelope
    set?: MatchWhereUniqueInput | MatchWhereUniqueInput[]
    disconnect?: MatchWhereUniqueInput | MatchWhereUniqueInput[]
    delete?: MatchWhereUniqueInput | MatchWhereUniqueInput[]
    connect?: MatchWhereUniqueInput | MatchWhereUniqueInput[]
    update?: MatchUpdateWithWhereUniqueWithoutHomeTeamInput | MatchUpdateWithWhereUniqueWithoutHomeTeamInput[]
    updateMany?: MatchUpdateManyWithWhereWithoutHomeTeamInput | MatchUpdateManyWithWhereWithoutHomeTeamInput[]
    deleteMany?: MatchScalarWhereInput | MatchScalarWhereInput[]
  }

  export type MatchUpdateManyWithoutAwayTeamNestedInput = {
    create?: XOR<MatchCreateWithoutAwayTeamInput, MatchUncheckedCreateWithoutAwayTeamInput> | MatchCreateWithoutAwayTeamInput[] | MatchUncheckedCreateWithoutAwayTeamInput[]
    connectOrCreate?: MatchCreateOrConnectWithoutAwayTeamInput | MatchCreateOrConnectWithoutAwayTeamInput[]
    upsert?: MatchUpsertWithWhereUniqueWithoutAwayTeamInput | MatchUpsertWithWhereUniqueWithoutAwayTeamInput[]
    createMany?: MatchCreateManyAwayTeamInputEnvelope
    set?: MatchWhereUniqueInput | MatchWhereUniqueInput[]
    disconnect?: MatchWhereUniqueInput | MatchWhereUniqueInput[]
    delete?: MatchWhereUniqueInput | MatchWhereUniqueInput[]
    connect?: MatchWhereUniqueInput | MatchWhereUniqueInput[]
    update?: MatchUpdateWithWhereUniqueWithoutAwayTeamInput | MatchUpdateWithWhereUniqueWithoutAwayTeamInput[]
    updateMany?: MatchUpdateManyWithWhereWithoutAwayTeamInput | MatchUpdateManyWithWhereWithoutAwayTeamInput[]
    deleteMany?: MatchScalarWhereInput | MatchScalarWhereInput[]
  }

  export type PlayerUncheckedUpdateManyWithoutCountryNestedInput = {
    create?: XOR<PlayerCreateWithoutCountryInput, PlayerUncheckedCreateWithoutCountryInput> | PlayerCreateWithoutCountryInput[] | PlayerUncheckedCreateWithoutCountryInput[]
    connectOrCreate?: PlayerCreateOrConnectWithoutCountryInput | PlayerCreateOrConnectWithoutCountryInput[]
    upsert?: PlayerUpsertWithWhereUniqueWithoutCountryInput | PlayerUpsertWithWhereUniqueWithoutCountryInput[]
    createMany?: PlayerCreateManyCountryInputEnvelope
    set?: PlayerWhereUniqueInput | PlayerWhereUniqueInput[]
    disconnect?: PlayerWhereUniqueInput | PlayerWhereUniqueInput[]
    delete?: PlayerWhereUniqueInput | PlayerWhereUniqueInput[]
    connect?: PlayerWhereUniqueInput | PlayerWhereUniqueInput[]
    update?: PlayerUpdateWithWhereUniqueWithoutCountryInput | PlayerUpdateWithWhereUniqueWithoutCountryInput[]
    updateMany?: PlayerUpdateManyWithWhereWithoutCountryInput | PlayerUpdateManyWithWhereWithoutCountryInput[]
    deleteMany?: PlayerScalarWhereInput | PlayerScalarWhereInput[]
  }

  export type MatchUncheckedUpdateManyWithoutHomeTeamNestedInput = {
    create?: XOR<MatchCreateWithoutHomeTeamInput, MatchUncheckedCreateWithoutHomeTeamInput> | MatchCreateWithoutHomeTeamInput[] | MatchUncheckedCreateWithoutHomeTeamInput[]
    connectOrCreate?: MatchCreateOrConnectWithoutHomeTeamInput | MatchCreateOrConnectWithoutHomeTeamInput[]
    upsert?: MatchUpsertWithWhereUniqueWithoutHomeTeamInput | MatchUpsertWithWhereUniqueWithoutHomeTeamInput[]
    createMany?: MatchCreateManyHomeTeamInputEnvelope
    set?: MatchWhereUniqueInput | MatchWhereUniqueInput[]
    disconnect?: MatchWhereUniqueInput | MatchWhereUniqueInput[]
    delete?: MatchWhereUniqueInput | MatchWhereUniqueInput[]
    connect?: MatchWhereUniqueInput | MatchWhereUniqueInput[]
    update?: MatchUpdateWithWhereUniqueWithoutHomeTeamInput | MatchUpdateWithWhereUniqueWithoutHomeTeamInput[]
    updateMany?: MatchUpdateManyWithWhereWithoutHomeTeamInput | MatchUpdateManyWithWhereWithoutHomeTeamInput[]
    deleteMany?: MatchScalarWhereInput | MatchScalarWhereInput[]
  }

  export type MatchUncheckedUpdateManyWithoutAwayTeamNestedInput = {
    create?: XOR<MatchCreateWithoutAwayTeamInput, MatchUncheckedCreateWithoutAwayTeamInput> | MatchCreateWithoutAwayTeamInput[] | MatchUncheckedCreateWithoutAwayTeamInput[]
    connectOrCreate?: MatchCreateOrConnectWithoutAwayTeamInput | MatchCreateOrConnectWithoutAwayTeamInput[]
    upsert?: MatchUpsertWithWhereUniqueWithoutAwayTeamInput | MatchUpsertWithWhereUniqueWithoutAwayTeamInput[]
    createMany?: MatchCreateManyAwayTeamInputEnvelope
    set?: MatchWhereUniqueInput | MatchWhereUniqueInput[]
    disconnect?: MatchWhereUniqueInput | MatchWhereUniqueInput[]
    delete?: MatchWhereUniqueInput | MatchWhereUniqueInput[]
    connect?: MatchWhereUniqueInput | MatchWhereUniqueInput[]
    update?: MatchUpdateWithWhereUniqueWithoutAwayTeamInput | MatchUpdateWithWhereUniqueWithoutAwayTeamInput[]
    updateMany?: MatchUpdateManyWithWhereWithoutAwayTeamInput | MatchUpdateManyWithWhereWithoutAwayTeamInput[]
    deleteMany?: MatchScalarWhereInput | MatchScalarWhereInput[]
  }

  export type CountryCreateNestedManyWithoutGroupInput = {
    create?: XOR<CountryCreateWithoutGroupInput, CountryUncheckedCreateWithoutGroupInput> | CountryCreateWithoutGroupInput[] | CountryUncheckedCreateWithoutGroupInput[]
    connectOrCreate?: CountryCreateOrConnectWithoutGroupInput | CountryCreateOrConnectWithoutGroupInput[]
    createMany?: CountryCreateManyGroupInputEnvelope
    connect?: CountryWhereUniqueInput | CountryWhereUniqueInput[]
  }

  export type CountryUncheckedCreateNestedManyWithoutGroupInput = {
    create?: XOR<CountryCreateWithoutGroupInput, CountryUncheckedCreateWithoutGroupInput> | CountryCreateWithoutGroupInput[] | CountryUncheckedCreateWithoutGroupInput[]
    connectOrCreate?: CountryCreateOrConnectWithoutGroupInput | CountryCreateOrConnectWithoutGroupInput[]
    createMany?: CountryCreateManyGroupInputEnvelope
    connect?: CountryWhereUniqueInput | CountryWhereUniqueInput[]
  }

  export type CountryUpdateManyWithoutGroupNestedInput = {
    create?: XOR<CountryCreateWithoutGroupInput, CountryUncheckedCreateWithoutGroupInput> | CountryCreateWithoutGroupInput[] | CountryUncheckedCreateWithoutGroupInput[]
    connectOrCreate?: CountryCreateOrConnectWithoutGroupInput | CountryCreateOrConnectWithoutGroupInput[]
    upsert?: CountryUpsertWithWhereUniqueWithoutGroupInput | CountryUpsertWithWhereUniqueWithoutGroupInput[]
    createMany?: CountryCreateManyGroupInputEnvelope
    set?: CountryWhereUniqueInput | CountryWhereUniqueInput[]
    disconnect?: CountryWhereUniqueInput | CountryWhereUniqueInput[]
    delete?: CountryWhereUniqueInput | CountryWhereUniqueInput[]
    connect?: CountryWhereUniqueInput | CountryWhereUniqueInput[]
    update?: CountryUpdateWithWhereUniqueWithoutGroupInput | CountryUpdateWithWhereUniqueWithoutGroupInput[]
    updateMany?: CountryUpdateManyWithWhereWithoutGroupInput | CountryUpdateManyWithWhereWithoutGroupInput[]
    deleteMany?: CountryScalarWhereInput | CountryScalarWhereInput[]
  }

  export type CountryUncheckedUpdateManyWithoutGroupNestedInput = {
    create?: XOR<CountryCreateWithoutGroupInput, CountryUncheckedCreateWithoutGroupInput> | CountryCreateWithoutGroupInput[] | CountryUncheckedCreateWithoutGroupInput[]
    connectOrCreate?: CountryCreateOrConnectWithoutGroupInput | CountryCreateOrConnectWithoutGroupInput[]
    upsert?: CountryUpsertWithWhereUniqueWithoutGroupInput | CountryUpsertWithWhereUniqueWithoutGroupInput[]
    createMany?: CountryCreateManyGroupInputEnvelope
    set?: CountryWhereUniqueInput | CountryWhereUniqueInput[]
    disconnect?: CountryWhereUniqueInput | CountryWhereUniqueInput[]
    delete?: CountryWhereUniqueInput | CountryWhereUniqueInput[]
    connect?: CountryWhereUniqueInput | CountryWhereUniqueInput[]
    update?: CountryUpdateWithWhereUniqueWithoutGroupInput | CountryUpdateWithWhereUniqueWithoutGroupInput[]
    updateMany?: CountryUpdateManyWithWhereWithoutGroupInput | CountryUpdateManyWithWhereWithoutGroupInput[]
    deleteMany?: CountryScalarWhereInput | CountryScalarWhereInput[]
  }

  export type CountryCreateNestedOneWithoutPlayersInput = {
    create?: XOR<CountryCreateWithoutPlayersInput, CountryUncheckedCreateWithoutPlayersInput>
    connectOrCreate?: CountryCreateOrConnectWithoutPlayersInput
    connect?: CountryWhereUniqueInput
  }

  export type PlayerMatchStatCreateNestedManyWithoutPlayerInput = {
    create?: XOR<PlayerMatchStatCreateWithoutPlayerInput, PlayerMatchStatUncheckedCreateWithoutPlayerInput> | PlayerMatchStatCreateWithoutPlayerInput[] | PlayerMatchStatUncheckedCreateWithoutPlayerInput[]
    connectOrCreate?: PlayerMatchStatCreateOrConnectWithoutPlayerInput | PlayerMatchStatCreateOrConnectWithoutPlayerInput[]
    createMany?: PlayerMatchStatCreateManyPlayerInputEnvelope
    connect?: PlayerMatchStatWhereUniqueInput | PlayerMatchStatWhereUniqueInput[]
  }

  export type TeamPlayerCreateNestedManyWithoutPlayerInput = {
    create?: XOR<TeamPlayerCreateWithoutPlayerInput, TeamPlayerUncheckedCreateWithoutPlayerInput> | TeamPlayerCreateWithoutPlayerInput[] | TeamPlayerUncheckedCreateWithoutPlayerInput[]
    connectOrCreate?: TeamPlayerCreateOrConnectWithoutPlayerInput | TeamPlayerCreateOrConnectWithoutPlayerInput[]
    createMany?: TeamPlayerCreateManyPlayerInputEnvelope
    connect?: TeamPlayerWhereUniqueInput | TeamPlayerWhereUniqueInput[]
  }

  export type MatchEventCreateNestedManyWithoutPlayerInput = {
    create?: XOR<MatchEventCreateWithoutPlayerInput, MatchEventUncheckedCreateWithoutPlayerInput> | MatchEventCreateWithoutPlayerInput[] | MatchEventUncheckedCreateWithoutPlayerInput[]
    connectOrCreate?: MatchEventCreateOrConnectWithoutPlayerInput | MatchEventCreateOrConnectWithoutPlayerInput[]
    createMany?: MatchEventCreateManyPlayerInputEnvelope
    connect?: MatchEventWhereUniqueInput | MatchEventWhereUniqueInput[]
  }

  export type GoldenCardCreateNestedManyWithoutPlayerInput = {
    create?: XOR<GoldenCardCreateWithoutPlayerInput, GoldenCardUncheckedCreateWithoutPlayerInput> | GoldenCardCreateWithoutPlayerInput[] | GoldenCardUncheckedCreateWithoutPlayerInput[]
    connectOrCreate?: GoldenCardCreateOrConnectWithoutPlayerInput | GoldenCardCreateOrConnectWithoutPlayerInput[]
    createMany?: GoldenCardCreateManyPlayerInputEnvelope
    connect?: GoldenCardWhereUniqueInput | GoldenCardWhereUniqueInput[]
  }

  export type PlayerMatchStatUncheckedCreateNestedManyWithoutPlayerInput = {
    create?: XOR<PlayerMatchStatCreateWithoutPlayerInput, PlayerMatchStatUncheckedCreateWithoutPlayerInput> | PlayerMatchStatCreateWithoutPlayerInput[] | PlayerMatchStatUncheckedCreateWithoutPlayerInput[]
    connectOrCreate?: PlayerMatchStatCreateOrConnectWithoutPlayerInput | PlayerMatchStatCreateOrConnectWithoutPlayerInput[]
    createMany?: PlayerMatchStatCreateManyPlayerInputEnvelope
    connect?: PlayerMatchStatWhereUniqueInput | PlayerMatchStatWhereUniqueInput[]
  }

  export type TeamPlayerUncheckedCreateNestedManyWithoutPlayerInput = {
    create?: XOR<TeamPlayerCreateWithoutPlayerInput, TeamPlayerUncheckedCreateWithoutPlayerInput> | TeamPlayerCreateWithoutPlayerInput[] | TeamPlayerUncheckedCreateWithoutPlayerInput[]
    connectOrCreate?: TeamPlayerCreateOrConnectWithoutPlayerInput | TeamPlayerCreateOrConnectWithoutPlayerInput[]
    createMany?: TeamPlayerCreateManyPlayerInputEnvelope
    connect?: TeamPlayerWhereUniqueInput | TeamPlayerWhereUniqueInput[]
  }

  export type MatchEventUncheckedCreateNestedManyWithoutPlayerInput = {
    create?: XOR<MatchEventCreateWithoutPlayerInput, MatchEventUncheckedCreateWithoutPlayerInput> | MatchEventCreateWithoutPlayerInput[] | MatchEventUncheckedCreateWithoutPlayerInput[]
    connectOrCreate?: MatchEventCreateOrConnectWithoutPlayerInput | MatchEventCreateOrConnectWithoutPlayerInput[]
    createMany?: MatchEventCreateManyPlayerInputEnvelope
    connect?: MatchEventWhereUniqueInput | MatchEventWhereUniqueInput[]
  }

  export type GoldenCardUncheckedCreateNestedManyWithoutPlayerInput = {
    create?: XOR<GoldenCardCreateWithoutPlayerInput, GoldenCardUncheckedCreateWithoutPlayerInput> | GoldenCardCreateWithoutPlayerInput[] | GoldenCardUncheckedCreateWithoutPlayerInput[]
    connectOrCreate?: GoldenCardCreateOrConnectWithoutPlayerInput | GoldenCardCreateOrConnectWithoutPlayerInput[]
    createMany?: GoldenCardCreateManyPlayerInputEnvelope
    connect?: GoldenCardWhereUniqueInput | GoldenCardWhereUniqueInput[]
  }

  export type EnumPositionFieldUpdateOperationsInput = {
    set?: $Enums.Position
  }

  export type FloatFieldUpdateOperationsInput = {
    set?: number
    increment?: number
    decrement?: number
    multiply?: number
    divide?: number
  }

  export type IntFieldUpdateOperationsInput = {
    set?: number
    increment?: number
    decrement?: number
    multiply?: number
    divide?: number
  }

  export type EnumCardTierFieldUpdateOperationsInput = {
    set?: $Enums.CardTier
  }

  export type DateTimeFieldUpdateOperationsInput = {
    set?: Date | string
  }

  export type CountryUpdateOneRequiredWithoutPlayersNestedInput = {
    create?: XOR<CountryCreateWithoutPlayersInput, CountryUncheckedCreateWithoutPlayersInput>
    connectOrCreate?: CountryCreateOrConnectWithoutPlayersInput
    upsert?: CountryUpsertWithoutPlayersInput
    connect?: CountryWhereUniqueInput
    update?: XOR<XOR<CountryUpdateToOneWithWhereWithoutPlayersInput, CountryUpdateWithoutPlayersInput>, CountryUncheckedUpdateWithoutPlayersInput>
  }

  export type PlayerMatchStatUpdateManyWithoutPlayerNestedInput = {
    create?: XOR<PlayerMatchStatCreateWithoutPlayerInput, PlayerMatchStatUncheckedCreateWithoutPlayerInput> | PlayerMatchStatCreateWithoutPlayerInput[] | PlayerMatchStatUncheckedCreateWithoutPlayerInput[]
    connectOrCreate?: PlayerMatchStatCreateOrConnectWithoutPlayerInput | PlayerMatchStatCreateOrConnectWithoutPlayerInput[]
    upsert?: PlayerMatchStatUpsertWithWhereUniqueWithoutPlayerInput | PlayerMatchStatUpsertWithWhereUniqueWithoutPlayerInput[]
    createMany?: PlayerMatchStatCreateManyPlayerInputEnvelope
    set?: PlayerMatchStatWhereUniqueInput | PlayerMatchStatWhereUniqueInput[]
    disconnect?: PlayerMatchStatWhereUniqueInput | PlayerMatchStatWhereUniqueInput[]
    delete?: PlayerMatchStatWhereUniqueInput | PlayerMatchStatWhereUniqueInput[]
    connect?: PlayerMatchStatWhereUniqueInput | PlayerMatchStatWhereUniqueInput[]
    update?: PlayerMatchStatUpdateWithWhereUniqueWithoutPlayerInput | PlayerMatchStatUpdateWithWhereUniqueWithoutPlayerInput[]
    updateMany?: PlayerMatchStatUpdateManyWithWhereWithoutPlayerInput | PlayerMatchStatUpdateManyWithWhereWithoutPlayerInput[]
    deleteMany?: PlayerMatchStatScalarWhereInput | PlayerMatchStatScalarWhereInput[]
  }

  export type TeamPlayerUpdateManyWithoutPlayerNestedInput = {
    create?: XOR<TeamPlayerCreateWithoutPlayerInput, TeamPlayerUncheckedCreateWithoutPlayerInput> | TeamPlayerCreateWithoutPlayerInput[] | TeamPlayerUncheckedCreateWithoutPlayerInput[]
    connectOrCreate?: TeamPlayerCreateOrConnectWithoutPlayerInput | TeamPlayerCreateOrConnectWithoutPlayerInput[]
    upsert?: TeamPlayerUpsertWithWhereUniqueWithoutPlayerInput | TeamPlayerUpsertWithWhereUniqueWithoutPlayerInput[]
    createMany?: TeamPlayerCreateManyPlayerInputEnvelope
    set?: TeamPlayerWhereUniqueInput | TeamPlayerWhereUniqueInput[]
    disconnect?: TeamPlayerWhereUniqueInput | TeamPlayerWhereUniqueInput[]
    delete?: TeamPlayerWhereUniqueInput | TeamPlayerWhereUniqueInput[]
    connect?: TeamPlayerWhereUniqueInput | TeamPlayerWhereUniqueInput[]
    update?: TeamPlayerUpdateWithWhereUniqueWithoutPlayerInput | TeamPlayerUpdateWithWhereUniqueWithoutPlayerInput[]
    updateMany?: TeamPlayerUpdateManyWithWhereWithoutPlayerInput | TeamPlayerUpdateManyWithWhereWithoutPlayerInput[]
    deleteMany?: TeamPlayerScalarWhereInput | TeamPlayerScalarWhereInput[]
  }

  export type MatchEventUpdateManyWithoutPlayerNestedInput = {
    create?: XOR<MatchEventCreateWithoutPlayerInput, MatchEventUncheckedCreateWithoutPlayerInput> | MatchEventCreateWithoutPlayerInput[] | MatchEventUncheckedCreateWithoutPlayerInput[]
    connectOrCreate?: MatchEventCreateOrConnectWithoutPlayerInput | MatchEventCreateOrConnectWithoutPlayerInput[]
    upsert?: MatchEventUpsertWithWhereUniqueWithoutPlayerInput | MatchEventUpsertWithWhereUniqueWithoutPlayerInput[]
    createMany?: MatchEventCreateManyPlayerInputEnvelope
    set?: MatchEventWhereUniqueInput | MatchEventWhereUniqueInput[]
    disconnect?: MatchEventWhereUniqueInput | MatchEventWhereUniqueInput[]
    delete?: MatchEventWhereUniqueInput | MatchEventWhereUniqueInput[]
    connect?: MatchEventWhereUniqueInput | MatchEventWhereUniqueInput[]
    update?: MatchEventUpdateWithWhereUniqueWithoutPlayerInput | MatchEventUpdateWithWhereUniqueWithoutPlayerInput[]
    updateMany?: MatchEventUpdateManyWithWhereWithoutPlayerInput | MatchEventUpdateManyWithWhereWithoutPlayerInput[]
    deleteMany?: MatchEventScalarWhereInput | MatchEventScalarWhereInput[]
  }

  export type GoldenCardUpdateManyWithoutPlayerNestedInput = {
    create?: XOR<GoldenCardCreateWithoutPlayerInput, GoldenCardUncheckedCreateWithoutPlayerInput> | GoldenCardCreateWithoutPlayerInput[] | GoldenCardUncheckedCreateWithoutPlayerInput[]
    connectOrCreate?: GoldenCardCreateOrConnectWithoutPlayerInput | GoldenCardCreateOrConnectWithoutPlayerInput[]
    upsert?: GoldenCardUpsertWithWhereUniqueWithoutPlayerInput | GoldenCardUpsertWithWhereUniqueWithoutPlayerInput[]
    createMany?: GoldenCardCreateManyPlayerInputEnvelope
    set?: GoldenCardWhereUniqueInput | GoldenCardWhereUniqueInput[]
    disconnect?: GoldenCardWhereUniqueInput | GoldenCardWhereUniqueInput[]
    delete?: GoldenCardWhereUniqueInput | GoldenCardWhereUniqueInput[]
    connect?: GoldenCardWhereUniqueInput | GoldenCardWhereUniqueInput[]
    update?: GoldenCardUpdateWithWhereUniqueWithoutPlayerInput | GoldenCardUpdateWithWhereUniqueWithoutPlayerInput[]
    updateMany?: GoldenCardUpdateManyWithWhereWithoutPlayerInput | GoldenCardUpdateManyWithWhereWithoutPlayerInput[]
    deleteMany?: GoldenCardScalarWhereInput | GoldenCardScalarWhereInput[]
  }

  export type PlayerMatchStatUncheckedUpdateManyWithoutPlayerNestedInput = {
    create?: XOR<PlayerMatchStatCreateWithoutPlayerInput, PlayerMatchStatUncheckedCreateWithoutPlayerInput> | PlayerMatchStatCreateWithoutPlayerInput[] | PlayerMatchStatUncheckedCreateWithoutPlayerInput[]
    connectOrCreate?: PlayerMatchStatCreateOrConnectWithoutPlayerInput | PlayerMatchStatCreateOrConnectWithoutPlayerInput[]
    upsert?: PlayerMatchStatUpsertWithWhereUniqueWithoutPlayerInput | PlayerMatchStatUpsertWithWhereUniqueWithoutPlayerInput[]
    createMany?: PlayerMatchStatCreateManyPlayerInputEnvelope
    set?: PlayerMatchStatWhereUniqueInput | PlayerMatchStatWhereUniqueInput[]
    disconnect?: PlayerMatchStatWhereUniqueInput | PlayerMatchStatWhereUniqueInput[]
    delete?: PlayerMatchStatWhereUniqueInput | PlayerMatchStatWhereUniqueInput[]
    connect?: PlayerMatchStatWhereUniqueInput | PlayerMatchStatWhereUniqueInput[]
    update?: PlayerMatchStatUpdateWithWhereUniqueWithoutPlayerInput | PlayerMatchStatUpdateWithWhereUniqueWithoutPlayerInput[]
    updateMany?: PlayerMatchStatUpdateManyWithWhereWithoutPlayerInput | PlayerMatchStatUpdateManyWithWhereWithoutPlayerInput[]
    deleteMany?: PlayerMatchStatScalarWhereInput | PlayerMatchStatScalarWhereInput[]
  }

  export type TeamPlayerUncheckedUpdateManyWithoutPlayerNestedInput = {
    create?: XOR<TeamPlayerCreateWithoutPlayerInput, TeamPlayerUncheckedCreateWithoutPlayerInput> | TeamPlayerCreateWithoutPlayerInput[] | TeamPlayerUncheckedCreateWithoutPlayerInput[]
    connectOrCreate?: TeamPlayerCreateOrConnectWithoutPlayerInput | TeamPlayerCreateOrConnectWithoutPlayerInput[]
    upsert?: TeamPlayerUpsertWithWhereUniqueWithoutPlayerInput | TeamPlayerUpsertWithWhereUniqueWithoutPlayerInput[]
    createMany?: TeamPlayerCreateManyPlayerInputEnvelope
    set?: TeamPlayerWhereUniqueInput | TeamPlayerWhereUniqueInput[]
    disconnect?: TeamPlayerWhereUniqueInput | TeamPlayerWhereUniqueInput[]
    delete?: TeamPlayerWhereUniqueInput | TeamPlayerWhereUniqueInput[]
    connect?: TeamPlayerWhereUniqueInput | TeamPlayerWhereUniqueInput[]
    update?: TeamPlayerUpdateWithWhereUniqueWithoutPlayerInput | TeamPlayerUpdateWithWhereUniqueWithoutPlayerInput[]
    updateMany?: TeamPlayerUpdateManyWithWhereWithoutPlayerInput | TeamPlayerUpdateManyWithWhereWithoutPlayerInput[]
    deleteMany?: TeamPlayerScalarWhereInput | TeamPlayerScalarWhereInput[]
  }

  export type MatchEventUncheckedUpdateManyWithoutPlayerNestedInput = {
    create?: XOR<MatchEventCreateWithoutPlayerInput, MatchEventUncheckedCreateWithoutPlayerInput> | MatchEventCreateWithoutPlayerInput[] | MatchEventUncheckedCreateWithoutPlayerInput[]
    connectOrCreate?: MatchEventCreateOrConnectWithoutPlayerInput | MatchEventCreateOrConnectWithoutPlayerInput[]
    upsert?: MatchEventUpsertWithWhereUniqueWithoutPlayerInput | MatchEventUpsertWithWhereUniqueWithoutPlayerInput[]
    createMany?: MatchEventCreateManyPlayerInputEnvelope
    set?: MatchEventWhereUniqueInput | MatchEventWhereUniqueInput[]
    disconnect?: MatchEventWhereUniqueInput | MatchEventWhereUniqueInput[]
    delete?: MatchEventWhereUniqueInput | MatchEventWhereUniqueInput[]
    connect?: MatchEventWhereUniqueInput | MatchEventWhereUniqueInput[]
    update?: MatchEventUpdateWithWhereUniqueWithoutPlayerInput | MatchEventUpdateWithWhereUniqueWithoutPlayerInput[]
    updateMany?: MatchEventUpdateManyWithWhereWithoutPlayerInput | MatchEventUpdateManyWithWhereWithoutPlayerInput[]
    deleteMany?: MatchEventScalarWhereInput | MatchEventScalarWhereInput[]
  }

  export type GoldenCardUncheckedUpdateManyWithoutPlayerNestedInput = {
    create?: XOR<GoldenCardCreateWithoutPlayerInput, GoldenCardUncheckedCreateWithoutPlayerInput> | GoldenCardCreateWithoutPlayerInput[] | GoldenCardUncheckedCreateWithoutPlayerInput[]
    connectOrCreate?: GoldenCardCreateOrConnectWithoutPlayerInput | GoldenCardCreateOrConnectWithoutPlayerInput[]
    upsert?: GoldenCardUpsertWithWhereUniqueWithoutPlayerInput | GoldenCardUpsertWithWhereUniqueWithoutPlayerInput[]
    createMany?: GoldenCardCreateManyPlayerInputEnvelope
    set?: GoldenCardWhereUniqueInput | GoldenCardWhereUniqueInput[]
    disconnect?: GoldenCardWhereUniqueInput | GoldenCardWhereUniqueInput[]
    delete?: GoldenCardWhereUniqueInput | GoldenCardWhereUniqueInput[]
    connect?: GoldenCardWhereUniqueInput | GoldenCardWhereUniqueInput[]
    update?: GoldenCardUpdateWithWhereUniqueWithoutPlayerInput | GoldenCardUpdateWithWhereUniqueWithoutPlayerInput[]
    updateMany?: GoldenCardUpdateManyWithWhereWithoutPlayerInput | GoldenCardUpdateManyWithWhereWithoutPlayerInput[]
    deleteMany?: GoldenCardScalarWhereInput | GoldenCardScalarWhereInput[]
  }

  export type CountryCreateNestedOneWithoutHomeMatchesInput = {
    create?: XOR<CountryCreateWithoutHomeMatchesInput, CountryUncheckedCreateWithoutHomeMatchesInput>
    connectOrCreate?: CountryCreateOrConnectWithoutHomeMatchesInput
    connect?: CountryWhereUniqueInput
  }

  export type CountryCreateNestedOneWithoutAwayMatchesInput = {
    create?: XOR<CountryCreateWithoutAwayMatchesInput, CountryUncheckedCreateWithoutAwayMatchesInput>
    connectOrCreate?: CountryCreateOrConnectWithoutAwayMatchesInput
    connect?: CountryWhereUniqueInput
  }

  export type RoundCreateNestedOneWithoutMatchesInput = {
    create?: XOR<RoundCreateWithoutMatchesInput, RoundUncheckedCreateWithoutMatchesInput>
    connectOrCreate?: RoundCreateOrConnectWithoutMatchesInput
    connect?: RoundWhereUniqueInput
  }

  export type PlayerMatchStatCreateNestedManyWithoutMatchInput = {
    create?: XOR<PlayerMatchStatCreateWithoutMatchInput, PlayerMatchStatUncheckedCreateWithoutMatchInput> | PlayerMatchStatCreateWithoutMatchInput[] | PlayerMatchStatUncheckedCreateWithoutMatchInput[]
    connectOrCreate?: PlayerMatchStatCreateOrConnectWithoutMatchInput | PlayerMatchStatCreateOrConnectWithoutMatchInput[]
    createMany?: PlayerMatchStatCreateManyMatchInputEnvelope
    connect?: PlayerMatchStatWhereUniqueInput | PlayerMatchStatWhereUniqueInput[]
  }

  export type MatchEventCreateNestedManyWithoutMatchInput = {
    create?: XOR<MatchEventCreateWithoutMatchInput, MatchEventUncheckedCreateWithoutMatchInput> | MatchEventCreateWithoutMatchInput[] | MatchEventUncheckedCreateWithoutMatchInput[]
    connectOrCreate?: MatchEventCreateOrConnectWithoutMatchInput | MatchEventCreateOrConnectWithoutMatchInput[]
    createMany?: MatchEventCreateManyMatchInputEnvelope
    connect?: MatchEventWhereUniqueInput | MatchEventWhereUniqueInput[]
  }

  export type MatchLineupCreateNestedManyWithoutMatchInput = {
    create?: XOR<MatchLineupCreateWithoutMatchInput, MatchLineupUncheckedCreateWithoutMatchInput> | MatchLineupCreateWithoutMatchInput[] | MatchLineupUncheckedCreateWithoutMatchInput[]
    connectOrCreate?: MatchLineupCreateOrConnectWithoutMatchInput | MatchLineupCreateOrConnectWithoutMatchInput[]
    createMany?: MatchLineupCreateManyMatchInputEnvelope
    connect?: MatchLineupWhereUniqueInput | MatchLineupWhereUniqueInput[]
  }

  export type PlayerMatchStatUncheckedCreateNestedManyWithoutMatchInput = {
    create?: XOR<PlayerMatchStatCreateWithoutMatchInput, PlayerMatchStatUncheckedCreateWithoutMatchInput> | PlayerMatchStatCreateWithoutMatchInput[] | PlayerMatchStatUncheckedCreateWithoutMatchInput[]
    connectOrCreate?: PlayerMatchStatCreateOrConnectWithoutMatchInput | PlayerMatchStatCreateOrConnectWithoutMatchInput[]
    createMany?: PlayerMatchStatCreateManyMatchInputEnvelope
    connect?: PlayerMatchStatWhereUniqueInput | PlayerMatchStatWhereUniqueInput[]
  }

  export type MatchEventUncheckedCreateNestedManyWithoutMatchInput = {
    create?: XOR<MatchEventCreateWithoutMatchInput, MatchEventUncheckedCreateWithoutMatchInput> | MatchEventCreateWithoutMatchInput[] | MatchEventUncheckedCreateWithoutMatchInput[]
    connectOrCreate?: MatchEventCreateOrConnectWithoutMatchInput | MatchEventCreateOrConnectWithoutMatchInput[]
    createMany?: MatchEventCreateManyMatchInputEnvelope
    connect?: MatchEventWhereUniqueInput | MatchEventWhereUniqueInput[]
  }

  export type MatchLineupUncheckedCreateNestedManyWithoutMatchInput = {
    create?: XOR<MatchLineupCreateWithoutMatchInput, MatchLineupUncheckedCreateWithoutMatchInput> | MatchLineupCreateWithoutMatchInput[] | MatchLineupUncheckedCreateWithoutMatchInput[]
    connectOrCreate?: MatchLineupCreateOrConnectWithoutMatchInput | MatchLineupCreateOrConnectWithoutMatchInput[]
    createMany?: MatchLineupCreateManyMatchInputEnvelope
    connect?: MatchLineupWhereUniqueInput | MatchLineupWhereUniqueInput[]
  }

  export type NullableIntFieldUpdateOperationsInput = {
    set?: number | null
    increment?: number
    decrement?: number
    multiply?: number
    divide?: number
  }

  export type EnumMatchStageFieldUpdateOperationsInput = {
    set?: $Enums.MatchStage
  }

  export type EnumMatchStatusFieldUpdateOperationsInput = {
    set?: $Enums.MatchStatus
  }

  export type CountryUpdateOneRequiredWithoutHomeMatchesNestedInput = {
    create?: XOR<CountryCreateWithoutHomeMatchesInput, CountryUncheckedCreateWithoutHomeMatchesInput>
    connectOrCreate?: CountryCreateOrConnectWithoutHomeMatchesInput
    upsert?: CountryUpsertWithoutHomeMatchesInput
    connect?: CountryWhereUniqueInput
    update?: XOR<XOR<CountryUpdateToOneWithWhereWithoutHomeMatchesInput, CountryUpdateWithoutHomeMatchesInput>, CountryUncheckedUpdateWithoutHomeMatchesInput>
  }

  export type CountryUpdateOneRequiredWithoutAwayMatchesNestedInput = {
    create?: XOR<CountryCreateWithoutAwayMatchesInput, CountryUncheckedCreateWithoutAwayMatchesInput>
    connectOrCreate?: CountryCreateOrConnectWithoutAwayMatchesInput
    upsert?: CountryUpsertWithoutAwayMatchesInput
    connect?: CountryWhereUniqueInput
    update?: XOR<XOR<CountryUpdateToOneWithWhereWithoutAwayMatchesInput, CountryUpdateWithoutAwayMatchesInput>, CountryUncheckedUpdateWithoutAwayMatchesInput>
  }

  export type RoundUpdateOneWithoutMatchesNestedInput = {
    create?: XOR<RoundCreateWithoutMatchesInput, RoundUncheckedCreateWithoutMatchesInput>
    connectOrCreate?: RoundCreateOrConnectWithoutMatchesInput
    upsert?: RoundUpsertWithoutMatchesInput
    disconnect?: RoundWhereInput | boolean
    delete?: RoundWhereInput | boolean
    connect?: RoundWhereUniqueInput
    update?: XOR<XOR<RoundUpdateToOneWithWhereWithoutMatchesInput, RoundUpdateWithoutMatchesInput>, RoundUncheckedUpdateWithoutMatchesInput>
  }

  export type PlayerMatchStatUpdateManyWithoutMatchNestedInput = {
    create?: XOR<PlayerMatchStatCreateWithoutMatchInput, PlayerMatchStatUncheckedCreateWithoutMatchInput> | PlayerMatchStatCreateWithoutMatchInput[] | PlayerMatchStatUncheckedCreateWithoutMatchInput[]
    connectOrCreate?: PlayerMatchStatCreateOrConnectWithoutMatchInput | PlayerMatchStatCreateOrConnectWithoutMatchInput[]
    upsert?: PlayerMatchStatUpsertWithWhereUniqueWithoutMatchInput | PlayerMatchStatUpsertWithWhereUniqueWithoutMatchInput[]
    createMany?: PlayerMatchStatCreateManyMatchInputEnvelope
    set?: PlayerMatchStatWhereUniqueInput | PlayerMatchStatWhereUniqueInput[]
    disconnect?: PlayerMatchStatWhereUniqueInput | PlayerMatchStatWhereUniqueInput[]
    delete?: PlayerMatchStatWhereUniqueInput | PlayerMatchStatWhereUniqueInput[]
    connect?: PlayerMatchStatWhereUniqueInput | PlayerMatchStatWhereUniqueInput[]
    update?: PlayerMatchStatUpdateWithWhereUniqueWithoutMatchInput | PlayerMatchStatUpdateWithWhereUniqueWithoutMatchInput[]
    updateMany?: PlayerMatchStatUpdateManyWithWhereWithoutMatchInput | PlayerMatchStatUpdateManyWithWhereWithoutMatchInput[]
    deleteMany?: PlayerMatchStatScalarWhereInput | PlayerMatchStatScalarWhereInput[]
  }

  export type MatchEventUpdateManyWithoutMatchNestedInput = {
    create?: XOR<MatchEventCreateWithoutMatchInput, MatchEventUncheckedCreateWithoutMatchInput> | MatchEventCreateWithoutMatchInput[] | MatchEventUncheckedCreateWithoutMatchInput[]
    connectOrCreate?: MatchEventCreateOrConnectWithoutMatchInput | MatchEventCreateOrConnectWithoutMatchInput[]
    upsert?: MatchEventUpsertWithWhereUniqueWithoutMatchInput | MatchEventUpsertWithWhereUniqueWithoutMatchInput[]
    createMany?: MatchEventCreateManyMatchInputEnvelope
    set?: MatchEventWhereUniqueInput | MatchEventWhereUniqueInput[]
    disconnect?: MatchEventWhereUniqueInput | MatchEventWhereUniqueInput[]
    delete?: MatchEventWhereUniqueInput | MatchEventWhereUniqueInput[]
    connect?: MatchEventWhereUniqueInput | MatchEventWhereUniqueInput[]
    update?: MatchEventUpdateWithWhereUniqueWithoutMatchInput | MatchEventUpdateWithWhereUniqueWithoutMatchInput[]
    updateMany?: MatchEventUpdateManyWithWhereWithoutMatchInput | MatchEventUpdateManyWithWhereWithoutMatchInput[]
    deleteMany?: MatchEventScalarWhereInput | MatchEventScalarWhereInput[]
  }

  export type MatchLineupUpdateManyWithoutMatchNestedInput = {
    create?: XOR<MatchLineupCreateWithoutMatchInput, MatchLineupUncheckedCreateWithoutMatchInput> | MatchLineupCreateWithoutMatchInput[] | MatchLineupUncheckedCreateWithoutMatchInput[]
    connectOrCreate?: MatchLineupCreateOrConnectWithoutMatchInput | MatchLineupCreateOrConnectWithoutMatchInput[]
    upsert?: MatchLineupUpsertWithWhereUniqueWithoutMatchInput | MatchLineupUpsertWithWhereUniqueWithoutMatchInput[]
    createMany?: MatchLineupCreateManyMatchInputEnvelope
    set?: MatchLineupWhereUniqueInput | MatchLineupWhereUniqueInput[]
    disconnect?: MatchLineupWhereUniqueInput | MatchLineupWhereUniqueInput[]
    delete?: MatchLineupWhereUniqueInput | MatchLineupWhereUniqueInput[]
    connect?: MatchLineupWhereUniqueInput | MatchLineupWhereUniqueInput[]
    update?: MatchLineupUpdateWithWhereUniqueWithoutMatchInput | MatchLineupUpdateWithWhereUniqueWithoutMatchInput[]
    updateMany?: MatchLineupUpdateManyWithWhereWithoutMatchInput | MatchLineupUpdateManyWithWhereWithoutMatchInput[]
    deleteMany?: MatchLineupScalarWhereInput | MatchLineupScalarWhereInput[]
  }

  export type PlayerMatchStatUncheckedUpdateManyWithoutMatchNestedInput = {
    create?: XOR<PlayerMatchStatCreateWithoutMatchInput, PlayerMatchStatUncheckedCreateWithoutMatchInput> | PlayerMatchStatCreateWithoutMatchInput[] | PlayerMatchStatUncheckedCreateWithoutMatchInput[]
    connectOrCreate?: PlayerMatchStatCreateOrConnectWithoutMatchInput | PlayerMatchStatCreateOrConnectWithoutMatchInput[]
    upsert?: PlayerMatchStatUpsertWithWhereUniqueWithoutMatchInput | PlayerMatchStatUpsertWithWhereUniqueWithoutMatchInput[]
    createMany?: PlayerMatchStatCreateManyMatchInputEnvelope
    set?: PlayerMatchStatWhereUniqueInput | PlayerMatchStatWhereUniqueInput[]
    disconnect?: PlayerMatchStatWhereUniqueInput | PlayerMatchStatWhereUniqueInput[]
    delete?: PlayerMatchStatWhereUniqueInput | PlayerMatchStatWhereUniqueInput[]
    connect?: PlayerMatchStatWhereUniqueInput | PlayerMatchStatWhereUniqueInput[]
    update?: PlayerMatchStatUpdateWithWhereUniqueWithoutMatchInput | PlayerMatchStatUpdateWithWhereUniqueWithoutMatchInput[]
    updateMany?: PlayerMatchStatUpdateManyWithWhereWithoutMatchInput | PlayerMatchStatUpdateManyWithWhereWithoutMatchInput[]
    deleteMany?: PlayerMatchStatScalarWhereInput | PlayerMatchStatScalarWhereInput[]
  }

  export type MatchEventUncheckedUpdateManyWithoutMatchNestedInput = {
    create?: XOR<MatchEventCreateWithoutMatchInput, MatchEventUncheckedCreateWithoutMatchInput> | MatchEventCreateWithoutMatchInput[] | MatchEventUncheckedCreateWithoutMatchInput[]
    connectOrCreate?: MatchEventCreateOrConnectWithoutMatchInput | MatchEventCreateOrConnectWithoutMatchInput[]
    upsert?: MatchEventUpsertWithWhereUniqueWithoutMatchInput | MatchEventUpsertWithWhereUniqueWithoutMatchInput[]
    createMany?: MatchEventCreateManyMatchInputEnvelope
    set?: MatchEventWhereUniqueInput | MatchEventWhereUniqueInput[]
    disconnect?: MatchEventWhereUniqueInput | MatchEventWhereUniqueInput[]
    delete?: MatchEventWhereUniqueInput | MatchEventWhereUniqueInput[]
    connect?: MatchEventWhereUniqueInput | MatchEventWhereUniqueInput[]
    update?: MatchEventUpdateWithWhereUniqueWithoutMatchInput | MatchEventUpdateWithWhereUniqueWithoutMatchInput[]
    updateMany?: MatchEventUpdateManyWithWhereWithoutMatchInput | MatchEventUpdateManyWithWhereWithoutMatchInput[]
    deleteMany?: MatchEventScalarWhereInput | MatchEventScalarWhereInput[]
  }

  export type MatchLineupUncheckedUpdateManyWithoutMatchNestedInput = {
    create?: XOR<MatchLineupCreateWithoutMatchInput, MatchLineupUncheckedCreateWithoutMatchInput> | MatchLineupCreateWithoutMatchInput[] | MatchLineupUncheckedCreateWithoutMatchInput[]
    connectOrCreate?: MatchLineupCreateOrConnectWithoutMatchInput | MatchLineupCreateOrConnectWithoutMatchInput[]
    upsert?: MatchLineupUpsertWithWhereUniqueWithoutMatchInput | MatchLineupUpsertWithWhereUniqueWithoutMatchInput[]
    createMany?: MatchLineupCreateManyMatchInputEnvelope
    set?: MatchLineupWhereUniqueInput | MatchLineupWhereUniqueInput[]
    disconnect?: MatchLineupWhereUniqueInput | MatchLineupWhereUniqueInput[]
    delete?: MatchLineupWhereUniqueInput | MatchLineupWhereUniqueInput[]
    connect?: MatchLineupWhereUniqueInput | MatchLineupWhereUniqueInput[]
    update?: MatchLineupUpdateWithWhereUniqueWithoutMatchInput | MatchLineupUpdateWithWhereUniqueWithoutMatchInput[]
    updateMany?: MatchLineupUpdateManyWithWhereWithoutMatchInput | MatchLineupUpdateManyWithWhereWithoutMatchInput[]
    deleteMany?: MatchLineupScalarWhereInput | MatchLineupScalarWhereInput[]
  }

  export type MatchCreateNestedManyWithoutRoundInput = {
    create?: XOR<MatchCreateWithoutRoundInput, MatchUncheckedCreateWithoutRoundInput> | MatchCreateWithoutRoundInput[] | MatchUncheckedCreateWithoutRoundInput[]
    connectOrCreate?: MatchCreateOrConnectWithoutRoundInput | MatchCreateOrConnectWithoutRoundInput[]
    createMany?: MatchCreateManyRoundInputEnvelope
    connect?: MatchWhereUniqueInput | MatchWhereUniqueInput[]
  }

  export type MatchUncheckedCreateNestedManyWithoutRoundInput = {
    create?: XOR<MatchCreateWithoutRoundInput, MatchUncheckedCreateWithoutRoundInput> | MatchCreateWithoutRoundInput[] | MatchUncheckedCreateWithoutRoundInput[]
    connectOrCreate?: MatchCreateOrConnectWithoutRoundInput | MatchCreateOrConnectWithoutRoundInput[]
    createMany?: MatchCreateManyRoundInputEnvelope
    connect?: MatchWhereUniqueInput | MatchWhereUniqueInput[]
  }

  export type MatchUpdateManyWithoutRoundNestedInput = {
    create?: XOR<MatchCreateWithoutRoundInput, MatchUncheckedCreateWithoutRoundInput> | MatchCreateWithoutRoundInput[] | MatchUncheckedCreateWithoutRoundInput[]
    connectOrCreate?: MatchCreateOrConnectWithoutRoundInput | MatchCreateOrConnectWithoutRoundInput[]
    upsert?: MatchUpsertWithWhereUniqueWithoutRoundInput | MatchUpsertWithWhereUniqueWithoutRoundInput[]
    createMany?: MatchCreateManyRoundInputEnvelope
    set?: MatchWhereUniqueInput | MatchWhereUniqueInput[]
    disconnect?: MatchWhereUniqueInput | MatchWhereUniqueInput[]
    delete?: MatchWhereUniqueInput | MatchWhereUniqueInput[]
    connect?: MatchWhereUniqueInput | MatchWhereUniqueInput[]
    update?: MatchUpdateWithWhereUniqueWithoutRoundInput | MatchUpdateWithWhereUniqueWithoutRoundInput[]
    updateMany?: MatchUpdateManyWithWhereWithoutRoundInput | MatchUpdateManyWithWhereWithoutRoundInput[]
    deleteMany?: MatchScalarWhereInput | MatchScalarWhereInput[]
  }

  export type MatchUncheckedUpdateManyWithoutRoundNestedInput = {
    create?: XOR<MatchCreateWithoutRoundInput, MatchUncheckedCreateWithoutRoundInput> | MatchCreateWithoutRoundInput[] | MatchUncheckedCreateWithoutRoundInput[]
    connectOrCreate?: MatchCreateOrConnectWithoutRoundInput | MatchCreateOrConnectWithoutRoundInput[]
    upsert?: MatchUpsertWithWhereUniqueWithoutRoundInput | MatchUpsertWithWhereUniqueWithoutRoundInput[]
    createMany?: MatchCreateManyRoundInputEnvelope
    set?: MatchWhereUniqueInput | MatchWhereUniqueInput[]
    disconnect?: MatchWhereUniqueInput | MatchWhereUniqueInput[]
    delete?: MatchWhereUniqueInput | MatchWhereUniqueInput[]
    connect?: MatchWhereUniqueInput | MatchWhereUniqueInput[]
    update?: MatchUpdateWithWhereUniqueWithoutRoundInput | MatchUpdateWithWhereUniqueWithoutRoundInput[]
    updateMany?: MatchUpdateManyWithWhereWithoutRoundInput | MatchUpdateManyWithWhereWithoutRoundInput[]
    deleteMany?: MatchScalarWhereInput | MatchScalarWhereInput[]
  }

  export type MatchCreateNestedOneWithoutEventsInput = {
    create?: XOR<MatchCreateWithoutEventsInput, MatchUncheckedCreateWithoutEventsInput>
    connectOrCreate?: MatchCreateOrConnectWithoutEventsInput
    connect?: MatchWhereUniqueInput
  }

  export type PlayerCreateNestedOneWithoutEventsInput = {
    create?: XOR<PlayerCreateWithoutEventsInput, PlayerUncheckedCreateWithoutEventsInput>
    connectOrCreate?: PlayerCreateOrConnectWithoutEventsInput
    connect?: PlayerWhereUniqueInput
  }

  export type EnumEventTypeFieldUpdateOperationsInput = {
    set?: $Enums.EventType
  }

  export type MatchUpdateOneRequiredWithoutEventsNestedInput = {
    create?: XOR<MatchCreateWithoutEventsInput, MatchUncheckedCreateWithoutEventsInput>
    connectOrCreate?: MatchCreateOrConnectWithoutEventsInput
    upsert?: MatchUpsertWithoutEventsInput
    connect?: MatchWhereUniqueInput
    update?: XOR<XOR<MatchUpdateToOneWithWhereWithoutEventsInput, MatchUpdateWithoutEventsInput>, MatchUncheckedUpdateWithoutEventsInput>
  }

  export type PlayerUpdateOneRequiredWithoutEventsNestedInput = {
    create?: XOR<PlayerCreateWithoutEventsInput, PlayerUncheckedCreateWithoutEventsInput>
    connectOrCreate?: PlayerCreateOrConnectWithoutEventsInput
    upsert?: PlayerUpsertWithoutEventsInput
    connect?: PlayerWhereUniqueInput
    update?: XOR<XOR<PlayerUpdateToOneWithWhereWithoutEventsInput, PlayerUpdateWithoutEventsInput>, PlayerUncheckedUpdateWithoutEventsInput>
  }

  export type MatchLineupCreateplayerIdsInput = {
    set: string[]
  }

  export type MatchCreateNestedOneWithoutLineupsInput = {
    create?: XOR<MatchCreateWithoutLineupsInput, MatchUncheckedCreateWithoutLineupsInput>
    connectOrCreate?: MatchCreateOrConnectWithoutLineupsInput
    connect?: MatchWhereUniqueInput
  }

  export type MatchLineupUpdateplayerIdsInput = {
    set?: string[]
    push?: string | string[]
  }

  export type MatchUpdateOneRequiredWithoutLineupsNestedInput = {
    create?: XOR<MatchCreateWithoutLineupsInput, MatchUncheckedCreateWithoutLineupsInput>
    connectOrCreate?: MatchCreateOrConnectWithoutLineupsInput
    upsert?: MatchUpsertWithoutLineupsInput
    connect?: MatchWhereUniqueInput
    update?: XOR<XOR<MatchUpdateToOneWithWhereWithoutLineupsInput, MatchUpdateWithoutLineupsInput>, MatchUncheckedUpdateWithoutLineupsInput>
  }

  export type PlayerCreateNestedOneWithoutMatchStatsInput = {
    create?: XOR<PlayerCreateWithoutMatchStatsInput, PlayerUncheckedCreateWithoutMatchStatsInput>
    connectOrCreate?: PlayerCreateOrConnectWithoutMatchStatsInput
    connect?: PlayerWhereUniqueInput
  }

  export type MatchCreateNestedOneWithoutPlayerStatsInput = {
    create?: XOR<MatchCreateWithoutPlayerStatsInput, MatchUncheckedCreateWithoutPlayerStatsInput>
    connectOrCreate?: MatchCreateOrConnectWithoutPlayerStatsInput
    connect?: MatchWhereUniqueInput
  }

  export type PlayerUpdateOneRequiredWithoutMatchStatsNestedInput = {
    create?: XOR<PlayerCreateWithoutMatchStatsInput, PlayerUncheckedCreateWithoutMatchStatsInput>
    connectOrCreate?: PlayerCreateOrConnectWithoutMatchStatsInput
    upsert?: PlayerUpsertWithoutMatchStatsInput
    connect?: PlayerWhereUniqueInput
    update?: XOR<XOR<PlayerUpdateToOneWithWhereWithoutMatchStatsInput, PlayerUpdateWithoutMatchStatsInput>, PlayerUncheckedUpdateWithoutMatchStatsInput>
  }

  export type MatchUpdateOneRequiredWithoutPlayerStatsNestedInput = {
    create?: XOR<MatchCreateWithoutPlayerStatsInput, MatchUncheckedCreateWithoutPlayerStatsInput>
    connectOrCreate?: MatchCreateOrConnectWithoutPlayerStatsInput
    upsert?: MatchUpsertWithoutPlayerStatsInput
    connect?: MatchWhereUniqueInput
    update?: XOR<XOR<MatchUpdateToOneWithWhereWithoutPlayerStatsInput, MatchUpdateWithoutPlayerStatsInput>, MatchUncheckedUpdateWithoutPlayerStatsInput>
  }

  export type TeamCreateNestedOneWithoutUserInput = {
    create?: XOR<TeamCreateWithoutUserInput, TeamUncheckedCreateWithoutUserInput>
    connectOrCreate?: TeamCreateOrConnectWithoutUserInput
    connect?: TeamWhereUniqueInput
  }

  export type SessionCreateNestedManyWithoutUserInput = {
    create?: XOR<SessionCreateWithoutUserInput, SessionUncheckedCreateWithoutUserInput> | SessionCreateWithoutUserInput[] | SessionUncheckedCreateWithoutUserInput[]
    connectOrCreate?: SessionCreateOrConnectWithoutUserInput | SessionCreateOrConnectWithoutUserInput[]
    createMany?: SessionCreateManyUserInputEnvelope
    connect?: SessionWhereUniqueInput | SessionWhereUniqueInput[]
  }

  export type PaymentCreateNestedManyWithoutUserInput = {
    create?: XOR<PaymentCreateWithoutUserInput, PaymentUncheckedCreateWithoutUserInput> | PaymentCreateWithoutUserInput[] | PaymentUncheckedCreateWithoutUserInput[]
    connectOrCreate?: PaymentCreateOrConnectWithoutUserInput | PaymentCreateOrConnectWithoutUserInput[]
    createMany?: PaymentCreateManyUserInputEnvelope
    connect?: PaymentWhereUniqueInput | PaymentWhereUniqueInput[]
  }

  export type QuizSubmissionCreateNestedManyWithoutUserInput = {
    create?: XOR<QuizSubmissionCreateWithoutUserInput, QuizSubmissionUncheckedCreateWithoutUserInput> | QuizSubmissionCreateWithoutUserInput[] | QuizSubmissionUncheckedCreateWithoutUserInput[]
    connectOrCreate?: QuizSubmissionCreateOrConnectWithoutUserInput | QuizSubmissionCreateOrConnectWithoutUserInput[]
    createMany?: QuizSubmissionCreateManyUserInputEnvelope
    connect?: QuizSubmissionWhereUniqueInput | QuizSubmissionWhereUniqueInput[]
  }

  export type GoldenCardCreateNestedManyWithoutUserInput = {
    create?: XOR<GoldenCardCreateWithoutUserInput, GoldenCardUncheckedCreateWithoutUserInput> | GoldenCardCreateWithoutUserInput[] | GoldenCardUncheckedCreateWithoutUserInput[]
    connectOrCreate?: GoldenCardCreateOrConnectWithoutUserInput | GoldenCardCreateOrConnectWithoutUserInput[]
    createMany?: GoldenCardCreateManyUserInputEnvelope
    connect?: GoldenCardWhereUniqueInput | GoldenCardWhereUniqueInput[]
  }

  export type TeamUncheckedCreateNestedOneWithoutUserInput = {
    create?: XOR<TeamCreateWithoutUserInput, TeamUncheckedCreateWithoutUserInput>
    connectOrCreate?: TeamCreateOrConnectWithoutUserInput
    connect?: TeamWhereUniqueInput
  }

  export type SessionUncheckedCreateNestedManyWithoutUserInput = {
    create?: XOR<SessionCreateWithoutUserInput, SessionUncheckedCreateWithoutUserInput> | SessionCreateWithoutUserInput[] | SessionUncheckedCreateWithoutUserInput[]
    connectOrCreate?: SessionCreateOrConnectWithoutUserInput | SessionCreateOrConnectWithoutUserInput[]
    createMany?: SessionCreateManyUserInputEnvelope
    connect?: SessionWhereUniqueInput | SessionWhereUniqueInput[]
  }

  export type PaymentUncheckedCreateNestedManyWithoutUserInput = {
    create?: XOR<PaymentCreateWithoutUserInput, PaymentUncheckedCreateWithoutUserInput> | PaymentCreateWithoutUserInput[] | PaymentUncheckedCreateWithoutUserInput[]
    connectOrCreate?: PaymentCreateOrConnectWithoutUserInput | PaymentCreateOrConnectWithoutUserInput[]
    createMany?: PaymentCreateManyUserInputEnvelope
    connect?: PaymentWhereUniqueInput | PaymentWhereUniqueInput[]
  }

  export type QuizSubmissionUncheckedCreateNestedManyWithoutUserInput = {
    create?: XOR<QuizSubmissionCreateWithoutUserInput, QuizSubmissionUncheckedCreateWithoutUserInput> | QuizSubmissionCreateWithoutUserInput[] | QuizSubmissionUncheckedCreateWithoutUserInput[]
    connectOrCreate?: QuizSubmissionCreateOrConnectWithoutUserInput | QuizSubmissionCreateOrConnectWithoutUserInput[]
    createMany?: QuizSubmissionCreateManyUserInputEnvelope
    connect?: QuizSubmissionWhereUniqueInput | QuizSubmissionWhereUniqueInput[]
  }

  export type GoldenCardUncheckedCreateNestedManyWithoutUserInput = {
    create?: XOR<GoldenCardCreateWithoutUserInput, GoldenCardUncheckedCreateWithoutUserInput> | GoldenCardCreateWithoutUserInput[] | GoldenCardUncheckedCreateWithoutUserInput[]
    connectOrCreate?: GoldenCardCreateOrConnectWithoutUserInput | GoldenCardCreateOrConnectWithoutUserInput[]
    createMany?: GoldenCardCreateManyUserInputEnvelope
    connect?: GoldenCardWhereUniqueInput | GoldenCardWhereUniqueInput[]
  }

  export type EnumRoleFieldUpdateOperationsInput = {
    set?: $Enums.Role
  }

  export type TeamUpdateOneWithoutUserNestedInput = {
    create?: XOR<TeamCreateWithoutUserInput, TeamUncheckedCreateWithoutUserInput>
    connectOrCreate?: TeamCreateOrConnectWithoutUserInput
    upsert?: TeamUpsertWithoutUserInput
    disconnect?: TeamWhereInput | boolean
    delete?: TeamWhereInput | boolean
    connect?: TeamWhereUniqueInput
    update?: XOR<XOR<TeamUpdateToOneWithWhereWithoutUserInput, TeamUpdateWithoutUserInput>, TeamUncheckedUpdateWithoutUserInput>
  }

  export type SessionUpdateManyWithoutUserNestedInput = {
    create?: XOR<SessionCreateWithoutUserInput, SessionUncheckedCreateWithoutUserInput> | SessionCreateWithoutUserInput[] | SessionUncheckedCreateWithoutUserInput[]
    connectOrCreate?: SessionCreateOrConnectWithoutUserInput | SessionCreateOrConnectWithoutUserInput[]
    upsert?: SessionUpsertWithWhereUniqueWithoutUserInput | SessionUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: SessionCreateManyUserInputEnvelope
    set?: SessionWhereUniqueInput | SessionWhereUniqueInput[]
    disconnect?: SessionWhereUniqueInput | SessionWhereUniqueInput[]
    delete?: SessionWhereUniqueInput | SessionWhereUniqueInput[]
    connect?: SessionWhereUniqueInput | SessionWhereUniqueInput[]
    update?: SessionUpdateWithWhereUniqueWithoutUserInput | SessionUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: SessionUpdateManyWithWhereWithoutUserInput | SessionUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: SessionScalarWhereInput | SessionScalarWhereInput[]
  }

  export type PaymentUpdateManyWithoutUserNestedInput = {
    create?: XOR<PaymentCreateWithoutUserInput, PaymentUncheckedCreateWithoutUserInput> | PaymentCreateWithoutUserInput[] | PaymentUncheckedCreateWithoutUserInput[]
    connectOrCreate?: PaymentCreateOrConnectWithoutUserInput | PaymentCreateOrConnectWithoutUserInput[]
    upsert?: PaymentUpsertWithWhereUniqueWithoutUserInput | PaymentUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: PaymentCreateManyUserInputEnvelope
    set?: PaymentWhereUniqueInput | PaymentWhereUniqueInput[]
    disconnect?: PaymentWhereUniqueInput | PaymentWhereUniqueInput[]
    delete?: PaymentWhereUniqueInput | PaymentWhereUniqueInput[]
    connect?: PaymentWhereUniqueInput | PaymentWhereUniqueInput[]
    update?: PaymentUpdateWithWhereUniqueWithoutUserInput | PaymentUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: PaymentUpdateManyWithWhereWithoutUserInput | PaymentUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: PaymentScalarWhereInput | PaymentScalarWhereInput[]
  }

  export type QuizSubmissionUpdateManyWithoutUserNestedInput = {
    create?: XOR<QuizSubmissionCreateWithoutUserInput, QuizSubmissionUncheckedCreateWithoutUserInput> | QuizSubmissionCreateWithoutUserInput[] | QuizSubmissionUncheckedCreateWithoutUserInput[]
    connectOrCreate?: QuizSubmissionCreateOrConnectWithoutUserInput | QuizSubmissionCreateOrConnectWithoutUserInput[]
    upsert?: QuizSubmissionUpsertWithWhereUniqueWithoutUserInput | QuizSubmissionUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: QuizSubmissionCreateManyUserInputEnvelope
    set?: QuizSubmissionWhereUniqueInput | QuizSubmissionWhereUniqueInput[]
    disconnect?: QuizSubmissionWhereUniqueInput | QuizSubmissionWhereUniqueInput[]
    delete?: QuizSubmissionWhereUniqueInput | QuizSubmissionWhereUniqueInput[]
    connect?: QuizSubmissionWhereUniqueInput | QuizSubmissionWhereUniqueInput[]
    update?: QuizSubmissionUpdateWithWhereUniqueWithoutUserInput | QuizSubmissionUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: QuizSubmissionUpdateManyWithWhereWithoutUserInput | QuizSubmissionUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: QuizSubmissionScalarWhereInput | QuizSubmissionScalarWhereInput[]
  }

  export type GoldenCardUpdateManyWithoutUserNestedInput = {
    create?: XOR<GoldenCardCreateWithoutUserInput, GoldenCardUncheckedCreateWithoutUserInput> | GoldenCardCreateWithoutUserInput[] | GoldenCardUncheckedCreateWithoutUserInput[]
    connectOrCreate?: GoldenCardCreateOrConnectWithoutUserInput | GoldenCardCreateOrConnectWithoutUserInput[]
    upsert?: GoldenCardUpsertWithWhereUniqueWithoutUserInput | GoldenCardUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: GoldenCardCreateManyUserInputEnvelope
    set?: GoldenCardWhereUniqueInput | GoldenCardWhereUniqueInput[]
    disconnect?: GoldenCardWhereUniqueInput | GoldenCardWhereUniqueInput[]
    delete?: GoldenCardWhereUniqueInput | GoldenCardWhereUniqueInput[]
    connect?: GoldenCardWhereUniqueInput | GoldenCardWhereUniqueInput[]
    update?: GoldenCardUpdateWithWhereUniqueWithoutUserInput | GoldenCardUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: GoldenCardUpdateManyWithWhereWithoutUserInput | GoldenCardUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: GoldenCardScalarWhereInput | GoldenCardScalarWhereInput[]
  }

  export type TeamUncheckedUpdateOneWithoutUserNestedInput = {
    create?: XOR<TeamCreateWithoutUserInput, TeamUncheckedCreateWithoutUserInput>
    connectOrCreate?: TeamCreateOrConnectWithoutUserInput
    upsert?: TeamUpsertWithoutUserInput
    disconnect?: TeamWhereInput | boolean
    delete?: TeamWhereInput | boolean
    connect?: TeamWhereUniqueInput
    update?: XOR<XOR<TeamUpdateToOneWithWhereWithoutUserInput, TeamUpdateWithoutUserInput>, TeamUncheckedUpdateWithoutUserInput>
  }

  export type SessionUncheckedUpdateManyWithoutUserNestedInput = {
    create?: XOR<SessionCreateWithoutUserInput, SessionUncheckedCreateWithoutUserInput> | SessionCreateWithoutUserInput[] | SessionUncheckedCreateWithoutUserInput[]
    connectOrCreate?: SessionCreateOrConnectWithoutUserInput | SessionCreateOrConnectWithoutUserInput[]
    upsert?: SessionUpsertWithWhereUniqueWithoutUserInput | SessionUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: SessionCreateManyUserInputEnvelope
    set?: SessionWhereUniqueInput | SessionWhereUniqueInput[]
    disconnect?: SessionWhereUniqueInput | SessionWhereUniqueInput[]
    delete?: SessionWhereUniqueInput | SessionWhereUniqueInput[]
    connect?: SessionWhereUniqueInput | SessionWhereUniqueInput[]
    update?: SessionUpdateWithWhereUniqueWithoutUserInput | SessionUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: SessionUpdateManyWithWhereWithoutUserInput | SessionUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: SessionScalarWhereInput | SessionScalarWhereInput[]
  }

  export type PaymentUncheckedUpdateManyWithoutUserNestedInput = {
    create?: XOR<PaymentCreateWithoutUserInput, PaymentUncheckedCreateWithoutUserInput> | PaymentCreateWithoutUserInput[] | PaymentUncheckedCreateWithoutUserInput[]
    connectOrCreate?: PaymentCreateOrConnectWithoutUserInput | PaymentCreateOrConnectWithoutUserInput[]
    upsert?: PaymentUpsertWithWhereUniqueWithoutUserInput | PaymentUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: PaymentCreateManyUserInputEnvelope
    set?: PaymentWhereUniqueInput | PaymentWhereUniqueInput[]
    disconnect?: PaymentWhereUniqueInput | PaymentWhereUniqueInput[]
    delete?: PaymentWhereUniqueInput | PaymentWhereUniqueInput[]
    connect?: PaymentWhereUniqueInput | PaymentWhereUniqueInput[]
    update?: PaymentUpdateWithWhereUniqueWithoutUserInput | PaymentUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: PaymentUpdateManyWithWhereWithoutUserInput | PaymentUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: PaymentScalarWhereInput | PaymentScalarWhereInput[]
  }

  export type QuizSubmissionUncheckedUpdateManyWithoutUserNestedInput = {
    create?: XOR<QuizSubmissionCreateWithoutUserInput, QuizSubmissionUncheckedCreateWithoutUserInput> | QuizSubmissionCreateWithoutUserInput[] | QuizSubmissionUncheckedCreateWithoutUserInput[]
    connectOrCreate?: QuizSubmissionCreateOrConnectWithoutUserInput | QuizSubmissionCreateOrConnectWithoutUserInput[]
    upsert?: QuizSubmissionUpsertWithWhereUniqueWithoutUserInput | QuizSubmissionUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: QuizSubmissionCreateManyUserInputEnvelope
    set?: QuizSubmissionWhereUniqueInput | QuizSubmissionWhereUniqueInput[]
    disconnect?: QuizSubmissionWhereUniqueInput | QuizSubmissionWhereUniqueInput[]
    delete?: QuizSubmissionWhereUniqueInput | QuizSubmissionWhereUniqueInput[]
    connect?: QuizSubmissionWhereUniqueInput | QuizSubmissionWhereUniqueInput[]
    update?: QuizSubmissionUpdateWithWhereUniqueWithoutUserInput | QuizSubmissionUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: QuizSubmissionUpdateManyWithWhereWithoutUserInput | QuizSubmissionUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: QuizSubmissionScalarWhereInput | QuizSubmissionScalarWhereInput[]
  }

  export type GoldenCardUncheckedUpdateManyWithoutUserNestedInput = {
    create?: XOR<GoldenCardCreateWithoutUserInput, GoldenCardUncheckedCreateWithoutUserInput> | GoldenCardCreateWithoutUserInput[] | GoldenCardUncheckedCreateWithoutUserInput[]
    connectOrCreate?: GoldenCardCreateOrConnectWithoutUserInput | GoldenCardCreateOrConnectWithoutUserInput[]
    upsert?: GoldenCardUpsertWithWhereUniqueWithoutUserInput | GoldenCardUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: GoldenCardCreateManyUserInputEnvelope
    set?: GoldenCardWhereUniqueInput | GoldenCardWhereUniqueInput[]
    disconnect?: GoldenCardWhereUniqueInput | GoldenCardWhereUniqueInput[]
    delete?: GoldenCardWhereUniqueInput | GoldenCardWhereUniqueInput[]
    connect?: GoldenCardWhereUniqueInput | GoldenCardWhereUniqueInput[]
    update?: GoldenCardUpdateWithWhereUniqueWithoutUserInput | GoldenCardUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: GoldenCardUpdateManyWithWhereWithoutUserInput | GoldenCardUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: GoldenCardScalarWhereInput | GoldenCardScalarWhereInput[]
  }

  export type NullableDateTimeFieldUpdateOperationsInput = {
    set?: Date | string | null
  }

  export type QuizQuestionCreateNestedManyWithoutQuizInput = {
    create?: XOR<QuizQuestionCreateWithoutQuizInput, QuizQuestionUncheckedCreateWithoutQuizInput> | QuizQuestionCreateWithoutQuizInput[] | QuizQuestionUncheckedCreateWithoutQuizInput[]
    connectOrCreate?: QuizQuestionCreateOrConnectWithoutQuizInput | QuizQuestionCreateOrConnectWithoutQuizInput[]
    createMany?: QuizQuestionCreateManyQuizInputEnvelope
    connect?: QuizQuestionWhereUniqueInput | QuizQuestionWhereUniqueInput[]
  }

  export type QuizSubmissionCreateNestedManyWithoutQuizInput = {
    create?: XOR<QuizSubmissionCreateWithoutQuizInput, QuizSubmissionUncheckedCreateWithoutQuizInput> | QuizSubmissionCreateWithoutQuizInput[] | QuizSubmissionUncheckedCreateWithoutQuizInput[]
    connectOrCreate?: QuizSubmissionCreateOrConnectWithoutQuizInput | QuizSubmissionCreateOrConnectWithoutQuizInput[]
    createMany?: QuizSubmissionCreateManyQuizInputEnvelope
    connect?: QuizSubmissionWhereUniqueInput | QuizSubmissionWhereUniqueInput[]
  }

  export type GoldenCardCreateNestedManyWithoutQuizInput = {
    create?: XOR<GoldenCardCreateWithoutQuizInput, GoldenCardUncheckedCreateWithoutQuizInput> | GoldenCardCreateWithoutQuizInput[] | GoldenCardUncheckedCreateWithoutQuizInput[]
    connectOrCreate?: GoldenCardCreateOrConnectWithoutQuizInput | GoldenCardCreateOrConnectWithoutQuizInput[]
    createMany?: GoldenCardCreateManyQuizInputEnvelope
    connect?: GoldenCardWhereUniqueInput | GoldenCardWhereUniqueInput[]
  }

  export type QuizQuestionUncheckedCreateNestedManyWithoutQuizInput = {
    create?: XOR<QuizQuestionCreateWithoutQuizInput, QuizQuestionUncheckedCreateWithoutQuizInput> | QuizQuestionCreateWithoutQuizInput[] | QuizQuestionUncheckedCreateWithoutQuizInput[]
    connectOrCreate?: QuizQuestionCreateOrConnectWithoutQuizInput | QuizQuestionCreateOrConnectWithoutQuizInput[]
    createMany?: QuizQuestionCreateManyQuizInputEnvelope
    connect?: QuizQuestionWhereUniqueInput | QuizQuestionWhereUniqueInput[]
  }

  export type QuizSubmissionUncheckedCreateNestedManyWithoutQuizInput = {
    create?: XOR<QuizSubmissionCreateWithoutQuizInput, QuizSubmissionUncheckedCreateWithoutQuizInput> | QuizSubmissionCreateWithoutQuizInput[] | QuizSubmissionUncheckedCreateWithoutQuizInput[]
    connectOrCreate?: QuizSubmissionCreateOrConnectWithoutQuizInput | QuizSubmissionCreateOrConnectWithoutQuizInput[]
    createMany?: QuizSubmissionCreateManyQuizInputEnvelope
    connect?: QuizSubmissionWhereUniqueInput | QuizSubmissionWhereUniqueInput[]
  }

  export type GoldenCardUncheckedCreateNestedManyWithoutQuizInput = {
    create?: XOR<GoldenCardCreateWithoutQuizInput, GoldenCardUncheckedCreateWithoutQuizInput> | GoldenCardCreateWithoutQuizInput[] | GoldenCardUncheckedCreateWithoutQuizInput[]
    connectOrCreate?: GoldenCardCreateOrConnectWithoutQuizInput | GoldenCardCreateOrConnectWithoutQuizInput[]
    createMany?: GoldenCardCreateManyQuizInputEnvelope
    connect?: GoldenCardWhereUniqueInput | GoldenCardWhereUniqueInput[]
  }

  export type QuizQuestionUpdateManyWithoutQuizNestedInput = {
    create?: XOR<QuizQuestionCreateWithoutQuizInput, QuizQuestionUncheckedCreateWithoutQuizInput> | QuizQuestionCreateWithoutQuizInput[] | QuizQuestionUncheckedCreateWithoutQuizInput[]
    connectOrCreate?: QuizQuestionCreateOrConnectWithoutQuizInput | QuizQuestionCreateOrConnectWithoutQuizInput[]
    upsert?: QuizQuestionUpsertWithWhereUniqueWithoutQuizInput | QuizQuestionUpsertWithWhereUniqueWithoutQuizInput[]
    createMany?: QuizQuestionCreateManyQuizInputEnvelope
    set?: QuizQuestionWhereUniqueInput | QuizQuestionWhereUniqueInput[]
    disconnect?: QuizQuestionWhereUniqueInput | QuizQuestionWhereUniqueInput[]
    delete?: QuizQuestionWhereUniqueInput | QuizQuestionWhereUniqueInput[]
    connect?: QuizQuestionWhereUniqueInput | QuizQuestionWhereUniqueInput[]
    update?: QuizQuestionUpdateWithWhereUniqueWithoutQuizInput | QuizQuestionUpdateWithWhereUniqueWithoutQuizInput[]
    updateMany?: QuizQuestionUpdateManyWithWhereWithoutQuizInput | QuizQuestionUpdateManyWithWhereWithoutQuizInput[]
    deleteMany?: QuizQuestionScalarWhereInput | QuizQuestionScalarWhereInput[]
  }

  export type QuizSubmissionUpdateManyWithoutQuizNestedInput = {
    create?: XOR<QuizSubmissionCreateWithoutQuizInput, QuizSubmissionUncheckedCreateWithoutQuizInput> | QuizSubmissionCreateWithoutQuizInput[] | QuizSubmissionUncheckedCreateWithoutQuizInput[]
    connectOrCreate?: QuizSubmissionCreateOrConnectWithoutQuizInput | QuizSubmissionCreateOrConnectWithoutQuizInput[]
    upsert?: QuizSubmissionUpsertWithWhereUniqueWithoutQuizInput | QuizSubmissionUpsertWithWhereUniqueWithoutQuizInput[]
    createMany?: QuizSubmissionCreateManyQuizInputEnvelope
    set?: QuizSubmissionWhereUniqueInput | QuizSubmissionWhereUniqueInput[]
    disconnect?: QuizSubmissionWhereUniqueInput | QuizSubmissionWhereUniqueInput[]
    delete?: QuizSubmissionWhereUniqueInput | QuizSubmissionWhereUniqueInput[]
    connect?: QuizSubmissionWhereUniqueInput | QuizSubmissionWhereUniqueInput[]
    update?: QuizSubmissionUpdateWithWhereUniqueWithoutQuizInput | QuizSubmissionUpdateWithWhereUniqueWithoutQuizInput[]
    updateMany?: QuizSubmissionUpdateManyWithWhereWithoutQuizInput | QuizSubmissionUpdateManyWithWhereWithoutQuizInput[]
    deleteMany?: QuizSubmissionScalarWhereInput | QuizSubmissionScalarWhereInput[]
  }

  export type GoldenCardUpdateManyWithoutQuizNestedInput = {
    create?: XOR<GoldenCardCreateWithoutQuizInput, GoldenCardUncheckedCreateWithoutQuizInput> | GoldenCardCreateWithoutQuizInput[] | GoldenCardUncheckedCreateWithoutQuizInput[]
    connectOrCreate?: GoldenCardCreateOrConnectWithoutQuizInput | GoldenCardCreateOrConnectWithoutQuizInput[]
    upsert?: GoldenCardUpsertWithWhereUniqueWithoutQuizInput | GoldenCardUpsertWithWhereUniqueWithoutQuizInput[]
    createMany?: GoldenCardCreateManyQuizInputEnvelope
    set?: GoldenCardWhereUniqueInput | GoldenCardWhereUniqueInput[]
    disconnect?: GoldenCardWhereUniqueInput | GoldenCardWhereUniqueInput[]
    delete?: GoldenCardWhereUniqueInput | GoldenCardWhereUniqueInput[]
    connect?: GoldenCardWhereUniqueInput | GoldenCardWhereUniqueInput[]
    update?: GoldenCardUpdateWithWhereUniqueWithoutQuizInput | GoldenCardUpdateWithWhereUniqueWithoutQuizInput[]
    updateMany?: GoldenCardUpdateManyWithWhereWithoutQuizInput | GoldenCardUpdateManyWithWhereWithoutQuizInput[]
    deleteMany?: GoldenCardScalarWhereInput | GoldenCardScalarWhereInput[]
  }

  export type QuizQuestionUncheckedUpdateManyWithoutQuizNestedInput = {
    create?: XOR<QuizQuestionCreateWithoutQuizInput, QuizQuestionUncheckedCreateWithoutQuizInput> | QuizQuestionCreateWithoutQuizInput[] | QuizQuestionUncheckedCreateWithoutQuizInput[]
    connectOrCreate?: QuizQuestionCreateOrConnectWithoutQuizInput | QuizQuestionCreateOrConnectWithoutQuizInput[]
    upsert?: QuizQuestionUpsertWithWhereUniqueWithoutQuizInput | QuizQuestionUpsertWithWhereUniqueWithoutQuizInput[]
    createMany?: QuizQuestionCreateManyQuizInputEnvelope
    set?: QuizQuestionWhereUniqueInput | QuizQuestionWhereUniqueInput[]
    disconnect?: QuizQuestionWhereUniqueInput | QuizQuestionWhereUniqueInput[]
    delete?: QuizQuestionWhereUniqueInput | QuizQuestionWhereUniqueInput[]
    connect?: QuizQuestionWhereUniqueInput | QuizQuestionWhereUniqueInput[]
    update?: QuizQuestionUpdateWithWhereUniqueWithoutQuizInput | QuizQuestionUpdateWithWhereUniqueWithoutQuizInput[]
    updateMany?: QuizQuestionUpdateManyWithWhereWithoutQuizInput | QuizQuestionUpdateManyWithWhereWithoutQuizInput[]
    deleteMany?: QuizQuestionScalarWhereInput | QuizQuestionScalarWhereInput[]
  }

  export type QuizSubmissionUncheckedUpdateManyWithoutQuizNestedInput = {
    create?: XOR<QuizSubmissionCreateWithoutQuizInput, QuizSubmissionUncheckedCreateWithoutQuizInput> | QuizSubmissionCreateWithoutQuizInput[] | QuizSubmissionUncheckedCreateWithoutQuizInput[]
    connectOrCreate?: QuizSubmissionCreateOrConnectWithoutQuizInput | QuizSubmissionCreateOrConnectWithoutQuizInput[]
    upsert?: QuizSubmissionUpsertWithWhereUniqueWithoutQuizInput | QuizSubmissionUpsertWithWhereUniqueWithoutQuizInput[]
    createMany?: QuizSubmissionCreateManyQuizInputEnvelope
    set?: QuizSubmissionWhereUniqueInput | QuizSubmissionWhereUniqueInput[]
    disconnect?: QuizSubmissionWhereUniqueInput | QuizSubmissionWhereUniqueInput[]
    delete?: QuizSubmissionWhereUniqueInput | QuizSubmissionWhereUniqueInput[]
    connect?: QuizSubmissionWhereUniqueInput | QuizSubmissionWhereUniqueInput[]
    update?: QuizSubmissionUpdateWithWhereUniqueWithoutQuizInput | QuizSubmissionUpdateWithWhereUniqueWithoutQuizInput[]
    updateMany?: QuizSubmissionUpdateManyWithWhereWithoutQuizInput | QuizSubmissionUpdateManyWithWhereWithoutQuizInput[]
    deleteMany?: QuizSubmissionScalarWhereInput | QuizSubmissionScalarWhereInput[]
  }

  export type GoldenCardUncheckedUpdateManyWithoutQuizNestedInput = {
    create?: XOR<GoldenCardCreateWithoutQuizInput, GoldenCardUncheckedCreateWithoutQuizInput> | GoldenCardCreateWithoutQuizInput[] | GoldenCardUncheckedCreateWithoutQuizInput[]
    connectOrCreate?: GoldenCardCreateOrConnectWithoutQuizInput | GoldenCardCreateOrConnectWithoutQuizInput[]
    upsert?: GoldenCardUpsertWithWhereUniqueWithoutQuizInput | GoldenCardUpsertWithWhereUniqueWithoutQuizInput[]
    createMany?: GoldenCardCreateManyQuizInputEnvelope
    set?: GoldenCardWhereUniqueInput | GoldenCardWhereUniqueInput[]
    disconnect?: GoldenCardWhereUniqueInput | GoldenCardWhereUniqueInput[]
    delete?: GoldenCardWhereUniqueInput | GoldenCardWhereUniqueInput[]
    connect?: GoldenCardWhereUniqueInput | GoldenCardWhereUniqueInput[]
    update?: GoldenCardUpdateWithWhereUniqueWithoutQuizInput | GoldenCardUpdateWithWhereUniqueWithoutQuizInput[]
    updateMany?: GoldenCardUpdateManyWithWhereWithoutQuizInput | GoldenCardUpdateManyWithWhereWithoutQuizInput[]
    deleteMany?: GoldenCardScalarWhereInput | GoldenCardScalarWhereInput[]
  }

  export type QuizQuestionCreateoptionsInput = {
    set: string[]
  }

  export type DailyQuizCreateNestedOneWithoutQuestionsInput = {
    create?: XOR<DailyQuizCreateWithoutQuestionsInput, DailyQuizUncheckedCreateWithoutQuestionsInput>
    connectOrCreate?: DailyQuizCreateOrConnectWithoutQuestionsInput
    connect?: DailyQuizWhereUniqueInput
  }

  export type QuizQuestionUpdateoptionsInput = {
    set?: string[]
    push?: string | string[]
  }

  export type DailyQuizUpdateOneRequiredWithoutQuestionsNestedInput = {
    create?: XOR<DailyQuizCreateWithoutQuestionsInput, DailyQuizUncheckedCreateWithoutQuestionsInput>
    connectOrCreate?: DailyQuizCreateOrConnectWithoutQuestionsInput
    upsert?: DailyQuizUpsertWithoutQuestionsInput
    connect?: DailyQuizWhereUniqueInput
    update?: XOR<XOR<DailyQuizUpdateToOneWithWhereWithoutQuestionsInput, DailyQuizUpdateWithoutQuestionsInput>, DailyQuizUncheckedUpdateWithoutQuestionsInput>
  }

  export type QuizSubmissionCreateanswersInput = {
    set: number[]
  }

  export type UserCreateNestedOneWithoutQuizSubmissionsInput = {
    create?: XOR<UserCreateWithoutQuizSubmissionsInput, UserUncheckedCreateWithoutQuizSubmissionsInput>
    connectOrCreate?: UserCreateOrConnectWithoutQuizSubmissionsInput
    connect?: UserWhereUniqueInput
  }

  export type DailyQuizCreateNestedOneWithoutSubmissionsInput = {
    create?: XOR<DailyQuizCreateWithoutSubmissionsInput, DailyQuizUncheckedCreateWithoutSubmissionsInput>
    connectOrCreate?: DailyQuizCreateOrConnectWithoutSubmissionsInput
    connect?: DailyQuizWhereUniqueInput
  }

  export type QuizSubmissionUpdateanswersInput = {
    set?: number[]
    push?: number | number[]
  }

  export type UserUpdateOneRequiredWithoutQuizSubmissionsNestedInput = {
    create?: XOR<UserCreateWithoutQuizSubmissionsInput, UserUncheckedCreateWithoutQuizSubmissionsInput>
    connectOrCreate?: UserCreateOrConnectWithoutQuizSubmissionsInput
    upsert?: UserUpsertWithoutQuizSubmissionsInput
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutQuizSubmissionsInput, UserUpdateWithoutQuizSubmissionsInput>, UserUncheckedUpdateWithoutQuizSubmissionsInput>
  }

  export type DailyQuizUpdateOneRequiredWithoutSubmissionsNestedInput = {
    create?: XOR<DailyQuizCreateWithoutSubmissionsInput, DailyQuizUncheckedCreateWithoutSubmissionsInput>
    connectOrCreate?: DailyQuizCreateOrConnectWithoutSubmissionsInput
    upsert?: DailyQuizUpsertWithoutSubmissionsInput
    connect?: DailyQuizWhereUniqueInput
    update?: XOR<XOR<DailyQuizUpdateToOneWithWhereWithoutSubmissionsInput, DailyQuizUpdateWithoutSubmissionsInput>, DailyQuizUncheckedUpdateWithoutSubmissionsInput>
  }

  export type UserCreateNestedOneWithoutGoldenCardsInput = {
    create?: XOR<UserCreateWithoutGoldenCardsInput, UserUncheckedCreateWithoutGoldenCardsInput>
    connectOrCreate?: UserCreateOrConnectWithoutGoldenCardsInput
    connect?: UserWhereUniqueInput
  }

  export type DailyQuizCreateNestedOneWithoutAwardedCardsInput = {
    create?: XOR<DailyQuizCreateWithoutAwardedCardsInput, DailyQuizUncheckedCreateWithoutAwardedCardsInput>
    connectOrCreate?: DailyQuizCreateOrConnectWithoutAwardedCardsInput
    connect?: DailyQuizWhereUniqueInput
  }

  export type PlayerCreateNestedOneWithoutGoldenCardsInput = {
    create?: XOR<PlayerCreateWithoutGoldenCardsInput, PlayerUncheckedCreateWithoutGoldenCardsInput>
    connectOrCreate?: PlayerCreateOrConnectWithoutGoldenCardsInput
    connect?: PlayerWhereUniqueInput
  }

  export type TeamPlayerCreateNestedOneWithoutGoldenCardInput = {
    create?: XOR<TeamPlayerCreateWithoutGoldenCardInput, TeamPlayerUncheckedCreateWithoutGoldenCardInput>
    connectOrCreate?: TeamPlayerCreateOrConnectWithoutGoldenCardInput
    connect?: TeamPlayerWhereUniqueInput
  }

  export type TeamPlayerUncheckedCreateNestedOneWithoutGoldenCardInput = {
    create?: XOR<TeamPlayerCreateWithoutGoldenCardInput, TeamPlayerUncheckedCreateWithoutGoldenCardInput>
    connectOrCreate?: TeamPlayerCreateOrConnectWithoutGoldenCardInput
    connect?: TeamPlayerWhereUniqueInput
  }

  export type EnumGoldenCardStatusFieldUpdateOperationsInput = {
    set?: $Enums.GoldenCardStatus
  }

  export type EnumSpecialCardStateFieldUpdateOperationsInput = {
    set?: $Enums.SpecialCardState
  }

  export type UserUpdateOneRequiredWithoutGoldenCardsNestedInput = {
    create?: XOR<UserCreateWithoutGoldenCardsInput, UserUncheckedCreateWithoutGoldenCardsInput>
    connectOrCreate?: UserCreateOrConnectWithoutGoldenCardsInput
    upsert?: UserUpsertWithoutGoldenCardsInput
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutGoldenCardsInput, UserUpdateWithoutGoldenCardsInput>, UserUncheckedUpdateWithoutGoldenCardsInput>
  }

  export type DailyQuizUpdateOneWithoutAwardedCardsNestedInput = {
    create?: XOR<DailyQuizCreateWithoutAwardedCardsInput, DailyQuizUncheckedCreateWithoutAwardedCardsInput>
    connectOrCreate?: DailyQuizCreateOrConnectWithoutAwardedCardsInput
    upsert?: DailyQuizUpsertWithoutAwardedCardsInput
    disconnect?: DailyQuizWhereInput | boolean
    delete?: DailyQuizWhereInput | boolean
    connect?: DailyQuizWhereUniqueInput
    update?: XOR<XOR<DailyQuizUpdateToOneWithWhereWithoutAwardedCardsInput, DailyQuizUpdateWithoutAwardedCardsInput>, DailyQuizUncheckedUpdateWithoutAwardedCardsInput>
  }

  export type PlayerUpdateOneRequiredWithoutGoldenCardsNestedInput = {
    create?: XOR<PlayerCreateWithoutGoldenCardsInput, PlayerUncheckedCreateWithoutGoldenCardsInput>
    connectOrCreate?: PlayerCreateOrConnectWithoutGoldenCardsInput
    upsert?: PlayerUpsertWithoutGoldenCardsInput
    connect?: PlayerWhereUniqueInput
    update?: XOR<XOR<PlayerUpdateToOneWithWhereWithoutGoldenCardsInput, PlayerUpdateWithoutGoldenCardsInput>, PlayerUncheckedUpdateWithoutGoldenCardsInput>
  }

  export type TeamPlayerUpdateOneWithoutGoldenCardNestedInput = {
    create?: XOR<TeamPlayerCreateWithoutGoldenCardInput, TeamPlayerUncheckedCreateWithoutGoldenCardInput>
    connectOrCreate?: TeamPlayerCreateOrConnectWithoutGoldenCardInput
    upsert?: TeamPlayerUpsertWithoutGoldenCardInput
    disconnect?: TeamPlayerWhereInput | boolean
    delete?: TeamPlayerWhereInput | boolean
    connect?: TeamPlayerWhereUniqueInput
    update?: XOR<XOR<TeamPlayerUpdateToOneWithWhereWithoutGoldenCardInput, TeamPlayerUpdateWithoutGoldenCardInput>, TeamPlayerUncheckedUpdateWithoutGoldenCardInput>
  }

  export type TeamPlayerUncheckedUpdateOneWithoutGoldenCardNestedInput = {
    create?: XOR<TeamPlayerCreateWithoutGoldenCardInput, TeamPlayerUncheckedCreateWithoutGoldenCardInput>
    connectOrCreate?: TeamPlayerCreateOrConnectWithoutGoldenCardInput
    upsert?: TeamPlayerUpsertWithoutGoldenCardInput
    disconnect?: TeamPlayerWhereInput | boolean
    delete?: TeamPlayerWhereInput | boolean
    connect?: TeamPlayerWhereUniqueInput
    update?: XOR<XOR<TeamPlayerUpdateToOneWithWhereWithoutGoldenCardInput, TeamPlayerUpdateWithoutGoldenCardInput>, TeamPlayerUncheckedUpdateWithoutGoldenCardInput>
  }

  export type UserCreateNestedOneWithoutSessionsInput = {
    create?: XOR<UserCreateWithoutSessionsInput, UserUncheckedCreateWithoutSessionsInput>
    connectOrCreate?: UserCreateOrConnectWithoutSessionsInput
    connect?: UserWhereUniqueInput
  }

  export type UserUpdateOneRequiredWithoutSessionsNestedInput = {
    create?: XOR<UserCreateWithoutSessionsInput, UserUncheckedCreateWithoutSessionsInput>
    connectOrCreate?: UserCreateOrConnectWithoutSessionsInput
    upsert?: UserUpsertWithoutSessionsInput
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutSessionsInput, UserUpdateWithoutSessionsInput>, UserUncheckedUpdateWithoutSessionsInput>
  }

  export type UserCreateNestedOneWithoutTeamInput = {
    create?: XOR<UserCreateWithoutTeamInput, UserUncheckedCreateWithoutTeamInput>
    connectOrCreate?: UserCreateOrConnectWithoutTeamInput
    connect?: UserWhereUniqueInput
  }

  export type TeamPlayerCreateNestedManyWithoutTeamInput = {
    create?: XOR<TeamPlayerCreateWithoutTeamInput, TeamPlayerUncheckedCreateWithoutTeamInput> | TeamPlayerCreateWithoutTeamInput[] | TeamPlayerUncheckedCreateWithoutTeamInput[]
    connectOrCreate?: TeamPlayerCreateOrConnectWithoutTeamInput | TeamPlayerCreateOrConnectWithoutTeamInput[]
    createMany?: TeamPlayerCreateManyTeamInputEnvelope
    connect?: TeamPlayerWhereUniqueInput | TeamPlayerWhereUniqueInput[]
  }

  export type TeamPlayerUncheckedCreateNestedManyWithoutTeamInput = {
    create?: XOR<TeamPlayerCreateWithoutTeamInput, TeamPlayerUncheckedCreateWithoutTeamInput> | TeamPlayerCreateWithoutTeamInput[] | TeamPlayerUncheckedCreateWithoutTeamInput[]
    connectOrCreate?: TeamPlayerCreateOrConnectWithoutTeamInput | TeamPlayerCreateOrConnectWithoutTeamInput[]
    createMany?: TeamPlayerCreateManyTeamInputEnvelope
    connect?: TeamPlayerWhereUniqueInput | TeamPlayerWhereUniqueInput[]
  }

  export type EnumTeamStatusFieldUpdateOperationsInput = {
    set?: $Enums.TeamStatus
  }

  export type UserUpdateOneRequiredWithoutTeamNestedInput = {
    create?: XOR<UserCreateWithoutTeamInput, UserUncheckedCreateWithoutTeamInput>
    connectOrCreate?: UserCreateOrConnectWithoutTeamInput
    upsert?: UserUpsertWithoutTeamInput
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutTeamInput, UserUpdateWithoutTeamInput>, UserUncheckedUpdateWithoutTeamInput>
  }

  export type TeamPlayerUpdateManyWithoutTeamNestedInput = {
    create?: XOR<TeamPlayerCreateWithoutTeamInput, TeamPlayerUncheckedCreateWithoutTeamInput> | TeamPlayerCreateWithoutTeamInput[] | TeamPlayerUncheckedCreateWithoutTeamInput[]
    connectOrCreate?: TeamPlayerCreateOrConnectWithoutTeamInput | TeamPlayerCreateOrConnectWithoutTeamInput[]
    upsert?: TeamPlayerUpsertWithWhereUniqueWithoutTeamInput | TeamPlayerUpsertWithWhereUniqueWithoutTeamInput[]
    createMany?: TeamPlayerCreateManyTeamInputEnvelope
    set?: TeamPlayerWhereUniqueInput | TeamPlayerWhereUniqueInput[]
    disconnect?: TeamPlayerWhereUniqueInput | TeamPlayerWhereUniqueInput[]
    delete?: TeamPlayerWhereUniqueInput | TeamPlayerWhereUniqueInput[]
    connect?: TeamPlayerWhereUniqueInput | TeamPlayerWhereUniqueInput[]
    update?: TeamPlayerUpdateWithWhereUniqueWithoutTeamInput | TeamPlayerUpdateWithWhereUniqueWithoutTeamInput[]
    updateMany?: TeamPlayerUpdateManyWithWhereWithoutTeamInput | TeamPlayerUpdateManyWithWhereWithoutTeamInput[]
    deleteMany?: TeamPlayerScalarWhereInput | TeamPlayerScalarWhereInput[]
  }

  export type TeamPlayerUncheckedUpdateManyWithoutTeamNestedInput = {
    create?: XOR<TeamPlayerCreateWithoutTeamInput, TeamPlayerUncheckedCreateWithoutTeamInput> | TeamPlayerCreateWithoutTeamInput[] | TeamPlayerUncheckedCreateWithoutTeamInput[]
    connectOrCreate?: TeamPlayerCreateOrConnectWithoutTeamInput | TeamPlayerCreateOrConnectWithoutTeamInput[]
    upsert?: TeamPlayerUpsertWithWhereUniqueWithoutTeamInput | TeamPlayerUpsertWithWhereUniqueWithoutTeamInput[]
    createMany?: TeamPlayerCreateManyTeamInputEnvelope
    set?: TeamPlayerWhereUniqueInput | TeamPlayerWhereUniqueInput[]
    disconnect?: TeamPlayerWhereUniqueInput | TeamPlayerWhereUniqueInput[]
    delete?: TeamPlayerWhereUniqueInput | TeamPlayerWhereUniqueInput[]
    connect?: TeamPlayerWhereUniqueInput | TeamPlayerWhereUniqueInput[]
    update?: TeamPlayerUpdateWithWhereUniqueWithoutTeamInput | TeamPlayerUpdateWithWhereUniqueWithoutTeamInput[]
    updateMany?: TeamPlayerUpdateManyWithWhereWithoutTeamInput | TeamPlayerUpdateManyWithWhereWithoutTeamInput[]
    deleteMany?: TeamPlayerScalarWhereInput | TeamPlayerScalarWhereInput[]
  }

  export type TeamCreateNestedOneWithoutPlayersInput = {
    create?: XOR<TeamCreateWithoutPlayersInput, TeamUncheckedCreateWithoutPlayersInput>
    connectOrCreate?: TeamCreateOrConnectWithoutPlayersInput
    connect?: TeamWhereUniqueInput
  }

  export type PlayerCreateNestedOneWithoutTeamPlayersInput = {
    create?: XOR<PlayerCreateWithoutTeamPlayersInput, PlayerUncheckedCreateWithoutTeamPlayersInput>
    connectOrCreate?: PlayerCreateOrConnectWithoutTeamPlayersInput
    connect?: PlayerWhereUniqueInput
  }

  export type GoldenCardCreateNestedOneWithoutTeamPlayerInput = {
    create?: XOR<GoldenCardCreateWithoutTeamPlayerInput, GoldenCardUncheckedCreateWithoutTeamPlayerInput>
    connectOrCreate?: GoldenCardCreateOrConnectWithoutTeamPlayerInput
    connect?: GoldenCardWhereUniqueInput
  }

  export type TeamUpdateOneRequiredWithoutPlayersNestedInput = {
    create?: XOR<TeamCreateWithoutPlayersInput, TeamUncheckedCreateWithoutPlayersInput>
    connectOrCreate?: TeamCreateOrConnectWithoutPlayersInput
    upsert?: TeamUpsertWithoutPlayersInput
    connect?: TeamWhereUniqueInput
    update?: XOR<XOR<TeamUpdateToOneWithWhereWithoutPlayersInput, TeamUpdateWithoutPlayersInput>, TeamUncheckedUpdateWithoutPlayersInput>
  }

  export type PlayerUpdateOneRequiredWithoutTeamPlayersNestedInput = {
    create?: XOR<PlayerCreateWithoutTeamPlayersInput, PlayerUncheckedCreateWithoutTeamPlayersInput>
    connectOrCreate?: PlayerCreateOrConnectWithoutTeamPlayersInput
    upsert?: PlayerUpsertWithoutTeamPlayersInput
    connect?: PlayerWhereUniqueInput
    update?: XOR<XOR<PlayerUpdateToOneWithWhereWithoutTeamPlayersInput, PlayerUpdateWithoutTeamPlayersInput>, PlayerUncheckedUpdateWithoutTeamPlayersInput>
  }

  export type GoldenCardUpdateOneWithoutTeamPlayerNestedInput = {
    create?: XOR<GoldenCardCreateWithoutTeamPlayerInput, GoldenCardUncheckedCreateWithoutTeamPlayerInput>
    connectOrCreate?: GoldenCardCreateOrConnectWithoutTeamPlayerInput
    upsert?: GoldenCardUpsertWithoutTeamPlayerInput
    disconnect?: GoldenCardWhereInput | boolean
    delete?: GoldenCardWhereInput | boolean
    connect?: GoldenCardWhereUniqueInput
    update?: XOR<XOR<GoldenCardUpdateToOneWithWhereWithoutTeamPlayerInput, GoldenCardUpdateWithoutTeamPlayerInput>, GoldenCardUncheckedUpdateWithoutTeamPlayerInput>
  }

  export type PaymentCreateNestedManyWithoutPackageInput = {
    create?: XOR<PaymentCreateWithoutPackageInput, PaymentUncheckedCreateWithoutPackageInput> | PaymentCreateWithoutPackageInput[] | PaymentUncheckedCreateWithoutPackageInput[]
    connectOrCreate?: PaymentCreateOrConnectWithoutPackageInput | PaymentCreateOrConnectWithoutPackageInput[]
    createMany?: PaymentCreateManyPackageInputEnvelope
    connect?: PaymentWhereUniqueInput | PaymentWhereUniqueInput[]
  }

  export type PaymentUncheckedCreateNestedManyWithoutPackageInput = {
    create?: XOR<PaymentCreateWithoutPackageInput, PaymentUncheckedCreateWithoutPackageInput> | PaymentCreateWithoutPackageInput[] | PaymentUncheckedCreateWithoutPackageInput[]
    connectOrCreate?: PaymentCreateOrConnectWithoutPackageInput | PaymentCreateOrConnectWithoutPackageInput[]
    createMany?: PaymentCreateManyPackageInputEnvelope
    connect?: PaymentWhereUniqueInput | PaymentWhereUniqueInput[]
  }

  export type PaymentUpdateManyWithoutPackageNestedInput = {
    create?: XOR<PaymentCreateWithoutPackageInput, PaymentUncheckedCreateWithoutPackageInput> | PaymentCreateWithoutPackageInput[] | PaymentUncheckedCreateWithoutPackageInput[]
    connectOrCreate?: PaymentCreateOrConnectWithoutPackageInput | PaymentCreateOrConnectWithoutPackageInput[]
    upsert?: PaymentUpsertWithWhereUniqueWithoutPackageInput | PaymentUpsertWithWhereUniqueWithoutPackageInput[]
    createMany?: PaymentCreateManyPackageInputEnvelope
    set?: PaymentWhereUniqueInput | PaymentWhereUniqueInput[]
    disconnect?: PaymentWhereUniqueInput | PaymentWhereUniqueInput[]
    delete?: PaymentWhereUniqueInput | PaymentWhereUniqueInput[]
    connect?: PaymentWhereUniqueInput | PaymentWhereUniqueInput[]
    update?: PaymentUpdateWithWhereUniqueWithoutPackageInput | PaymentUpdateWithWhereUniqueWithoutPackageInput[]
    updateMany?: PaymentUpdateManyWithWhereWithoutPackageInput | PaymentUpdateManyWithWhereWithoutPackageInput[]
    deleteMany?: PaymentScalarWhereInput | PaymentScalarWhereInput[]
  }

  export type PaymentUncheckedUpdateManyWithoutPackageNestedInput = {
    create?: XOR<PaymentCreateWithoutPackageInput, PaymentUncheckedCreateWithoutPackageInput> | PaymentCreateWithoutPackageInput[] | PaymentUncheckedCreateWithoutPackageInput[]
    connectOrCreate?: PaymentCreateOrConnectWithoutPackageInput | PaymentCreateOrConnectWithoutPackageInput[]
    upsert?: PaymentUpsertWithWhereUniqueWithoutPackageInput | PaymentUpsertWithWhereUniqueWithoutPackageInput[]
    createMany?: PaymentCreateManyPackageInputEnvelope
    set?: PaymentWhereUniqueInput | PaymentWhereUniqueInput[]
    disconnect?: PaymentWhereUniqueInput | PaymentWhereUniqueInput[]
    delete?: PaymentWhereUniqueInput | PaymentWhereUniqueInput[]
    connect?: PaymentWhereUniqueInput | PaymentWhereUniqueInput[]
    update?: PaymentUpdateWithWhereUniqueWithoutPackageInput | PaymentUpdateWithWhereUniqueWithoutPackageInput[]
    updateMany?: PaymentUpdateManyWithWhereWithoutPackageInput | PaymentUpdateManyWithWhereWithoutPackageInput[]
    deleteMany?: PaymentScalarWhereInput | PaymentScalarWhereInput[]
  }

  export type UserCreateNestedOneWithoutPaymentsInput = {
    create?: XOR<UserCreateWithoutPaymentsInput, UserUncheckedCreateWithoutPaymentsInput>
    connectOrCreate?: UserCreateOrConnectWithoutPaymentsInput
    connect?: UserWhereUniqueInput
  }

  export type PackageCreateNestedOneWithoutPaymentsInput = {
    create?: XOR<PackageCreateWithoutPaymentsInput, PackageUncheckedCreateWithoutPaymentsInput>
    connectOrCreate?: PackageCreateOrConnectWithoutPaymentsInput
    connect?: PackageWhereUniqueInput
  }

  export type EnumPaymentStatusFieldUpdateOperationsInput = {
    set?: $Enums.PaymentStatus
  }

  export type UserUpdateOneRequiredWithoutPaymentsNestedInput = {
    create?: XOR<UserCreateWithoutPaymentsInput, UserUncheckedCreateWithoutPaymentsInput>
    connectOrCreate?: UserCreateOrConnectWithoutPaymentsInput
    upsert?: UserUpsertWithoutPaymentsInput
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutPaymentsInput, UserUpdateWithoutPaymentsInput>, UserUncheckedUpdateWithoutPaymentsInput>
  }

  export type PackageUpdateOneRequiredWithoutPaymentsNestedInput = {
    create?: XOR<PackageCreateWithoutPaymentsInput, PackageUncheckedCreateWithoutPaymentsInput>
    connectOrCreate?: PackageCreateOrConnectWithoutPaymentsInput
    upsert?: PackageUpsertWithoutPaymentsInput
    connect?: PackageWhereUniqueInput
    update?: XOR<XOR<PackageUpdateToOneWithWhereWithoutPaymentsInput, PackageUpdateWithoutPaymentsInput>, PackageUncheckedUpdateWithoutPaymentsInput>
  }

  export type NestedStringFilter<$PrismaModel = never> = {
    equals?: string | StringFieldRefInput<$PrismaModel>
    in?: string[] | ListStringFieldRefInput<$PrismaModel>
    notIn?: string[] | ListStringFieldRefInput<$PrismaModel>
    lt?: string | StringFieldRefInput<$PrismaModel>
    lte?: string | StringFieldRefInput<$PrismaModel>
    gt?: string | StringFieldRefInput<$PrismaModel>
    gte?: string | StringFieldRefInput<$PrismaModel>
    contains?: string | StringFieldRefInput<$PrismaModel>
    startsWith?: string | StringFieldRefInput<$PrismaModel>
    endsWith?: string | StringFieldRefInput<$PrismaModel>
    not?: NestedStringFilter<$PrismaModel> | string
  }

  export type NestedStringNullableFilter<$PrismaModel = never> = {
    equals?: string | StringFieldRefInput<$PrismaModel> | null
    in?: string[] | ListStringFieldRefInput<$PrismaModel> | null
    notIn?: string[] | ListStringFieldRefInput<$PrismaModel> | null
    lt?: string | StringFieldRefInput<$PrismaModel>
    lte?: string | StringFieldRefInput<$PrismaModel>
    gt?: string | StringFieldRefInput<$PrismaModel>
    gte?: string | StringFieldRefInput<$PrismaModel>
    contains?: string | StringFieldRefInput<$PrismaModel>
    startsWith?: string | StringFieldRefInput<$PrismaModel>
    endsWith?: string | StringFieldRefInput<$PrismaModel>
    not?: NestedStringNullableFilter<$PrismaModel> | string | null
  }

  export type NestedBoolFilter<$PrismaModel = never> = {
    equals?: boolean | BooleanFieldRefInput<$PrismaModel>
    not?: NestedBoolFilter<$PrismaModel> | boolean
  }

  export type NestedStringWithAggregatesFilter<$PrismaModel = never> = {
    equals?: string | StringFieldRefInput<$PrismaModel>
    in?: string[] | ListStringFieldRefInput<$PrismaModel>
    notIn?: string[] | ListStringFieldRefInput<$PrismaModel>
    lt?: string | StringFieldRefInput<$PrismaModel>
    lte?: string | StringFieldRefInput<$PrismaModel>
    gt?: string | StringFieldRefInput<$PrismaModel>
    gte?: string | StringFieldRefInput<$PrismaModel>
    contains?: string | StringFieldRefInput<$PrismaModel>
    startsWith?: string | StringFieldRefInput<$PrismaModel>
    endsWith?: string | StringFieldRefInput<$PrismaModel>
    not?: NestedStringWithAggregatesFilter<$PrismaModel> | string
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedStringFilter<$PrismaModel>
    _max?: NestedStringFilter<$PrismaModel>
  }

  export type NestedIntFilter<$PrismaModel = never> = {
    equals?: number | IntFieldRefInput<$PrismaModel>
    in?: number[] | ListIntFieldRefInput<$PrismaModel>
    notIn?: number[] | ListIntFieldRefInput<$PrismaModel>
    lt?: number | IntFieldRefInput<$PrismaModel>
    lte?: number | IntFieldRefInput<$PrismaModel>
    gt?: number | IntFieldRefInput<$PrismaModel>
    gte?: number | IntFieldRefInput<$PrismaModel>
    not?: NestedIntFilter<$PrismaModel> | number
  }

  export type NestedStringNullableWithAggregatesFilter<$PrismaModel = never> = {
    equals?: string | StringFieldRefInput<$PrismaModel> | null
    in?: string[] | ListStringFieldRefInput<$PrismaModel> | null
    notIn?: string[] | ListStringFieldRefInput<$PrismaModel> | null
    lt?: string | StringFieldRefInput<$PrismaModel>
    lte?: string | StringFieldRefInput<$PrismaModel>
    gt?: string | StringFieldRefInput<$PrismaModel>
    gte?: string | StringFieldRefInput<$PrismaModel>
    contains?: string | StringFieldRefInput<$PrismaModel>
    startsWith?: string | StringFieldRefInput<$PrismaModel>
    endsWith?: string | StringFieldRefInput<$PrismaModel>
    not?: NestedStringNullableWithAggregatesFilter<$PrismaModel> | string | null
    _count?: NestedIntNullableFilter<$PrismaModel>
    _min?: NestedStringNullableFilter<$PrismaModel>
    _max?: NestedStringNullableFilter<$PrismaModel>
  }

  export type NestedIntNullableFilter<$PrismaModel = never> = {
    equals?: number | IntFieldRefInput<$PrismaModel> | null
    in?: number[] | ListIntFieldRefInput<$PrismaModel> | null
    notIn?: number[] | ListIntFieldRefInput<$PrismaModel> | null
    lt?: number | IntFieldRefInput<$PrismaModel>
    lte?: number | IntFieldRefInput<$PrismaModel>
    gt?: number | IntFieldRefInput<$PrismaModel>
    gte?: number | IntFieldRefInput<$PrismaModel>
    not?: NestedIntNullableFilter<$PrismaModel> | number | null
  }

  export type NestedBoolWithAggregatesFilter<$PrismaModel = never> = {
    equals?: boolean | BooleanFieldRefInput<$PrismaModel>
    not?: NestedBoolWithAggregatesFilter<$PrismaModel> | boolean
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedBoolFilter<$PrismaModel>
    _max?: NestedBoolFilter<$PrismaModel>
  }

  export type NestedEnumPositionFilter<$PrismaModel = never> = {
    equals?: $Enums.Position | EnumPositionFieldRefInput<$PrismaModel>
    in?: $Enums.Position[] | ListEnumPositionFieldRefInput<$PrismaModel>
    notIn?: $Enums.Position[] | ListEnumPositionFieldRefInput<$PrismaModel>
    not?: NestedEnumPositionFilter<$PrismaModel> | $Enums.Position
  }

  export type NestedFloatFilter<$PrismaModel = never> = {
    equals?: number | FloatFieldRefInput<$PrismaModel>
    in?: number[] | ListFloatFieldRefInput<$PrismaModel>
    notIn?: number[] | ListFloatFieldRefInput<$PrismaModel>
    lt?: number | FloatFieldRefInput<$PrismaModel>
    lte?: number | FloatFieldRefInput<$PrismaModel>
    gt?: number | FloatFieldRefInput<$PrismaModel>
    gte?: number | FloatFieldRefInput<$PrismaModel>
    not?: NestedFloatFilter<$PrismaModel> | number
  }

  export type NestedEnumCardTierFilter<$PrismaModel = never> = {
    equals?: $Enums.CardTier | EnumCardTierFieldRefInput<$PrismaModel>
    in?: $Enums.CardTier[] | ListEnumCardTierFieldRefInput<$PrismaModel>
    notIn?: $Enums.CardTier[] | ListEnumCardTierFieldRefInput<$PrismaModel>
    not?: NestedEnumCardTierFilter<$PrismaModel> | $Enums.CardTier
  }

  export type NestedDateTimeFilter<$PrismaModel = never> = {
    equals?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    in?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel>
    notIn?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel>
    lt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    lte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    not?: NestedDateTimeFilter<$PrismaModel> | Date | string
  }

  export type NestedEnumPositionWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.Position | EnumPositionFieldRefInput<$PrismaModel>
    in?: $Enums.Position[] | ListEnumPositionFieldRefInput<$PrismaModel>
    notIn?: $Enums.Position[] | ListEnumPositionFieldRefInput<$PrismaModel>
    not?: NestedEnumPositionWithAggregatesFilter<$PrismaModel> | $Enums.Position
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumPositionFilter<$PrismaModel>
    _max?: NestedEnumPositionFilter<$PrismaModel>
  }

  export type NestedFloatWithAggregatesFilter<$PrismaModel = never> = {
    equals?: number | FloatFieldRefInput<$PrismaModel>
    in?: number[] | ListFloatFieldRefInput<$PrismaModel>
    notIn?: number[] | ListFloatFieldRefInput<$PrismaModel>
    lt?: number | FloatFieldRefInput<$PrismaModel>
    lte?: number | FloatFieldRefInput<$PrismaModel>
    gt?: number | FloatFieldRefInput<$PrismaModel>
    gte?: number | FloatFieldRefInput<$PrismaModel>
    not?: NestedFloatWithAggregatesFilter<$PrismaModel> | number
    _count?: NestedIntFilter<$PrismaModel>
    _avg?: NestedFloatFilter<$PrismaModel>
    _sum?: NestedFloatFilter<$PrismaModel>
    _min?: NestedFloatFilter<$PrismaModel>
    _max?: NestedFloatFilter<$PrismaModel>
  }

  export type NestedIntWithAggregatesFilter<$PrismaModel = never> = {
    equals?: number | IntFieldRefInput<$PrismaModel>
    in?: number[] | ListIntFieldRefInput<$PrismaModel>
    notIn?: number[] | ListIntFieldRefInput<$PrismaModel>
    lt?: number | IntFieldRefInput<$PrismaModel>
    lte?: number | IntFieldRefInput<$PrismaModel>
    gt?: number | IntFieldRefInput<$PrismaModel>
    gte?: number | IntFieldRefInput<$PrismaModel>
    not?: NestedIntWithAggregatesFilter<$PrismaModel> | number
    _count?: NestedIntFilter<$PrismaModel>
    _avg?: NestedFloatFilter<$PrismaModel>
    _sum?: NestedIntFilter<$PrismaModel>
    _min?: NestedIntFilter<$PrismaModel>
    _max?: NestedIntFilter<$PrismaModel>
  }

  export type NestedEnumCardTierWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.CardTier | EnumCardTierFieldRefInput<$PrismaModel>
    in?: $Enums.CardTier[] | ListEnumCardTierFieldRefInput<$PrismaModel>
    notIn?: $Enums.CardTier[] | ListEnumCardTierFieldRefInput<$PrismaModel>
    not?: NestedEnumCardTierWithAggregatesFilter<$PrismaModel> | $Enums.CardTier
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumCardTierFilter<$PrismaModel>
    _max?: NestedEnumCardTierFilter<$PrismaModel>
  }

  export type NestedDateTimeWithAggregatesFilter<$PrismaModel = never> = {
    equals?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    in?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel>
    notIn?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel>
    lt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    lte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    not?: NestedDateTimeWithAggregatesFilter<$PrismaModel> | Date | string
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedDateTimeFilter<$PrismaModel>
    _max?: NestedDateTimeFilter<$PrismaModel>
  }

  export type NestedEnumMatchStageFilter<$PrismaModel = never> = {
    equals?: $Enums.MatchStage | EnumMatchStageFieldRefInput<$PrismaModel>
    in?: $Enums.MatchStage[] | ListEnumMatchStageFieldRefInput<$PrismaModel>
    notIn?: $Enums.MatchStage[] | ListEnumMatchStageFieldRefInput<$PrismaModel>
    not?: NestedEnumMatchStageFilter<$PrismaModel> | $Enums.MatchStage
  }

  export type NestedEnumMatchStatusFilter<$PrismaModel = never> = {
    equals?: $Enums.MatchStatus | EnumMatchStatusFieldRefInput<$PrismaModel>
    in?: $Enums.MatchStatus[] | ListEnumMatchStatusFieldRefInput<$PrismaModel>
    notIn?: $Enums.MatchStatus[] | ListEnumMatchStatusFieldRefInput<$PrismaModel>
    not?: NestedEnumMatchStatusFilter<$PrismaModel> | $Enums.MatchStatus
  }

  export type NestedIntNullableWithAggregatesFilter<$PrismaModel = never> = {
    equals?: number | IntFieldRefInput<$PrismaModel> | null
    in?: number[] | ListIntFieldRefInput<$PrismaModel> | null
    notIn?: number[] | ListIntFieldRefInput<$PrismaModel> | null
    lt?: number | IntFieldRefInput<$PrismaModel>
    lte?: number | IntFieldRefInput<$PrismaModel>
    gt?: number | IntFieldRefInput<$PrismaModel>
    gte?: number | IntFieldRefInput<$PrismaModel>
    not?: NestedIntNullableWithAggregatesFilter<$PrismaModel> | number | null
    _count?: NestedIntNullableFilter<$PrismaModel>
    _avg?: NestedFloatNullableFilter<$PrismaModel>
    _sum?: NestedIntNullableFilter<$PrismaModel>
    _min?: NestedIntNullableFilter<$PrismaModel>
    _max?: NestedIntNullableFilter<$PrismaModel>
  }

  export type NestedFloatNullableFilter<$PrismaModel = never> = {
    equals?: number | FloatFieldRefInput<$PrismaModel> | null
    in?: number[] | ListFloatFieldRefInput<$PrismaModel> | null
    notIn?: number[] | ListFloatFieldRefInput<$PrismaModel> | null
    lt?: number | FloatFieldRefInput<$PrismaModel>
    lte?: number | FloatFieldRefInput<$PrismaModel>
    gt?: number | FloatFieldRefInput<$PrismaModel>
    gte?: number | FloatFieldRefInput<$PrismaModel>
    not?: NestedFloatNullableFilter<$PrismaModel> | number | null
  }

  export type NestedEnumMatchStageWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.MatchStage | EnumMatchStageFieldRefInput<$PrismaModel>
    in?: $Enums.MatchStage[] | ListEnumMatchStageFieldRefInput<$PrismaModel>
    notIn?: $Enums.MatchStage[] | ListEnumMatchStageFieldRefInput<$PrismaModel>
    not?: NestedEnumMatchStageWithAggregatesFilter<$PrismaModel> | $Enums.MatchStage
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumMatchStageFilter<$PrismaModel>
    _max?: NestedEnumMatchStageFilter<$PrismaModel>
  }

  export type NestedEnumMatchStatusWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.MatchStatus | EnumMatchStatusFieldRefInput<$PrismaModel>
    in?: $Enums.MatchStatus[] | ListEnumMatchStatusFieldRefInput<$PrismaModel>
    notIn?: $Enums.MatchStatus[] | ListEnumMatchStatusFieldRefInput<$PrismaModel>
    not?: NestedEnumMatchStatusWithAggregatesFilter<$PrismaModel> | $Enums.MatchStatus
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumMatchStatusFilter<$PrismaModel>
    _max?: NestedEnumMatchStatusFilter<$PrismaModel>
  }

  export type NestedEnumEventTypeFilter<$PrismaModel = never> = {
    equals?: $Enums.EventType | EnumEventTypeFieldRefInput<$PrismaModel>
    in?: $Enums.EventType[] | ListEnumEventTypeFieldRefInput<$PrismaModel>
    notIn?: $Enums.EventType[] | ListEnumEventTypeFieldRefInput<$PrismaModel>
    not?: NestedEnumEventTypeFilter<$PrismaModel> | $Enums.EventType
  }

  export type NestedEnumEventTypeWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.EventType | EnumEventTypeFieldRefInput<$PrismaModel>
    in?: $Enums.EventType[] | ListEnumEventTypeFieldRefInput<$PrismaModel>
    notIn?: $Enums.EventType[] | ListEnumEventTypeFieldRefInput<$PrismaModel>
    not?: NestedEnumEventTypeWithAggregatesFilter<$PrismaModel> | $Enums.EventType
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumEventTypeFilter<$PrismaModel>
    _max?: NestedEnumEventTypeFilter<$PrismaModel>
  }

  export type NestedEnumRoleFilter<$PrismaModel = never> = {
    equals?: $Enums.Role | EnumRoleFieldRefInput<$PrismaModel>
    in?: $Enums.Role[] | ListEnumRoleFieldRefInput<$PrismaModel>
    notIn?: $Enums.Role[] | ListEnumRoleFieldRefInput<$PrismaModel>
    not?: NestedEnumRoleFilter<$PrismaModel> | $Enums.Role
  }

  export type NestedEnumRoleWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.Role | EnumRoleFieldRefInput<$PrismaModel>
    in?: $Enums.Role[] | ListEnumRoleFieldRefInput<$PrismaModel>
    notIn?: $Enums.Role[] | ListEnumRoleFieldRefInput<$PrismaModel>
    not?: NestedEnumRoleWithAggregatesFilter<$PrismaModel> | $Enums.Role
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumRoleFilter<$PrismaModel>
    _max?: NestedEnumRoleFilter<$PrismaModel>
  }

  export type NestedDateTimeNullableFilter<$PrismaModel = never> = {
    equals?: Date | string | DateTimeFieldRefInput<$PrismaModel> | null
    in?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel> | null
    notIn?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel> | null
    lt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    lte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    not?: NestedDateTimeNullableFilter<$PrismaModel> | Date | string | null
  }

  export type NestedDateTimeNullableWithAggregatesFilter<$PrismaModel = never> = {
    equals?: Date | string | DateTimeFieldRefInput<$PrismaModel> | null
    in?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel> | null
    notIn?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel> | null
    lt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    lte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    not?: NestedDateTimeNullableWithAggregatesFilter<$PrismaModel> | Date | string | null
    _count?: NestedIntNullableFilter<$PrismaModel>
    _min?: NestedDateTimeNullableFilter<$PrismaModel>
    _max?: NestedDateTimeNullableFilter<$PrismaModel>
  }

  export type NestedEnumGoldenCardStatusFilter<$PrismaModel = never> = {
    equals?: $Enums.GoldenCardStatus | EnumGoldenCardStatusFieldRefInput<$PrismaModel>
    in?: $Enums.GoldenCardStatus[] | ListEnumGoldenCardStatusFieldRefInput<$PrismaModel>
    notIn?: $Enums.GoldenCardStatus[] | ListEnumGoldenCardStatusFieldRefInput<$PrismaModel>
    not?: NestedEnumGoldenCardStatusFilter<$PrismaModel> | $Enums.GoldenCardStatus
  }

  export type NestedEnumSpecialCardStateFilter<$PrismaModel = never> = {
    equals?: $Enums.SpecialCardState | EnumSpecialCardStateFieldRefInput<$PrismaModel>
    in?: $Enums.SpecialCardState[] | ListEnumSpecialCardStateFieldRefInput<$PrismaModel>
    notIn?: $Enums.SpecialCardState[] | ListEnumSpecialCardStateFieldRefInput<$PrismaModel>
    not?: NestedEnumSpecialCardStateFilter<$PrismaModel> | $Enums.SpecialCardState
  }

  export type NestedEnumGoldenCardStatusWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.GoldenCardStatus | EnumGoldenCardStatusFieldRefInput<$PrismaModel>
    in?: $Enums.GoldenCardStatus[] | ListEnumGoldenCardStatusFieldRefInput<$PrismaModel>
    notIn?: $Enums.GoldenCardStatus[] | ListEnumGoldenCardStatusFieldRefInput<$PrismaModel>
    not?: NestedEnumGoldenCardStatusWithAggregatesFilter<$PrismaModel> | $Enums.GoldenCardStatus
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumGoldenCardStatusFilter<$PrismaModel>
    _max?: NestedEnumGoldenCardStatusFilter<$PrismaModel>
  }

  export type NestedEnumSpecialCardStateWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.SpecialCardState | EnumSpecialCardStateFieldRefInput<$PrismaModel>
    in?: $Enums.SpecialCardState[] | ListEnumSpecialCardStateFieldRefInput<$PrismaModel>
    notIn?: $Enums.SpecialCardState[] | ListEnumSpecialCardStateFieldRefInput<$PrismaModel>
    not?: NestedEnumSpecialCardStateWithAggregatesFilter<$PrismaModel> | $Enums.SpecialCardState
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumSpecialCardStateFilter<$PrismaModel>
    _max?: NestedEnumSpecialCardStateFilter<$PrismaModel>
  }

  export type NestedEnumTeamStatusFilter<$PrismaModel = never> = {
    equals?: $Enums.TeamStatus | EnumTeamStatusFieldRefInput<$PrismaModel>
    in?: $Enums.TeamStatus[] | ListEnumTeamStatusFieldRefInput<$PrismaModel>
    notIn?: $Enums.TeamStatus[] | ListEnumTeamStatusFieldRefInput<$PrismaModel>
    not?: NestedEnumTeamStatusFilter<$PrismaModel> | $Enums.TeamStatus
  }

  export type NestedEnumTeamStatusWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.TeamStatus | EnumTeamStatusFieldRefInput<$PrismaModel>
    in?: $Enums.TeamStatus[] | ListEnumTeamStatusFieldRefInput<$PrismaModel>
    notIn?: $Enums.TeamStatus[] | ListEnumTeamStatusFieldRefInput<$PrismaModel>
    not?: NestedEnumTeamStatusWithAggregatesFilter<$PrismaModel> | $Enums.TeamStatus
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumTeamStatusFilter<$PrismaModel>
    _max?: NestedEnumTeamStatusFilter<$PrismaModel>
  }

  export type NestedEnumPaymentStatusFilter<$PrismaModel = never> = {
    equals?: $Enums.PaymentStatus | EnumPaymentStatusFieldRefInput<$PrismaModel>
    in?: $Enums.PaymentStatus[] | ListEnumPaymentStatusFieldRefInput<$PrismaModel>
    notIn?: $Enums.PaymentStatus[] | ListEnumPaymentStatusFieldRefInput<$PrismaModel>
    not?: NestedEnumPaymentStatusFilter<$PrismaModel> | $Enums.PaymentStatus
  }

  export type NestedEnumPaymentStatusWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.PaymentStatus | EnumPaymentStatusFieldRefInput<$PrismaModel>
    in?: $Enums.PaymentStatus[] | ListEnumPaymentStatusFieldRefInput<$PrismaModel>
    notIn?: $Enums.PaymentStatus[] | ListEnumPaymentStatusFieldRefInput<$PrismaModel>
    not?: NestedEnumPaymentStatusWithAggregatesFilter<$PrismaModel> | $Enums.PaymentStatus
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumPaymentStatusFilter<$PrismaModel>
    _max?: NestedEnumPaymentStatusFilter<$PrismaModel>
  }

  export type GroupCreateWithoutCountriesInput = {
    id?: string
    name: string
  }

  export type GroupUncheckedCreateWithoutCountriesInput = {
    id?: string
    name: string
  }

  export type GroupCreateOrConnectWithoutCountriesInput = {
    where: GroupWhereUniqueInput
    create: XOR<GroupCreateWithoutCountriesInput, GroupUncheckedCreateWithoutCountriesInput>
  }

  export type PlayerCreateWithoutCountryInput = {
    id?: string
    name: string
    image?: string | null
    position: $Enums.Position
    price?: number
    totalPoints?: number
    isActive?: boolean
    isGoldenCardEligible?: boolean
    cardTier?: $Enums.CardTier
    createdAt?: Date | string
    updatedAt?: Date | string
    matchStats?: PlayerMatchStatCreateNestedManyWithoutPlayerInput
    teamPlayers?: TeamPlayerCreateNestedManyWithoutPlayerInput
    events?: MatchEventCreateNestedManyWithoutPlayerInput
    goldenCards?: GoldenCardCreateNestedManyWithoutPlayerInput
  }

  export type PlayerUncheckedCreateWithoutCountryInput = {
    id?: string
    name: string
    image?: string | null
    position: $Enums.Position
    price?: number
    totalPoints?: number
    isActive?: boolean
    isGoldenCardEligible?: boolean
    cardTier?: $Enums.CardTier
    createdAt?: Date | string
    updatedAt?: Date | string
    matchStats?: PlayerMatchStatUncheckedCreateNestedManyWithoutPlayerInput
    teamPlayers?: TeamPlayerUncheckedCreateNestedManyWithoutPlayerInput
    events?: MatchEventUncheckedCreateNestedManyWithoutPlayerInput
    goldenCards?: GoldenCardUncheckedCreateNestedManyWithoutPlayerInput
  }

  export type PlayerCreateOrConnectWithoutCountryInput = {
    where: PlayerWhereUniqueInput
    create: XOR<PlayerCreateWithoutCountryInput, PlayerUncheckedCreateWithoutCountryInput>
  }

  export type PlayerCreateManyCountryInputEnvelope = {
    data: PlayerCreateManyCountryInput | PlayerCreateManyCountryInput[]
    skipDuplicates?: boolean
  }

  export type MatchCreateWithoutHomeTeamInput = {
    id?: string
    homeScore?: number | null
    awayScore?: number | null
    stage?: $Enums.MatchStage
    status?: $Enums.MatchStatus
    matchDate: Date | string
    matchDatePersian?: string | null
    stadium?: string | null
    city?: string | null
    referee?: string | null
    assistant1?: string | null
    assistant2?: string | null
    fourthOfficial?: string | null
    attendance?: number | null
    weather?: string | null
    description?: string | null
    createdAt?: Date | string
    awayTeam: CountryCreateNestedOneWithoutAwayMatchesInput
    round?: RoundCreateNestedOneWithoutMatchesInput
    playerStats?: PlayerMatchStatCreateNestedManyWithoutMatchInput
    events?: MatchEventCreateNestedManyWithoutMatchInput
    lineups?: MatchLineupCreateNestedManyWithoutMatchInput
  }

  export type MatchUncheckedCreateWithoutHomeTeamInput = {
    id?: string
    awayTeamId: string
    homeScore?: number | null
    awayScore?: number | null
    stage?: $Enums.MatchStage
    status?: $Enums.MatchStatus
    matchDate: Date | string
    matchDatePersian?: string | null
    stadium?: string | null
    city?: string | null
    referee?: string | null
    assistant1?: string | null
    assistant2?: string | null
    fourthOfficial?: string | null
    attendance?: number | null
    weather?: string | null
    description?: string | null
    roundId?: string | null
    createdAt?: Date | string
    playerStats?: PlayerMatchStatUncheckedCreateNestedManyWithoutMatchInput
    events?: MatchEventUncheckedCreateNestedManyWithoutMatchInput
    lineups?: MatchLineupUncheckedCreateNestedManyWithoutMatchInput
  }

  export type MatchCreateOrConnectWithoutHomeTeamInput = {
    where: MatchWhereUniqueInput
    create: XOR<MatchCreateWithoutHomeTeamInput, MatchUncheckedCreateWithoutHomeTeamInput>
  }

  export type MatchCreateManyHomeTeamInputEnvelope = {
    data: MatchCreateManyHomeTeamInput | MatchCreateManyHomeTeamInput[]
    skipDuplicates?: boolean
  }

  export type MatchCreateWithoutAwayTeamInput = {
    id?: string
    homeScore?: number | null
    awayScore?: number | null
    stage?: $Enums.MatchStage
    status?: $Enums.MatchStatus
    matchDate: Date | string
    matchDatePersian?: string | null
    stadium?: string | null
    city?: string | null
    referee?: string | null
    assistant1?: string | null
    assistant2?: string | null
    fourthOfficial?: string | null
    attendance?: number | null
    weather?: string | null
    description?: string | null
    createdAt?: Date | string
    homeTeam: CountryCreateNestedOneWithoutHomeMatchesInput
    round?: RoundCreateNestedOneWithoutMatchesInput
    playerStats?: PlayerMatchStatCreateNestedManyWithoutMatchInput
    events?: MatchEventCreateNestedManyWithoutMatchInput
    lineups?: MatchLineupCreateNestedManyWithoutMatchInput
  }

  export type MatchUncheckedCreateWithoutAwayTeamInput = {
    id?: string
    homeTeamId: string
    homeScore?: number | null
    awayScore?: number | null
    stage?: $Enums.MatchStage
    status?: $Enums.MatchStatus
    matchDate: Date | string
    matchDatePersian?: string | null
    stadium?: string | null
    city?: string | null
    referee?: string | null
    assistant1?: string | null
    assistant2?: string | null
    fourthOfficial?: string | null
    attendance?: number | null
    weather?: string | null
    description?: string | null
    roundId?: string | null
    createdAt?: Date | string
    playerStats?: PlayerMatchStatUncheckedCreateNestedManyWithoutMatchInput
    events?: MatchEventUncheckedCreateNestedManyWithoutMatchInput
    lineups?: MatchLineupUncheckedCreateNestedManyWithoutMatchInput
  }

  export type MatchCreateOrConnectWithoutAwayTeamInput = {
    where: MatchWhereUniqueInput
    create: XOR<MatchCreateWithoutAwayTeamInput, MatchUncheckedCreateWithoutAwayTeamInput>
  }

  export type MatchCreateManyAwayTeamInputEnvelope = {
    data: MatchCreateManyAwayTeamInput | MatchCreateManyAwayTeamInput[]
    skipDuplicates?: boolean
  }

  export type GroupUpsertWithoutCountriesInput = {
    update: XOR<GroupUpdateWithoutCountriesInput, GroupUncheckedUpdateWithoutCountriesInput>
    create: XOR<GroupCreateWithoutCountriesInput, GroupUncheckedCreateWithoutCountriesInput>
    where?: GroupWhereInput
  }

  export type GroupUpdateToOneWithWhereWithoutCountriesInput = {
    where?: GroupWhereInput
    data: XOR<GroupUpdateWithoutCountriesInput, GroupUncheckedUpdateWithoutCountriesInput>
  }

  export type GroupUpdateWithoutCountriesInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
  }

  export type GroupUncheckedUpdateWithoutCountriesInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
  }

  export type PlayerUpsertWithWhereUniqueWithoutCountryInput = {
    where: PlayerWhereUniqueInput
    update: XOR<PlayerUpdateWithoutCountryInput, PlayerUncheckedUpdateWithoutCountryInput>
    create: XOR<PlayerCreateWithoutCountryInput, PlayerUncheckedCreateWithoutCountryInput>
  }

  export type PlayerUpdateWithWhereUniqueWithoutCountryInput = {
    where: PlayerWhereUniqueInput
    data: XOR<PlayerUpdateWithoutCountryInput, PlayerUncheckedUpdateWithoutCountryInput>
  }

  export type PlayerUpdateManyWithWhereWithoutCountryInput = {
    where: PlayerScalarWhereInput
    data: XOR<PlayerUpdateManyMutationInput, PlayerUncheckedUpdateManyWithoutCountryInput>
  }

  export type PlayerScalarWhereInput = {
    AND?: PlayerScalarWhereInput | PlayerScalarWhereInput[]
    OR?: PlayerScalarWhereInput[]
    NOT?: PlayerScalarWhereInput | PlayerScalarWhereInput[]
    id?: StringFilter<"Player"> | string
    name?: StringFilter<"Player"> | string
    image?: StringNullableFilter<"Player"> | string | null
    position?: EnumPositionFilter<"Player"> | $Enums.Position
    countryId?: StringFilter<"Player"> | string
    price?: FloatFilter<"Player"> | number
    totalPoints?: IntFilter<"Player"> | number
    isActive?: BoolFilter<"Player"> | boolean
    isGoldenCardEligible?: BoolFilter<"Player"> | boolean
    cardTier?: EnumCardTierFilter<"Player"> | $Enums.CardTier
    createdAt?: DateTimeFilter<"Player"> | Date | string
    updatedAt?: DateTimeFilter<"Player"> | Date | string
  }

  export type MatchUpsertWithWhereUniqueWithoutHomeTeamInput = {
    where: MatchWhereUniqueInput
    update: XOR<MatchUpdateWithoutHomeTeamInput, MatchUncheckedUpdateWithoutHomeTeamInput>
    create: XOR<MatchCreateWithoutHomeTeamInput, MatchUncheckedCreateWithoutHomeTeamInput>
  }

  export type MatchUpdateWithWhereUniqueWithoutHomeTeamInput = {
    where: MatchWhereUniqueInput
    data: XOR<MatchUpdateWithoutHomeTeamInput, MatchUncheckedUpdateWithoutHomeTeamInput>
  }

  export type MatchUpdateManyWithWhereWithoutHomeTeamInput = {
    where: MatchScalarWhereInput
    data: XOR<MatchUpdateManyMutationInput, MatchUncheckedUpdateManyWithoutHomeTeamInput>
  }

  export type MatchScalarWhereInput = {
    AND?: MatchScalarWhereInput | MatchScalarWhereInput[]
    OR?: MatchScalarWhereInput[]
    NOT?: MatchScalarWhereInput | MatchScalarWhereInput[]
    id?: StringFilter<"Match"> | string
    homeTeamId?: StringFilter<"Match"> | string
    awayTeamId?: StringFilter<"Match"> | string
    homeScore?: IntNullableFilter<"Match"> | number | null
    awayScore?: IntNullableFilter<"Match"> | number | null
    stage?: EnumMatchStageFilter<"Match"> | $Enums.MatchStage
    status?: EnumMatchStatusFilter<"Match"> | $Enums.MatchStatus
    matchDate?: DateTimeFilter<"Match"> | Date | string
    matchDatePersian?: StringNullableFilter<"Match"> | string | null
    stadium?: StringNullableFilter<"Match"> | string | null
    city?: StringNullableFilter<"Match"> | string | null
    referee?: StringNullableFilter<"Match"> | string | null
    assistant1?: StringNullableFilter<"Match"> | string | null
    assistant2?: StringNullableFilter<"Match"> | string | null
    fourthOfficial?: StringNullableFilter<"Match"> | string | null
    attendance?: IntNullableFilter<"Match"> | number | null
    weather?: StringNullableFilter<"Match"> | string | null
    description?: StringNullableFilter<"Match"> | string | null
    roundId?: StringNullableFilter<"Match"> | string | null
    createdAt?: DateTimeFilter<"Match"> | Date | string
  }

  export type MatchUpsertWithWhereUniqueWithoutAwayTeamInput = {
    where: MatchWhereUniqueInput
    update: XOR<MatchUpdateWithoutAwayTeamInput, MatchUncheckedUpdateWithoutAwayTeamInput>
    create: XOR<MatchCreateWithoutAwayTeamInput, MatchUncheckedCreateWithoutAwayTeamInput>
  }

  export type MatchUpdateWithWhereUniqueWithoutAwayTeamInput = {
    where: MatchWhereUniqueInput
    data: XOR<MatchUpdateWithoutAwayTeamInput, MatchUncheckedUpdateWithoutAwayTeamInput>
  }

  export type MatchUpdateManyWithWhereWithoutAwayTeamInput = {
    where: MatchScalarWhereInput
    data: XOR<MatchUpdateManyMutationInput, MatchUncheckedUpdateManyWithoutAwayTeamInput>
  }

  export type CountryCreateWithoutGroupInput = {
    id?: string
    name: string
    code: string
    flagUrl?: string | null
    flagImage?: string | null
    confederation?: string | null
    qualificationMethod?: string | null
    qualificationDate?: string | null
    participationHistory?: string | null
    bestResult?: string | null
    description?: string | null
    defaultFormation?: string
    defaultLineupPlayerIds?: CountryCreatedefaultLineupPlayerIdsInput | string[]
    defaultCaptainId?: string | null
    isEliminated?: boolean
    players?: PlayerCreateNestedManyWithoutCountryInput
    homeMatches?: MatchCreateNestedManyWithoutHomeTeamInput
    awayMatches?: MatchCreateNestedManyWithoutAwayTeamInput
  }

  export type CountryUncheckedCreateWithoutGroupInput = {
    id?: string
    name: string
    code: string
    flagUrl?: string | null
    flagImage?: string | null
    confederation?: string | null
    qualificationMethod?: string | null
    qualificationDate?: string | null
    participationHistory?: string | null
    bestResult?: string | null
    description?: string | null
    defaultFormation?: string
    defaultLineupPlayerIds?: CountryCreatedefaultLineupPlayerIdsInput | string[]
    defaultCaptainId?: string | null
    isEliminated?: boolean
    players?: PlayerUncheckedCreateNestedManyWithoutCountryInput
    homeMatches?: MatchUncheckedCreateNestedManyWithoutHomeTeamInput
    awayMatches?: MatchUncheckedCreateNestedManyWithoutAwayTeamInput
  }

  export type CountryCreateOrConnectWithoutGroupInput = {
    where: CountryWhereUniqueInput
    create: XOR<CountryCreateWithoutGroupInput, CountryUncheckedCreateWithoutGroupInput>
  }

  export type CountryCreateManyGroupInputEnvelope = {
    data: CountryCreateManyGroupInput | CountryCreateManyGroupInput[]
    skipDuplicates?: boolean
  }

  export type CountryUpsertWithWhereUniqueWithoutGroupInput = {
    where: CountryWhereUniqueInput
    update: XOR<CountryUpdateWithoutGroupInput, CountryUncheckedUpdateWithoutGroupInput>
    create: XOR<CountryCreateWithoutGroupInput, CountryUncheckedCreateWithoutGroupInput>
  }

  export type CountryUpdateWithWhereUniqueWithoutGroupInput = {
    where: CountryWhereUniqueInput
    data: XOR<CountryUpdateWithoutGroupInput, CountryUncheckedUpdateWithoutGroupInput>
  }

  export type CountryUpdateManyWithWhereWithoutGroupInput = {
    where: CountryScalarWhereInput
    data: XOR<CountryUpdateManyMutationInput, CountryUncheckedUpdateManyWithoutGroupInput>
  }

  export type CountryScalarWhereInput = {
    AND?: CountryScalarWhereInput | CountryScalarWhereInput[]
    OR?: CountryScalarWhereInput[]
    NOT?: CountryScalarWhereInput | CountryScalarWhereInput[]
    id?: StringFilter<"Country"> | string
    name?: StringFilter<"Country"> | string
    code?: StringFilter<"Country"> | string
    flagUrl?: StringNullableFilter<"Country"> | string | null
    flagImage?: StringNullableFilter<"Country"> | string | null
    confederation?: StringNullableFilter<"Country"> | string | null
    qualificationMethod?: StringNullableFilter<"Country"> | string | null
    qualificationDate?: StringNullableFilter<"Country"> | string | null
    participationHistory?: StringNullableFilter<"Country"> | string | null
    bestResult?: StringNullableFilter<"Country"> | string | null
    description?: StringNullableFilter<"Country"> | string | null
    defaultFormation?: StringFilter<"Country"> | string
    defaultLineupPlayerIds?: StringNullableListFilter<"Country">
    defaultCaptainId?: StringNullableFilter<"Country"> | string | null
    groupId?: StringNullableFilter<"Country"> | string | null
    isEliminated?: BoolFilter<"Country"> | boolean
  }

  export type CountryCreateWithoutPlayersInput = {
    id?: string
    name: string
    code: string
    flagUrl?: string | null
    flagImage?: string | null
    confederation?: string | null
    qualificationMethod?: string | null
    qualificationDate?: string | null
    participationHistory?: string | null
    bestResult?: string | null
    description?: string | null
    defaultFormation?: string
    defaultLineupPlayerIds?: CountryCreatedefaultLineupPlayerIdsInput | string[]
    defaultCaptainId?: string | null
    isEliminated?: boolean
    group?: GroupCreateNestedOneWithoutCountriesInput
    homeMatches?: MatchCreateNestedManyWithoutHomeTeamInput
    awayMatches?: MatchCreateNestedManyWithoutAwayTeamInput
  }

  export type CountryUncheckedCreateWithoutPlayersInput = {
    id?: string
    name: string
    code: string
    flagUrl?: string | null
    flagImage?: string | null
    confederation?: string | null
    qualificationMethod?: string | null
    qualificationDate?: string | null
    participationHistory?: string | null
    bestResult?: string | null
    description?: string | null
    defaultFormation?: string
    defaultLineupPlayerIds?: CountryCreatedefaultLineupPlayerIdsInput | string[]
    defaultCaptainId?: string | null
    groupId?: string | null
    isEliminated?: boolean
    homeMatches?: MatchUncheckedCreateNestedManyWithoutHomeTeamInput
    awayMatches?: MatchUncheckedCreateNestedManyWithoutAwayTeamInput
  }

  export type CountryCreateOrConnectWithoutPlayersInput = {
    where: CountryWhereUniqueInput
    create: XOR<CountryCreateWithoutPlayersInput, CountryUncheckedCreateWithoutPlayersInput>
  }

  export type PlayerMatchStatCreateWithoutPlayerInput = {
    id?: string
    goals?: number
    assists?: number
    yellowCards?: number
    redCards?: number
    minutesPlayed?: number
    cleanSheet?: boolean
    penaltySaved?: number
    penaltyMissed?: number
    ownGoals?: number
    isMotm?: boolean
    extraTimeBonus?: number
    points?: number
    match: MatchCreateNestedOneWithoutPlayerStatsInput
  }

  export type PlayerMatchStatUncheckedCreateWithoutPlayerInput = {
    id?: string
    matchId: string
    goals?: number
    assists?: number
    yellowCards?: number
    redCards?: number
    minutesPlayed?: number
    cleanSheet?: boolean
    penaltySaved?: number
    penaltyMissed?: number
    ownGoals?: number
    isMotm?: boolean
    extraTimeBonus?: number
    points?: number
  }

  export type PlayerMatchStatCreateOrConnectWithoutPlayerInput = {
    where: PlayerMatchStatWhereUniqueInput
    create: XOR<PlayerMatchStatCreateWithoutPlayerInput, PlayerMatchStatUncheckedCreateWithoutPlayerInput>
  }

  export type PlayerMatchStatCreateManyPlayerInputEnvelope = {
    data: PlayerMatchStatCreateManyPlayerInput | PlayerMatchStatCreateManyPlayerInput[]
    skipDuplicates?: boolean
  }

  export type TeamPlayerCreateWithoutPlayerInput = {
    isCaptain?: boolean
    isViceCaptain?: boolean
    isBench?: boolean
    positionIndex?: number
    team: TeamCreateNestedOneWithoutPlayersInput
    goldenCard?: GoldenCardCreateNestedOneWithoutTeamPlayerInput
  }

  export type TeamPlayerUncheckedCreateWithoutPlayerInput = {
    teamId: string
    goldenCardId?: string | null
    isCaptain?: boolean
    isViceCaptain?: boolean
    isBench?: boolean
    positionIndex?: number
  }

  export type TeamPlayerCreateOrConnectWithoutPlayerInput = {
    where: TeamPlayerWhereUniqueInput
    create: XOR<TeamPlayerCreateWithoutPlayerInput, TeamPlayerUncheckedCreateWithoutPlayerInput>
  }

  export type TeamPlayerCreateManyPlayerInputEnvelope = {
    data: TeamPlayerCreateManyPlayerInput | TeamPlayerCreateManyPlayerInput[]
    skipDuplicates?: boolean
  }

  export type MatchEventCreateWithoutPlayerInput = {
    id?: string
    type: $Enums.EventType
    minute?: number | null
    extraInfo?: string | null
    createdAt?: Date | string
    match: MatchCreateNestedOneWithoutEventsInput
  }

  export type MatchEventUncheckedCreateWithoutPlayerInput = {
    id?: string
    matchId: string
    type: $Enums.EventType
    minute?: number | null
    extraInfo?: string | null
    createdAt?: Date | string
  }

  export type MatchEventCreateOrConnectWithoutPlayerInput = {
    where: MatchEventWhereUniqueInput
    create: XOR<MatchEventCreateWithoutPlayerInput, MatchEventUncheckedCreateWithoutPlayerInput>
  }

  export type MatchEventCreateManyPlayerInputEnvelope = {
    data: MatchEventCreateManyPlayerInput | MatchEventCreateManyPlayerInput[]
    skipDuplicates?: boolean
  }

  export type GoldenCardCreateWithoutPlayerInput = {
    id?: string
    cardTier?: $Enums.CardTier
    status?: $Enums.GoldenCardStatus
    state?: $Enums.SpecialCardState
    acquiredDate?: Date | string
    openedAt?: Date | string | null
    user: UserCreateNestedOneWithoutGoldenCardsInput
    quiz?: DailyQuizCreateNestedOneWithoutAwardedCardsInput
    teamPlayer?: TeamPlayerCreateNestedOneWithoutGoldenCardInput
  }

  export type GoldenCardUncheckedCreateWithoutPlayerInput = {
    id?: string
    userId: string
    quizId?: string | null
    cardTier?: $Enums.CardTier
    status?: $Enums.GoldenCardStatus
    state?: $Enums.SpecialCardState
    acquiredDate?: Date | string
    openedAt?: Date | string | null
    teamPlayer?: TeamPlayerUncheckedCreateNestedOneWithoutGoldenCardInput
  }

  export type GoldenCardCreateOrConnectWithoutPlayerInput = {
    where: GoldenCardWhereUniqueInput
    create: XOR<GoldenCardCreateWithoutPlayerInput, GoldenCardUncheckedCreateWithoutPlayerInput>
  }

  export type GoldenCardCreateManyPlayerInputEnvelope = {
    data: GoldenCardCreateManyPlayerInput | GoldenCardCreateManyPlayerInput[]
    skipDuplicates?: boolean
  }

  export type CountryUpsertWithoutPlayersInput = {
    update: XOR<CountryUpdateWithoutPlayersInput, CountryUncheckedUpdateWithoutPlayersInput>
    create: XOR<CountryCreateWithoutPlayersInput, CountryUncheckedCreateWithoutPlayersInput>
    where?: CountryWhereInput
  }

  export type CountryUpdateToOneWithWhereWithoutPlayersInput = {
    where?: CountryWhereInput
    data: XOR<CountryUpdateWithoutPlayersInput, CountryUncheckedUpdateWithoutPlayersInput>
  }

  export type CountryUpdateWithoutPlayersInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    code?: StringFieldUpdateOperationsInput | string
    flagUrl?: NullableStringFieldUpdateOperationsInput | string | null
    flagImage?: NullableStringFieldUpdateOperationsInput | string | null
    confederation?: NullableStringFieldUpdateOperationsInput | string | null
    qualificationMethod?: NullableStringFieldUpdateOperationsInput | string | null
    qualificationDate?: NullableStringFieldUpdateOperationsInput | string | null
    participationHistory?: NullableStringFieldUpdateOperationsInput | string | null
    bestResult?: NullableStringFieldUpdateOperationsInput | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    defaultFormation?: StringFieldUpdateOperationsInput | string
    defaultLineupPlayerIds?: CountryUpdatedefaultLineupPlayerIdsInput | string[]
    defaultCaptainId?: NullableStringFieldUpdateOperationsInput | string | null
    isEliminated?: BoolFieldUpdateOperationsInput | boolean
    group?: GroupUpdateOneWithoutCountriesNestedInput
    homeMatches?: MatchUpdateManyWithoutHomeTeamNestedInput
    awayMatches?: MatchUpdateManyWithoutAwayTeamNestedInput
  }

  export type CountryUncheckedUpdateWithoutPlayersInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    code?: StringFieldUpdateOperationsInput | string
    flagUrl?: NullableStringFieldUpdateOperationsInput | string | null
    flagImage?: NullableStringFieldUpdateOperationsInput | string | null
    confederation?: NullableStringFieldUpdateOperationsInput | string | null
    qualificationMethod?: NullableStringFieldUpdateOperationsInput | string | null
    qualificationDate?: NullableStringFieldUpdateOperationsInput | string | null
    participationHistory?: NullableStringFieldUpdateOperationsInput | string | null
    bestResult?: NullableStringFieldUpdateOperationsInput | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    defaultFormation?: StringFieldUpdateOperationsInput | string
    defaultLineupPlayerIds?: CountryUpdatedefaultLineupPlayerIdsInput | string[]
    defaultCaptainId?: NullableStringFieldUpdateOperationsInput | string | null
    groupId?: NullableStringFieldUpdateOperationsInput | string | null
    isEliminated?: BoolFieldUpdateOperationsInput | boolean
    homeMatches?: MatchUncheckedUpdateManyWithoutHomeTeamNestedInput
    awayMatches?: MatchUncheckedUpdateManyWithoutAwayTeamNestedInput
  }

  export type PlayerMatchStatUpsertWithWhereUniqueWithoutPlayerInput = {
    where: PlayerMatchStatWhereUniqueInput
    update: XOR<PlayerMatchStatUpdateWithoutPlayerInput, PlayerMatchStatUncheckedUpdateWithoutPlayerInput>
    create: XOR<PlayerMatchStatCreateWithoutPlayerInput, PlayerMatchStatUncheckedCreateWithoutPlayerInput>
  }

  export type PlayerMatchStatUpdateWithWhereUniqueWithoutPlayerInput = {
    where: PlayerMatchStatWhereUniqueInput
    data: XOR<PlayerMatchStatUpdateWithoutPlayerInput, PlayerMatchStatUncheckedUpdateWithoutPlayerInput>
  }

  export type PlayerMatchStatUpdateManyWithWhereWithoutPlayerInput = {
    where: PlayerMatchStatScalarWhereInput
    data: XOR<PlayerMatchStatUpdateManyMutationInput, PlayerMatchStatUncheckedUpdateManyWithoutPlayerInput>
  }

  export type PlayerMatchStatScalarWhereInput = {
    AND?: PlayerMatchStatScalarWhereInput | PlayerMatchStatScalarWhereInput[]
    OR?: PlayerMatchStatScalarWhereInput[]
    NOT?: PlayerMatchStatScalarWhereInput | PlayerMatchStatScalarWhereInput[]
    id?: StringFilter<"PlayerMatchStat"> | string
    playerId?: StringFilter<"PlayerMatchStat"> | string
    matchId?: StringFilter<"PlayerMatchStat"> | string
    goals?: IntFilter<"PlayerMatchStat"> | number
    assists?: IntFilter<"PlayerMatchStat"> | number
    yellowCards?: IntFilter<"PlayerMatchStat"> | number
    redCards?: IntFilter<"PlayerMatchStat"> | number
    minutesPlayed?: IntFilter<"PlayerMatchStat"> | number
    cleanSheet?: BoolFilter<"PlayerMatchStat"> | boolean
    penaltySaved?: IntFilter<"PlayerMatchStat"> | number
    penaltyMissed?: IntFilter<"PlayerMatchStat"> | number
    ownGoals?: IntFilter<"PlayerMatchStat"> | number
    isMotm?: BoolFilter<"PlayerMatchStat"> | boolean
    extraTimeBonus?: IntFilter<"PlayerMatchStat"> | number
    points?: IntFilter<"PlayerMatchStat"> | number
  }

  export type TeamPlayerUpsertWithWhereUniqueWithoutPlayerInput = {
    where: TeamPlayerWhereUniqueInput
    update: XOR<TeamPlayerUpdateWithoutPlayerInput, TeamPlayerUncheckedUpdateWithoutPlayerInput>
    create: XOR<TeamPlayerCreateWithoutPlayerInput, TeamPlayerUncheckedCreateWithoutPlayerInput>
  }

  export type TeamPlayerUpdateWithWhereUniqueWithoutPlayerInput = {
    where: TeamPlayerWhereUniqueInput
    data: XOR<TeamPlayerUpdateWithoutPlayerInput, TeamPlayerUncheckedUpdateWithoutPlayerInput>
  }

  export type TeamPlayerUpdateManyWithWhereWithoutPlayerInput = {
    where: TeamPlayerScalarWhereInput
    data: XOR<TeamPlayerUpdateManyMutationInput, TeamPlayerUncheckedUpdateManyWithoutPlayerInput>
  }

  export type TeamPlayerScalarWhereInput = {
    AND?: TeamPlayerScalarWhereInput | TeamPlayerScalarWhereInput[]
    OR?: TeamPlayerScalarWhereInput[]
    NOT?: TeamPlayerScalarWhereInput | TeamPlayerScalarWhereInput[]
    teamId?: StringFilter<"TeamPlayer"> | string
    playerId?: StringFilter<"TeamPlayer"> | string
    goldenCardId?: StringNullableFilter<"TeamPlayer"> | string | null
    isCaptain?: BoolFilter<"TeamPlayer"> | boolean
    isViceCaptain?: BoolFilter<"TeamPlayer"> | boolean
    isBench?: BoolFilter<"TeamPlayer"> | boolean
    positionIndex?: IntFilter<"TeamPlayer"> | number
  }

  export type MatchEventUpsertWithWhereUniqueWithoutPlayerInput = {
    where: MatchEventWhereUniqueInput
    update: XOR<MatchEventUpdateWithoutPlayerInput, MatchEventUncheckedUpdateWithoutPlayerInput>
    create: XOR<MatchEventCreateWithoutPlayerInput, MatchEventUncheckedCreateWithoutPlayerInput>
  }

  export type MatchEventUpdateWithWhereUniqueWithoutPlayerInput = {
    where: MatchEventWhereUniqueInput
    data: XOR<MatchEventUpdateWithoutPlayerInput, MatchEventUncheckedUpdateWithoutPlayerInput>
  }

  export type MatchEventUpdateManyWithWhereWithoutPlayerInput = {
    where: MatchEventScalarWhereInput
    data: XOR<MatchEventUpdateManyMutationInput, MatchEventUncheckedUpdateManyWithoutPlayerInput>
  }

  export type MatchEventScalarWhereInput = {
    AND?: MatchEventScalarWhereInput | MatchEventScalarWhereInput[]
    OR?: MatchEventScalarWhereInput[]
    NOT?: MatchEventScalarWhereInput | MatchEventScalarWhereInput[]
    id?: StringFilter<"MatchEvent"> | string
    matchId?: StringFilter<"MatchEvent"> | string
    playerId?: StringFilter<"MatchEvent"> | string
    type?: EnumEventTypeFilter<"MatchEvent"> | $Enums.EventType
    minute?: IntNullableFilter<"MatchEvent"> | number | null
    extraInfo?: StringNullableFilter<"MatchEvent"> | string | null
    createdAt?: DateTimeFilter<"MatchEvent"> | Date | string
  }

  export type GoldenCardUpsertWithWhereUniqueWithoutPlayerInput = {
    where: GoldenCardWhereUniqueInput
    update: XOR<GoldenCardUpdateWithoutPlayerInput, GoldenCardUncheckedUpdateWithoutPlayerInput>
    create: XOR<GoldenCardCreateWithoutPlayerInput, GoldenCardUncheckedCreateWithoutPlayerInput>
  }

  export type GoldenCardUpdateWithWhereUniqueWithoutPlayerInput = {
    where: GoldenCardWhereUniqueInput
    data: XOR<GoldenCardUpdateWithoutPlayerInput, GoldenCardUncheckedUpdateWithoutPlayerInput>
  }

  export type GoldenCardUpdateManyWithWhereWithoutPlayerInput = {
    where: GoldenCardScalarWhereInput
    data: XOR<GoldenCardUpdateManyMutationInput, GoldenCardUncheckedUpdateManyWithoutPlayerInput>
  }

  export type GoldenCardScalarWhereInput = {
    AND?: GoldenCardScalarWhereInput | GoldenCardScalarWhereInput[]
    OR?: GoldenCardScalarWhereInput[]
    NOT?: GoldenCardScalarWhereInput | GoldenCardScalarWhereInput[]
    id?: StringFilter<"GoldenCard"> | string
    userId?: StringFilter<"GoldenCard"> | string
    quizId?: StringNullableFilter<"GoldenCard"> | string | null
    playerId?: StringFilter<"GoldenCard"> | string
    cardTier?: EnumCardTierFilter<"GoldenCard"> | $Enums.CardTier
    status?: EnumGoldenCardStatusFilter<"GoldenCard"> | $Enums.GoldenCardStatus
    state?: EnumSpecialCardStateFilter<"GoldenCard"> | $Enums.SpecialCardState
    acquiredDate?: DateTimeFilter<"GoldenCard"> | Date | string
    openedAt?: DateTimeNullableFilter<"GoldenCard"> | Date | string | null
  }

  export type CountryCreateWithoutHomeMatchesInput = {
    id?: string
    name: string
    code: string
    flagUrl?: string | null
    flagImage?: string | null
    confederation?: string | null
    qualificationMethod?: string | null
    qualificationDate?: string | null
    participationHistory?: string | null
    bestResult?: string | null
    description?: string | null
    defaultFormation?: string
    defaultLineupPlayerIds?: CountryCreatedefaultLineupPlayerIdsInput | string[]
    defaultCaptainId?: string | null
    isEliminated?: boolean
    group?: GroupCreateNestedOneWithoutCountriesInput
    players?: PlayerCreateNestedManyWithoutCountryInput
    awayMatches?: MatchCreateNestedManyWithoutAwayTeamInput
  }

  export type CountryUncheckedCreateWithoutHomeMatchesInput = {
    id?: string
    name: string
    code: string
    flagUrl?: string | null
    flagImage?: string | null
    confederation?: string | null
    qualificationMethod?: string | null
    qualificationDate?: string | null
    participationHistory?: string | null
    bestResult?: string | null
    description?: string | null
    defaultFormation?: string
    defaultLineupPlayerIds?: CountryCreatedefaultLineupPlayerIdsInput | string[]
    defaultCaptainId?: string | null
    groupId?: string | null
    isEliminated?: boolean
    players?: PlayerUncheckedCreateNestedManyWithoutCountryInput
    awayMatches?: MatchUncheckedCreateNestedManyWithoutAwayTeamInput
  }

  export type CountryCreateOrConnectWithoutHomeMatchesInput = {
    where: CountryWhereUniqueInput
    create: XOR<CountryCreateWithoutHomeMatchesInput, CountryUncheckedCreateWithoutHomeMatchesInput>
  }

  export type CountryCreateWithoutAwayMatchesInput = {
    id?: string
    name: string
    code: string
    flagUrl?: string | null
    flagImage?: string | null
    confederation?: string | null
    qualificationMethod?: string | null
    qualificationDate?: string | null
    participationHistory?: string | null
    bestResult?: string | null
    description?: string | null
    defaultFormation?: string
    defaultLineupPlayerIds?: CountryCreatedefaultLineupPlayerIdsInput | string[]
    defaultCaptainId?: string | null
    isEliminated?: boolean
    group?: GroupCreateNestedOneWithoutCountriesInput
    players?: PlayerCreateNestedManyWithoutCountryInput
    homeMatches?: MatchCreateNestedManyWithoutHomeTeamInput
  }

  export type CountryUncheckedCreateWithoutAwayMatchesInput = {
    id?: string
    name: string
    code: string
    flagUrl?: string | null
    flagImage?: string | null
    confederation?: string | null
    qualificationMethod?: string | null
    qualificationDate?: string | null
    participationHistory?: string | null
    bestResult?: string | null
    description?: string | null
    defaultFormation?: string
    defaultLineupPlayerIds?: CountryCreatedefaultLineupPlayerIdsInput | string[]
    defaultCaptainId?: string | null
    groupId?: string | null
    isEliminated?: boolean
    players?: PlayerUncheckedCreateNestedManyWithoutCountryInput
    homeMatches?: MatchUncheckedCreateNestedManyWithoutHomeTeamInput
  }

  export type CountryCreateOrConnectWithoutAwayMatchesInput = {
    where: CountryWhereUniqueInput
    create: XOR<CountryCreateWithoutAwayMatchesInput, CountryUncheckedCreateWithoutAwayMatchesInput>
  }

  export type RoundCreateWithoutMatchesInput = {
    id?: string
    number: number
    name: string
    isActive?: boolean
    deadline: Date | string
    createdAt?: Date | string
  }

  export type RoundUncheckedCreateWithoutMatchesInput = {
    id?: string
    number: number
    name: string
    isActive?: boolean
    deadline: Date | string
    createdAt?: Date | string
  }

  export type RoundCreateOrConnectWithoutMatchesInput = {
    where: RoundWhereUniqueInput
    create: XOR<RoundCreateWithoutMatchesInput, RoundUncheckedCreateWithoutMatchesInput>
  }

  export type PlayerMatchStatCreateWithoutMatchInput = {
    id?: string
    goals?: number
    assists?: number
    yellowCards?: number
    redCards?: number
    minutesPlayed?: number
    cleanSheet?: boolean
    penaltySaved?: number
    penaltyMissed?: number
    ownGoals?: number
    isMotm?: boolean
    extraTimeBonus?: number
    points?: number
    player: PlayerCreateNestedOneWithoutMatchStatsInput
  }

  export type PlayerMatchStatUncheckedCreateWithoutMatchInput = {
    id?: string
    playerId: string
    goals?: number
    assists?: number
    yellowCards?: number
    redCards?: number
    minutesPlayed?: number
    cleanSheet?: boolean
    penaltySaved?: number
    penaltyMissed?: number
    ownGoals?: number
    isMotm?: boolean
    extraTimeBonus?: number
    points?: number
  }

  export type PlayerMatchStatCreateOrConnectWithoutMatchInput = {
    where: PlayerMatchStatWhereUniqueInput
    create: XOR<PlayerMatchStatCreateWithoutMatchInput, PlayerMatchStatUncheckedCreateWithoutMatchInput>
  }

  export type PlayerMatchStatCreateManyMatchInputEnvelope = {
    data: PlayerMatchStatCreateManyMatchInput | PlayerMatchStatCreateManyMatchInput[]
    skipDuplicates?: boolean
  }

  export type MatchEventCreateWithoutMatchInput = {
    id?: string
    type: $Enums.EventType
    minute?: number | null
    extraInfo?: string | null
    createdAt?: Date | string
    player: PlayerCreateNestedOneWithoutEventsInput
  }

  export type MatchEventUncheckedCreateWithoutMatchInput = {
    id?: string
    playerId: string
    type: $Enums.EventType
    minute?: number | null
    extraInfo?: string | null
    createdAt?: Date | string
  }

  export type MatchEventCreateOrConnectWithoutMatchInput = {
    where: MatchEventWhereUniqueInput
    create: XOR<MatchEventCreateWithoutMatchInput, MatchEventUncheckedCreateWithoutMatchInput>
  }

  export type MatchEventCreateManyMatchInputEnvelope = {
    data: MatchEventCreateManyMatchInput | MatchEventCreateManyMatchInput[]
    skipDuplicates?: boolean
  }

  export type MatchLineupCreateWithoutMatchInput = {
    id?: string
    countryId: string
    formation: string
    playerIds?: MatchLineupCreateplayerIdsInput | string[]
  }

  export type MatchLineupUncheckedCreateWithoutMatchInput = {
    id?: string
    countryId: string
    formation: string
    playerIds?: MatchLineupCreateplayerIdsInput | string[]
  }

  export type MatchLineupCreateOrConnectWithoutMatchInput = {
    where: MatchLineupWhereUniqueInput
    create: XOR<MatchLineupCreateWithoutMatchInput, MatchLineupUncheckedCreateWithoutMatchInput>
  }

  export type MatchLineupCreateManyMatchInputEnvelope = {
    data: MatchLineupCreateManyMatchInput | MatchLineupCreateManyMatchInput[]
    skipDuplicates?: boolean
  }

  export type CountryUpsertWithoutHomeMatchesInput = {
    update: XOR<CountryUpdateWithoutHomeMatchesInput, CountryUncheckedUpdateWithoutHomeMatchesInput>
    create: XOR<CountryCreateWithoutHomeMatchesInput, CountryUncheckedCreateWithoutHomeMatchesInput>
    where?: CountryWhereInput
  }

  export type CountryUpdateToOneWithWhereWithoutHomeMatchesInput = {
    where?: CountryWhereInput
    data: XOR<CountryUpdateWithoutHomeMatchesInput, CountryUncheckedUpdateWithoutHomeMatchesInput>
  }

  export type CountryUpdateWithoutHomeMatchesInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    code?: StringFieldUpdateOperationsInput | string
    flagUrl?: NullableStringFieldUpdateOperationsInput | string | null
    flagImage?: NullableStringFieldUpdateOperationsInput | string | null
    confederation?: NullableStringFieldUpdateOperationsInput | string | null
    qualificationMethod?: NullableStringFieldUpdateOperationsInput | string | null
    qualificationDate?: NullableStringFieldUpdateOperationsInput | string | null
    participationHistory?: NullableStringFieldUpdateOperationsInput | string | null
    bestResult?: NullableStringFieldUpdateOperationsInput | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    defaultFormation?: StringFieldUpdateOperationsInput | string
    defaultLineupPlayerIds?: CountryUpdatedefaultLineupPlayerIdsInput | string[]
    defaultCaptainId?: NullableStringFieldUpdateOperationsInput | string | null
    isEliminated?: BoolFieldUpdateOperationsInput | boolean
    group?: GroupUpdateOneWithoutCountriesNestedInput
    players?: PlayerUpdateManyWithoutCountryNestedInput
    awayMatches?: MatchUpdateManyWithoutAwayTeamNestedInput
  }

  export type CountryUncheckedUpdateWithoutHomeMatchesInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    code?: StringFieldUpdateOperationsInput | string
    flagUrl?: NullableStringFieldUpdateOperationsInput | string | null
    flagImage?: NullableStringFieldUpdateOperationsInput | string | null
    confederation?: NullableStringFieldUpdateOperationsInput | string | null
    qualificationMethod?: NullableStringFieldUpdateOperationsInput | string | null
    qualificationDate?: NullableStringFieldUpdateOperationsInput | string | null
    participationHistory?: NullableStringFieldUpdateOperationsInput | string | null
    bestResult?: NullableStringFieldUpdateOperationsInput | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    defaultFormation?: StringFieldUpdateOperationsInput | string
    defaultLineupPlayerIds?: CountryUpdatedefaultLineupPlayerIdsInput | string[]
    defaultCaptainId?: NullableStringFieldUpdateOperationsInput | string | null
    groupId?: NullableStringFieldUpdateOperationsInput | string | null
    isEliminated?: BoolFieldUpdateOperationsInput | boolean
    players?: PlayerUncheckedUpdateManyWithoutCountryNestedInput
    awayMatches?: MatchUncheckedUpdateManyWithoutAwayTeamNestedInput
  }

  export type CountryUpsertWithoutAwayMatchesInput = {
    update: XOR<CountryUpdateWithoutAwayMatchesInput, CountryUncheckedUpdateWithoutAwayMatchesInput>
    create: XOR<CountryCreateWithoutAwayMatchesInput, CountryUncheckedCreateWithoutAwayMatchesInput>
    where?: CountryWhereInput
  }

  export type CountryUpdateToOneWithWhereWithoutAwayMatchesInput = {
    where?: CountryWhereInput
    data: XOR<CountryUpdateWithoutAwayMatchesInput, CountryUncheckedUpdateWithoutAwayMatchesInput>
  }

  export type CountryUpdateWithoutAwayMatchesInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    code?: StringFieldUpdateOperationsInput | string
    flagUrl?: NullableStringFieldUpdateOperationsInput | string | null
    flagImage?: NullableStringFieldUpdateOperationsInput | string | null
    confederation?: NullableStringFieldUpdateOperationsInput | string | null
    qualificationMethod?: NullableStringFieldUpdateOperationsInput | string | null
    qualificationDate?: NullableStringFieldUpdateOperationsInput | string | null
    participationHistory?: NullableStringFieldUpdateOperationsInput | string | null
    bestResult?: NullableStringFieldUpdateOperationsInput | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    defaultFormation?: StringFieldUpdateOperationsInput | string
    defaultLineupPlayerIds?: CountryUpdatedefaultLineupPlayerIdsInput | string[]
    defaultCaptainId?: NullableStringFieldUpdateOperationsInput | string | null
    isEliminated?: BoolFieldUpdateOperationsInput | boolean
    group?: GroupUpdateOneWithoutCountriesNestedInput
    players?: PlayerUpdateManyWithoutCountryNestedInput
    homeMatches?: MatchUpdateManyWithoutHomeTeamNestedInput
  }

  export type CountryUncheckedUpdateWithoutAwayMatchesInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    code?: StringFieldUpdateOperationsInput | string
    flagUrl?: NullableStringFieldUpdateOperationsInput | string | null
    flagImage?: NullableStringFieldUpdateOperationsInput | string | null
    confederation?: NullableStringFieldUpdateOperationsInput | string | null
    qualificationMethod?: NullableStringFieldUpdateOperationsInput | string | null
    qualificationDate?: NullableStringFieldUpdateOperationsInput | string | null
    participationHistory?: NullableStringFieldUpdateOperationsInput | string | null
    bestResult?: NullableStringFieldUpdateOperationsInput | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    defaultFormation?: StringFieldUpdateOperationsInput | string
    defaultLineupPlayerIds?: CountryUpdatedefaultLineupPlayerIdsInput | string[]
    defaultCaptainId?: NullableStringFieldUpdateOperationsInput | string | null
    groupId?: NullableStringFieldUpdateOperationsInput | string | null
    isEliminated?: BoolFieldUpdateOperationsInput | boolean
    players?: PlayerUncheckedUpdateManyWithoutCountryNestedInput
    homeMatches?: MatchUncheckedUpdateManyWithoutHomeTeamNestedInput
  }

  export type RoundUpsertWithoutMatchesInput = {
    update: XOR<RoundUpdateWithoutMatchesInput, RoundUncheckedUpdateWithoutMatchesInput>
    create: XOR<RoundCreateWithoutMatchesInput, RoundUncheckedCreateWithoutMatchesInput>
    where?: RoundWhereInput
  }

  export type RoundUpdateToOneWithWhereWithoutMatchesInput = {
    where?: RoundWhereInput
    data: XOR<RoundUpdateWithoutMatchesInput, RoundUncheckedUpdateWithoutMatchesInput>
  }

  export type RoundUpdateWithoutMatchesInput = {
    id?: StringFieldUpdateOperationsInput | string
    number?: IntFieldUpdateOperationsInput | number
    name?: StringFieldUpdateOperationsInput | string
    isActive?: BoolFieldUpdateOperationsInput | boolean
    deadline?: DateTimeFieldUpdateOperationsInput | Date | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type RoundUncheckedUpdateWithoutMatchesInput = {
    id?: StringFieldUpdateOperationsInput | string
    number?: IntFieldUpdateOperationsInput | number
    name?: StringFieldUpdateOperationsInput | string
    isActive?: BoolFieldUpdateOperationsInput | boolean
    deadline?: DateTimeFieldUpdateOperationsInput | Date | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type PlayerMatchStatUpsertWithWhereUniqueWithoutMatchInput = {
    where: PlayerMatchStatWhereUniqueInput
    update: XOR<PlayerMatchStatUpdateWithoutMatchInput, PlayerMatchStatUncheckedUpdateWithoutMatchInput>
    create: XOR<PlayerMatchStatCreateWithoutMatchInput, PlayerMatchStatUncheckedCreateWithoutMatchInput>
  }

  export type PlayerMatchStatUpdateWithWhereUniqueWithoutMatchInput = {
    where: PlayerMatchStatWhereUniqueInput
    data: XOR<PlayerMatchStatUpdateWithoutMatchInput, PlayerMatchStatUncheckedUpdateWithoutMatchInput>
  }

  export type PlayerMatchStatUpdateManyWithWhereWithoutMatchInput = {
    where: PlayerMatchStatScalarWhereInput
    data: XOR<PlayerMatchStatUpdateManyMutationInput, PlayerMatchStatUncheckedUpdateManyWithoutMatchInput>
  }

  export type MatchEventUpsertWithWhereUniqueWithoutMatchInput = {
    where: MatchEventWhereUniqueInput
    update: XOR<MatchEventUpdateWithoutMatchInput, MatchEventUncheckedUpdateWithoutMatchInput>
    create: XOR<MatchEventCreateWithoutMatchInput, MatchEventUncheckedCreateWithoutMatchInput>
  }

  export type MatchEventUpdateWithWhereUniqueWithoutMatchInput = {
    where: MatchEventWhereUniqueInput
    data: XOR<MatchEventUpdateWithoutMatchInput, MatchEventUncheckedUpdateWithoutMatchInput>
  }

  export type MatchEventUpdateManyWithWhereWithoutMatchInput = {
    where: MatchEventScalarWhereInput
    data: XOR<MatchEventUpdateManyMutationInput, MatchEventUncheckedUpdateManyWithoutMatchInput>
  }

  export type MatchLineupUpsertWithWhereUniqueWithoutMatchInput = {
    where: MatchLineupWhereUniqueInput
    update: XOR<MatchLineupUpdateWithoutMatchInput, MatchLineupUncheckedUpdateWithoutMatchInput>
    create: XOR<MatchLineupCreateWithoutMatchInput, MatchLineupUncheckedCreateWithoutMatchInput>
  }

  export type MatchLineupUpdateWithWhereUniqueWithoutMatchInput = {
    where: MatchLineupWhereUniqueInput
    data: XOR<MatchLineupUpdateWithoutMatchInput, MatchLineupUncheckedUpdateWithoutMatchInput>
  }

  export type MatchLineupUpdateManyWithWhereWithoutMatchInput = {
    where: MatchLineupScalarWhereInput
    data: XOR<MatchLineupUpdateManyMutationInput, MatchLineupUncheckedUpdateManyWithoutMatchInput>
  }

  export type MatchLineupScalarWhereInput = {
    AND?: MatchLineupScalarWhereInput | MatchLineupScalarWhereInput[]
    OR?: MatchLineupScalarWhereInput[]
    NOT?: MatchLineupScalarWhereInput | MatchLineupScalarWhereInput[]
    id?: StringFilter<"MatchLineup"> | string
    matchId?: StringFilter<"MatchLineup"> | string
    countryId?: StringFilter<"MatchLineup"> | string
    formation?: StringFilter<"MatchLineup"> | string
    playerIds?: StringNullableListFilter<"MatchLineup">
  }

  export type MatchCreateWithoutRoundInput = {
    id?: string
    homeScore?: number | null
    awayScore?: number | null
    stage?: $Enums.MatchStage
    status?: $Enums.MatchStatus
    matchDate: Date | string
    matchDatePersian?: string | null
    stadium?: string | null
    city?: string | null
    referee?: string | null
    assistant1?: string | null
    assistant2?: string | null
    fourthOfficial?: string | null
    attendance?: number | null
    weather?: string | null
    description?: string | null
    createdAt?: Date | string
    homeTeam: CountryCreateNestedOneWithoutHomeMatchesInput
    awayTeam: CountryCreateNestedOneWithoutAwayMatchesInput
    playerStats?: PlayerMatchStatCreateNestedManyWithoutMatchInput
    events?: MatchEventCreateNestedManyWithoutMatchInput
    lineups?: MatchLineupCreateNestedManyWithoutMatchInput
  }

  export type MatchUncheckedCreateWithoutRoundInput = {
    id?: string
    homeTeamId: string
    awayTeamId: string
    homeScore?: number | null
    awayScore?: number | null
    stage?: $Enums.MatchStage
    status?: $Enums.MatchStatus
    matchDate: Date | string
    matchDatePersian?: string | null
    stadium?: string | null
    city?: string | null
    referee?: string | null
    assistant1?: string | null
    assistant2?: string | null
    fourthOfficial?: string | null
    attendance?: number | null
    weather?: string | null
    description?: string | null
    createdAt?: Date | string
    playerStats?: PlayerMatchStatUncheckedCreateNestedManyWithoutMatchInput
    events?: MatchEventUncheckedCreateNestedManyWithoutMatchInput
    lineups?: MatchLineupUncheckedCreateNestedManyWithoutMatchInput
  }

  export type MatchCreateOrConnectWithoutRoundInput = {
    where: MatchWhereUniqueInput
    create: XOR<MatchCreateWithoutRoundInput, MatchUncheckedCreateWithoutRoundInput>
  }

  export type MatchCreateManyRoundInputEnvelope = {
    data: MatchCreateManyRoundInput | MatchCreateManyRoundInput[]
    skipDuplicates?: boolean
  }

  export type MatchUpsertWithWhereUniqueWithoutRoundInput = {
    where: MatchWhereUniqueInput
    update: XOR<MatchUpdateWithoutRoundInput, MatchUncheckedUpdateWithoutRoundInput>
    create: XOR<MatchCreateWithoutRoundInput, MatchUncheckedCreateWithoutRoundInput>
  }

  export type MatchUpdateWithWhereUniqueWithoutRoundInput = {
    where: MatchWhereUniqueInput
    data: XOR<MatchUpdateWithoutRoundInput, MatchUncheckedUpdateWithoutRoundInput>
  }

  export type MatchUpdateManyWithWhereWithoutRoundInput = {
    where: MatchScalarWhereInput
    data: XOR<MatchUpdateManyMutationInput, MatchUncheckedUpdateManyWithoutRoundInput>
  }

  export type MatchCreateWithoutEventsInput = {
    id?: string
    homeScore?: number | null
    awayScore?: number | null
    stage?: $Enums.MatchStage
    status?: $Enums.MatchStatus
    matchDate: Date | string
    matchDatePersian?: string | null
    stadium?: string | null
    city?: string | null
    referee?: string | null
    assistant1?: string | null
    assistant2?: string | null
    fourthOfficial?: string | null
    attendance?: number | null
    weather?: string | null
    description?: string | null
    createdAt?: Date | string
    homeTeam: CountryCreateNestedOneWithoutHomeMatchesInput
    awayTeam: CountryCreateNestedOneWithoutAwayMatchesInput
    round?: RoundCreateNestedOneWithoutMatchesInput
    playerStats?: PlayerMatchStatCreateNestedManyWithoutMatchInput
    lineups?: MatchLineupCreateNestedManyWithoutMatchInput
  }

  export type MatchUncheckedCreateWithoutEventsInput = {
    id?: string
    homeTeamId: string
    awayTeamId: string
    homeScore?: number | null
    awayScore?: number | null
    stage?: $Enums.MatchStage
    status?: $Enums.MatchStatus
    matchDate: Date | string
    matchDatePersian?: string | null
    stadium?: string | null
    city?: string | null
    referee?: string | null
    assistant1?: string | null
    assistant2?: string | null
    fourthOfficial?: string | null
    attendance?: number | null
    weather?: string | null
    description?: string | null
    roundId?: string | null
    createdAt?: Date | string
    playerStats?: PlayerMatchStatUncheckedCreateNestedManyWithoutMatchInput
    lineups?: MatchLineupUncheckedCreateNestedManyWithoutMatchInput
  }

  export type MatchCreateOrConnectWithoutEventsInput = {
    where: MatchWhereUniqueInput
    create: XOR<MatchCreateWithoutEventsInput, MatchUncheckedCreateWithoutEventsInput>
  }

  export type PlayerCreateWithoutEventsInput = {
    id?: string
    name: string
    image?: string | null
    position: $Enums.Position
    price?: number
    totalPoints?: number
    isActive?: boolean
    isGoldenCardEligible?: boolean
    cardTier?: $Enums.CardTier
    createdAt?: Date | string
    updatedAt?: Date | string
    country: CountryCreateNestedOneWithoutPlayersInput
    matchStats?: PlayerMatchStatCreateNestedManyWithoutPlayerInput
    teamPlayers?: TeamPlayerCreateNestedManyWithoutPlayerInput
    goldenCards?: GoldenCardCreateNestedManyWithoutPlayerInput
  }

  export type PlayerUncheckedCreateWithoutEventsInput = {
    id?: string
    name: string
    image?: string | null
    position: $Enums.Position
    countryId: string
    price?: number
    totalPoints?: number
    isActive?: boolean
    isGoldenCardEligible?: boolean
    cardTier?: $Enums.CardTier
    createdAt?: Date | string
    updatedAt?: Date | string
    matchStats?: PlayerMatchStatUncheckedCreateNestedManyWithoutPlayerInput
    teamPlayers?: TeamPlayerUncheckedCreateNestedManyWithoutPlayerInput
    goldenCards?: GoldenCardUncheckedCreateNestedManyWithoutPlayerInput
  }

  export type PlayerCreateOrConnectWithoutEventsInput = {
    where: PlayerWhereUniqueInput
    create: XOR<PlayerCreateWithoutEventsInput, PlayerUncheckedCreateWithoutEventsInput>
  }

  export type MatchUpsertWithoutEventsInput = {
    update: XOR<MatchUpdateWithoutEventsInput, MatchUncheckedUpdateWithoutEventsInput>
    create: XOR<MatchCreateWithoutEventsInput, MatchUncheckedCreateWithoutEventsInput>
    where?: MatchWhereInput
  }

  export type MatchUpdateToOneWithWhereWithoutEventsInput = {
    where?: MatchWhereInput
    data: XOR<MatchUpdateWithoutEventsInput, MatchUncheckedUpdateWithoutEventsInput>
  }

  export type MatchUpdateWithoutEventsInput = {
    id?: StringFieldUpdateOperationsInput | string
    homeScore?: NullableIntFieldUpdateOperationsInput | number | null
    awayScore?: NullableIntFieldUpdateOperationsInput | number | null
    stage?: EnumMatchStageFieldUpdateOperationsInput | $Enums.MatchStage
    status?: EnumMatchStatusFieldUpdateOperationsInput | $Enums.MatchStatus
    matchDate?: DateTimeFieldUpdateOperationsInput | Date | string
    matchDatePersian?: NullableStringFieldUpdateOperationsInput | string | null
    stadium?: NullableStringFieldUpdateOperationsInput | string | null
    city?: NullableStringFieldUpdateOperationsInput | string | null
    referee?: NullableStringFieldUpdateOperationsInput | string | null
    assistant1?: NullableStringFieldUpdateOperationsInput | string | null
    assistant2?: NullableStringFieldUpdateOperationsInput | string | null
    fourthOfficial?: NullableStringFieldUpdateOperationsInput | string | null
    attendance?: NullableIntFieldUpdateOperationsInput | number | null
    weather?: NullableStringFieldUpdateOperationsInput | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    homeTeam?: CountryUpdateOneRequiredWithoutHomeMatchesNestedInput
    awayTeam?: CountryUpdateOneRequiredWithoutAwayMatchesNestedInput
    round?: RoundUpdateOneWithoutMatchesNestedInput
    playerStats?: PlayerMatchStatUpdateManyWithoutMatchNestedInput
    lineups?: MatchLineupUpdateManyWithoutMatchNestedInput
  }

  export type MatchUncheckedUpdateWithoutEventsInput = {
    id?: StringFieldUpdateOperationsInput | string
    homeTeamId?: StringFieldUpdateOperationsInput | string
    awayTeamId?: StringFieldUpdateOperationsInput | string
    homeScore?: NullableIntFieldUpdateOperationsInput | number | null
    awayScore?: NullableIntFieldUpdateOperationsInput | number | null
    stage?: EnumMatchStageFieldUpdateOperationsInput | $Enums.MatchStage
    status?: EnumMatchStatusFieldUpdateOperationsInput | $Enums.MatchStatus
    matchDate?: DateTimeFieldUpdateOperationsInput | Date | string
    matchDatePersian?: NullableStringFieldUpdateOperationsInput | string | null
    stadium?: NullableStringFieldUpdateOperationsInput | string | null
    city?: NullableStringFieldUpdateOperationsInput | string | null
    referee?: NullableStringFieldUpdateOperationsInput | string | null
    assistant1?: NullableStringFieldUpdateOperationsInput | string | null
    assistant2?: NullableStringFieldUpdateOperationsInput | string | null
    fourthOfficial?: NullableStringFieldUpdateOperationsInput | string | null
    attendance?: NullableIntFieldUpdateOperationsInput | number | null
    weather?: NullableStringFieldUpdateOperationsInput | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    roundId?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    playerStats?: PlayerMatchStatUncheckedUpdateManyWithoutMatchNestedInput
    lineups?: MatchLineupUncheckedUpdateManyWithoutMatchNestedInput
  }

  export type PlayerUpsertWithoutEventsInput = {
    update: XOR<PlayerUpdateWithoutEventsInput, PlayerUncheckedUpdateWithoutEventsInput>
    create: XOR<PlayerCreateWithoutEventsInput, PlayerUncheckedCreateWithoutEventsInput>
    where?: PlayerWhereInput
  }

  export type PlayerUpdateToOneWithWhereWithoutEventsInput = {
    where?: PlayerWhereInput
    data: XOR<PlayerUpdateWithoutEventsInput, PlayerUncheckedUpdateWithoutEventsInput>
  }

  export type PlayerUpdateWithoutEventsInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    image?: NullableStringFieldUpdateOperationsInput | string | null
    position?: EnumPositionFieldUpdateOperationsInput | $Enums.Position
    price?: FloatFieldUpdateOperationsInput | number
    totalPoints?: IntFieldUpdateOperationsInput | number
    isActive?: BoolFieldUpdateOperationsInput | boolean
    isGoldenCardEligible?: BoolFieldUpdateOperationsInput | boolean
    cardTier?: EnumCardTierFieldUpdateOperationsInput | $Enums.CardTier
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    country?: CountryUpdateOneRequiredWithoutPlayersNestedInput
    matchStats?: PlayerMatchStatUpdateManyWithoutPlayerNestedInput
    teamPlayers?: TeamPlayerUpdateManyWithoutPlayerNestedInput
    goldenCards?: GoldenCardUpdateManyWithoutPlayerNestedInput
  }

  export type PlayerUncheckedUpdateWithoutEventsInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    image?: NullableStringFieldUpdateOperationsInput | string | null
    position?: EnumPositionFieldUpdateOperationsInput | $Enums.Position
    countryId?: StringFieldUpdateOperationsInput | string
    price?: FloatFieldUpdateOperationsInput | number
    totalPoints?: IntFieldUpdateOperationsInput | number
    isActive?: BoolFieldUpdateOperationsInput | boolean
    isGoldenCardEligible?: BoolFieldUpdateOperationsInput | boolean
    cardTier?: EnumCardTierFieldUpdateOperationsInput | $Enums.CardTier
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    matchStats?: PlayerMatchStatUncheckedUpdateManyWithoutPlayerNestedInput
    teamPlayers?: TeamPlayerUncheckedUpdateManyWithoutPlayerNestedInput
    goldenCards?: GoldenCardUncheckedUpdateManyWithoutPlayerNestedInput
  }

  export type MatchCreateWithoutLineupsInput = {
    id?: string
    homeScore?: number | null
    awayScore?: number | null
    stage?: $Enums.MatchStage
    status?: $Enums.MatchStatus
    matchDate: Date | string
    matchDatePersian?: string | null
    stadium?: string | null
    city?: string | null
    referee?: string | null
    assistant1?: string | null
    assistant2?: string | null
    fourthOfficial?: string | null
    attendance?: number | null
    weather?: string | null
    description?: string | null
    createdAt?: Date | string
    homeTeam: CountryCreateNestedOneWithoutHomeMatchesInput
    awayTeam: CountryCreateNestedOneWithoutAwayMatchesInput
    round?: RoundCreateNestedOneWithoutMatchesInput
    playerStats?: PlayerMatchStatCreateNestedManyWithoutMatchInput
    events?: MatchEventCreateNestedManyWithoutMatchInput
  }

  export type MatchUncheckedCreateWithoutLineupsInput = {
    id?: string
    homeTeamId: string
    awayTeamId: string
    homeScore?: number | null
    awayScore?: number | null
    stage?: $Enums.MatchStage
    status?: $Enums.MatchStatus
    matchDate: Date | string
    matchDatePersian?: string | null
    stadium?: string | null
    city?: string | null
    referee?: string | null
    assistant1?: string | null
    assistant2?: string | null
    fourthOfficial?: string | null
    attendance?: number | null
    weather?: string | null
    description?: string | null
    roundId?: string | null
    createdAt?: Date | string
    playerStats?: PlayerMatchStatUncheckedCreateNestedManyWithoutMatchInput
    events?: MatchEventUncheckedCreateNestedManyWithoutMatchInput
  }

  export type MatchCreateOrConnectWithoutLineupsInput = {
    where: MatchWhereUniqueInput
    create: XOR<MatchCreateWithoutLineupsInput, MatchUncheckedCreateWithoutLineupsInput>
  }

  export type MatchUpsertWithoutLineupsInput = {
    update: XOR<MatchUpdateWithoutLineupsInput, MatchUncheckedUpdateWithoutLineupsInput>
    create: XOR<MatchCreateWithoutLineupsInput, MatchUncheckedCreateWithoutLineupsInput>
    where?: MatchWhereInput
  }

  export type MatchUpdateToOneWithWhereWithoutLineupsInput = {
    where?: MatchWhereInput
    data: XOR<MatchUpdateWithoutLineupsInput, MatchUncheckedUpdateWithoutLineupsInput>
  }

  export type MatchUpdateWithoutLineupsInput = {
    id?: StringFieldUpdateOperationsInput | string
    homeScore?: NullableIntFieldUpdateOperationsInput | number | null
    awayScore?: NullableIntFieldUpdateOperationsInput | number | null
    stage?: EnumMatchStageFieldUpdateOperationsInput | $Enums.MatchStage
    status?: EnumMatchStatusFieldUpdateOperationsInput | $Enums.MatchStatus
    matchDate?: DateTimeFieldUpdateOperationsInput | Date | string
    matchDatePersian?: NullableStringFieldUpdateOperationsInput | string | null
    stadium?: NullableStringFieldUpdateOperationsInput | string | null
    city?: NullableStringFieldUpdateOperationsInput | string | null
    referee?: NullableStringFieldUpdateOperationsInput | string | null
    assistant1?: NullableStringFieldUpdateOperationsInput | string | null
    assistant2?: NullableStringFieldUpdateOperationsInput | string | null
    fourthOfficial?: NullableStringFieldUpdateOperationsInput | string | null
    attendance?: NullableIntFieldUpdateOperationsInput | number | null
    weather?: NullableStringFieldUpdateOperationsInput | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    homeTeam?: CountryUpdateOneRequiredWithoutHomeMatchesNestedInput
    awayTeam?: CountryUpdateOneRequiredWithoutAwayMatchesNestedInput
    round?: RoundUpdateOneWithoutMatchesNestedInput
    playerStats?: PlayerMatchStatUpdateManyWithoutMatchNestedInput
    events?: MatchEventUpdateManyWithoutMatchNestedInput
  }

  export type MatchUncheckedUpdateWithoutLineupsInput = {
    id?: StringFieldUpdateOperationsInput | string
    homeTeamId?: StringFieldUpdateOperationsInput | string
    awayTeamId?: StringFieldUpdateOperationsInput | string
    homeScore?: NullableIntFieldUpdateOperationsInput | number | null
    awayScore?: NullableIntFieldUpdateOperationsInput | number | null
    stage?: EnumMatchStageFieldUpdateOperationsInput | $Enums.MatchStage
    status?: EnumMatchStatusFieldUpdateOperationsInput | $Enums.MatchStatus
    matchDate?: DateTimeFieldUpdateOperationsInput | Date | string
    matchDatePersian?: NullableStringFieldUpdateOperationsInput | string | null
    stadium?: NullableStringFieldUpdateOperationsInput | string | null
    city?: NullableStringFieldUpdateOperationsInput | string | null
    referee?: NullableStringFieldUpdateOperationsInput | string | null
    assistant1?: NullableStringFieldUpdateOperationsInput | string | null
    assistant2?: NullableStringFieldUpdateOperationsInput | string | null
    fourthOfficial?: NullableStringFieldUpdateOperationsInput | string | null
    attendance?: NullableIntFieldUpdateOperationsInput | number | null
    weather?: NullableStringFieldUpdateOperationsInput | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    roundId?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    playerStats?: PlayerMatchStatUncheckedUpdateManyWithoutMatchNestedInput
    events?: MatchEventUncheckedUpdateManyWithoutMatchNestedInput
  }

  export type PlayerCreateWithoutMatchStatsInput = {
    id?: string
    name: string
    image?: string | null
    position: $Enums.Position
    price?: number
    totalPoints?: number
    isActive?: boolean
    isGoldenCardEligible?: boolean
    cardTier?: $Enums.CardTier
    createdAt?: Date | string
    updatedAt?: Date | string
    country: CountryCreateNestedOneWithoutPlayersInput
    teamPlayers?: TeamPlayerCreateNestedManyWithoutPlayerInput
    events?: MatchEventCreateNestedManyWithoutPlayerInput
    goldenCards?: GoldenCardCreateNestedManyWithoutPlayerInput
  }

  export type PlayerUncheckedCreateWithoutMatchStatsInput = {
    id?: string
    name: string
    image?: string | null
    position: $Enums.Position
    countryId: string
    price?: number
    totalPoints?: number
    isActive?: boolean
    isGoldenCardEligible?: boolean
    cardTier?: $Enums.CardTier
    createdAt?: Date | string
    updatedAt?: Date | string
    teamPlayers?: TeamPlayerUncheckedCreateNestedManyWithoutPlayerInput
    events?: MatchEventUncheckedCreateNestedManyWithoutPlayerInput
    goldenCards?: GoldenCardUncheckedCreateNestedManyWithoutPlayerInput
  }

  export type PlayerCreateOrConnectWithoutMatchStatsInput = {
    where: PlayerWhereUniqueInput
    create: XOR<PlayerCreateWithoutMatchStatsInput, PlayerUncheckedCreateWithoutMatchStatsInput>
  }

  export type MatchCreateWithoutPlayerStatsInput = {
    id?: string
    homeScore?: number | null
    awayScore?: number | null
    stage?: $Enums.MatchStage
    status?: $Enums.MatchStatus
    matchDate: Date | string
    matchDatePersian?: string | null
    stadium?: string | null
    city?: string | null
    referee?: string | null
    assistant1?: string | null
    assistant2?: string | null
    fourthOfficial?: string | null
    attendance?: number | null
    weather?: string | null
    description?: string | null
    createdAt?: Date | string
    homeTeam: CountryCreateNestedOneWithoutHomeMatchesInput
    awayTeam: CountryCreateNestedOneWithoutAwayMatchesInput
    round?: RoundCreateNestedOneWithoutMatchesInput
    events?: MatchEventCreateNestedManyWithoutMatchInput
    lineups?: MatchLineupCreateNestedManyWithoutMatchInput
  }

  export type MatchUncheckedCreateWithoutPlayerStatsInput = {
    id?: string
    homeTeamId: string
    awayTeamId: string
    homeScore?: number | null
    awayScore?: number | null
    stage?: $Enums.MatchStage
    status?: $Enums.MatchStatus
    matchDate: Date | string
    matchDatePersian?: string | null
    stadium?: string | null
    city?: string | null
    referee?: string | null
    assistant1?: string | null
    assistant2?: string | null
    fourthOfficial?: string | null
    attendance?: number | null
    weather?: string | null
    description?: string | null
    roundId?: string | null
    createdAt?: Date | string
    events?: MatchEventUncheckedCreateNestedManyWithoutMatchInput
    lineups?: MatchLineupUncheckedCreateNestedManyWithoutMatchInput
  }

  export type MatchCreateOrConnectWithoutPlayerStatsInput = {
    where: MatchWhereUniqueInput
    create: XOR<MatchCreateWithoutPlayerStatsInput, MatchUncheckedCreateWithoutPlayerStatsInput>
  }

  export type PlayerUpsertWithoutMatchStatsInput = {
    update: XOR<PlayerUpdateWithoutMatchStatsInput, PlayerUncheckedUpdateWithoutMatchStatsInput>
    create: XOR<PlayerCreateWithoutMatchStatsInput, PlayerUncheckedCreateWithoutMatchStatsInput>
    where?: PlayerWhereInput
  }

  export type PlayerUpdateToOneWithWhereWithoutMatchStatsInput = {
    where?: PlayerWhereInput
    data: XOR<PlayerUpdateWithoutMatchStatsInput, PlayerUncheckedUpdateWithoutMatchStatsInput>
  }

  export type PlayerUpdateWithoutMatchStatsInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    image?: NullableStringFieldUpdateOperationsInput | string | null
    position?: EnumPositionFieldUpdateOperationsInput | $Enums.Position
    price?: FloatFieldUpdateOperationsInput | number
    totalPoints?: IntFieldUpdateOperationsInput | number
    isActive?: BoolFieldUpdateOperationsInput | boolean
    isGoldenCardEligible?: BoolFieldUpdateOperationsInput | boolean
    cardTier?: EnumCardTierFieldUpdateOperationsInput | $Enums.CardTier
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    country?: CountryUpdateOneRequiredWithoutPlayersNestedInput
    teamPlayers?: TeamPlayerUpdateManyWithoutPlayerNestedInput
    events?: MatchEventUpdateManyWithoutPlayerNestedInput
    goldenCards?: GoldenCardUpdateManyWithoutPlayerNestedInput
  }

  export type PlayerUncheckedUpdateWithoutMatchStatsInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    image?: NullableStringFieldUpdateOperationsInput | string | null
    position?: EnumPositionFieldUpdateOperationsInput | $Enums.Position
    countryId?: StringFieldUpdateOperationsInput | string
    price?: FloatFieldUpdateOperationsInput | number
    totalPoints?: IntFieldUpdateOperationsInput | number
    isActive?: BoolFieldUpdateOperationsInput | boolean
    isGoldenCardEligible?: BoolFieldUpdateOperationsInput | boolean
    cardTier?: EnumCardTierFieldUpdateOperationsInput | $Enums.CardTier
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    teamPlayers?: TeamPlayerUncheckedUpdateManyWithoutPlayerNestedInput
    events?: MatchEventUncheckedUpdateManyWithoutPlayerNestedInput
    goldenCards?: GoldenCardUncheckedUpdateManyWithoutPlayerNestedInput
  }

  export type MatchUpsertWithoutPlayerStatsInput = {
    update: XOR<MatchUpdateWithoutPlayerStatsInput, MatchUncheckedUpdateWithoutPlayerStatsInput>
    create: XOR<MatchCreateWithoutPlayerStatsInput, MatchUncheckedCreateWithoutPlayerStatsInput>
    where?: MatchWhereInput
  }

  export type MatchUpdateToOneWithWhereWithoutPlayerStatsInput = {
    where?: MatchWhereInput
    data: XOR<MatchUpdateWithoutPlayerStatsInput, MatchUncheckedUpdateWithoutPlayerStatsInput>
  }

  export type MatchUpdateWithoutPlayerStatsInput = {
    id?: StringFieldUpdateOperationsInput | string
    homeScore?: NullableIntFieldUpdateOperationsInput | number | null
    awayScore?: NullableIntFieldUpdateOperationsInput | number | null
    stage?: EnumMatchStageFieldUpdateOperationsInput | $Enums.MatchStage
    status?: EnumMatchStatusFieldUpdateOperationsInput | $Enums.MatchStatus
    matchDate?: DateTimeFieldUpdateOperationsInput | Date | string
    matchDatePersian?: NullableStringFieldUpdateOperationsInput | string | null
    stadium?: NullableStringFieldUpdateOperationsInput | string | null
    city?: NullableStringFieldUpdateOperationsInput | string | null
    referee?: NullableStringFieldUpdateOperationsInput | string | null
    assistant1?: NullableStringFieldUpdateOperationsInput | string | null
    assistant2?: NullableStringFieldUpdateOperationsInput | string | null
    fourthOfficial?: NullableStringFieldUpdateOperationsInput | string | null
    attendance?: NullableIntFieldUpdateOperationsInput | number | null
    weather?: NullableStringFieldUpdateOperationsInput | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    homeTeam?: CountryUpdateOneRequiredWithoutHomeMatchesNestedInput
    awayTeam?: CountryUpdateOneRequiredWithoutAwayMatchesNestedInput
    round?: RoundUpdateOneWithoutMatchesNestedInput
    events?: MatchEventUpdateManyWithoutMatchNestedInput
    lineups?: MatchLineupUpdateManyWithoutMatchNestedInput
  }

  export type MatchUncheckedUpdateWithoutPlayerStatsInput = {
    id?: StringFieldUpdateOperationsInput | string
    homeTeamId?: StringFieldUpdateOperationsInput | string
    awayTeamId?: StringFieldUpdateOperationsInput | string
    homeScore?: NullableIntFieldUpdateOperationsInput | number | null
    awayScore?: NullableIntFieldUpdateOperationsInput | number | null
    stage?: EnumMatchStageFieldUpdateOperationsInput | $Enums.MatchStage
    status?: EnumMatchStatusFieldUpdateOperationsInput | $Enums.MatchStatus
    matchDate?: DateTimeFieldUpdateOperationsInput | Date | string
    matchDatePersian?: NullableStringFieldUpdateOperationsInput | string | null
    stadium?: NullableStringFieldUpdateOperationsInput | string | null
    city?: NullableStringFieldUpdateOperationsInput | string | null
    referee?: NullableStringFieldUpdateOperationsInput | string | null
    assistant1?: NullableStringFieldUpdateOperationsInput | string | null
    assistant2?: NullableStringFieldUpdateOperationsInput | string | null
    fourthOfficial?: NullableStringFieldUpdateOperationsInput | string | null
    attendance?: NullableIntFieldUpdateOperationsInput | number | null
    weather?: NullableStringFieldUpdateOperationsInput | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    roundId?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    events?: MatchEventUncheckedUpdateManyWithoutMatchNestedInput
    lineups?: MatchLineupUncheckedUpdateManyWithoutMatchNestedInput
  }

  export type TeamCreateWithoutUserInput = {
    id?: string
    name: string
    budget?: number
    totalPoints?: number
    formation?: string
    status?: $Enums.TeamStatus
    createdAt?: Date | string
    players?: TeamPlayerCreateNestedManyWithoutTeamInput
  }

  export type TeamUncheckedCreateWithoutUserInput = {
    id?: string
    name: string
    budget?: number
    totalPoints?: number
    formation?: string
    status?: $Enums.TeamStatus
    createdAt?: Date | string
    players?: TeamPlayerUncheckedCreateNestedManyWithoutTeamInput
  }

  export type TeamCreateOrConnectWithoutUserInput = {
    where: TeamWhereUniqueInput
    create: XOR<TeamCreateWithoutUserInput, TeamUncheckedCreateWithoutUserInput>
  }

  export type SessionCreateWithoutUserInput = {
    id?: string
    sessionToken: string
    expires: Date | string
  }

  export type SessionUncheckedCreateWithoutUserInput = {
    id?: string
    sessionToken: string
    expires: Date | string
  }

  export type SessionCreateOrConnectWithoutUserInput = {
    where: SessionWhereUniqueInput
    create: XOR<SessionCreateWithoutUserInput, SessionUncheckedCreateWithoutUserInput>
  }

  export type SessionCreateManyUserInputEnvelope = {
    data: SessionCreateManyUserInput | SessionCreateManyUserInput[]
    skipDuplicates?: boolean
  }

  export type PaymentCreateWithoutUserInput = {
    id?: string
    amount: number
    authority?: string | null
    refId?: string | null
    status?: $Enums.PaymentStatus
    createdAt?: Date | string
    updatedAt?: Date | string
    package: PackageCreateNestedOneWithoutPaymentsInput
  }

  export type PaymentUncheckedCreateWithoutUserInput = {
    id?: string
    packageId: string
    amount: number
    authority?: string | null
    refId?: string | null
    status?: $Enums.PaymentStatus
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type PaymentCreateOrConnectWithoutUserInput = {
    where: PaymentWhereUniqueInput
    create: XOR<PaymentCreateWithoutUserInput, PaymentUncheckedCreateWithoutUserInput>
  }

  export type PaymentCreateManyUserInputEnvelope = {
    data: PaymentCreateManyUserInput | PaymentCreateManyUserInput[]
    skipDuplicates?: boolean
  }

  export type QuizSubmissionCreateWithoutUserInput = {
    id?: string
    answers?: QuizSubmissionCreateanswersInput | number[]
    correctAnswers?: number
    score?: number
    submittedAt?: Date | string
    quiz: DailyQuizCreateNestedOneWithoutSubmissionsInput
  }

  export type QuizSubmissionUncheckedCreateWithoutUserInput = {
    id?: string
    quizId: string
    answers?: QuizSubmissionCreateanswersInput | number[]
    correctAnswers?: number
    score?: number
    submittedAt?: Date | string
  }

  export type QuizSubmissionCreateOrConnectWithoutUserInput = {
    where: QuizSubmissionWhereUniqueInput
    create: XOR<QuizSubmissionCreateWithoutUserInput, QuizSubmissionUncheckedCreateWithoutUserInput>
  }

  export type QuizSubmissionCreateManyUserInputEnvelope = {
    data: QuizSubmissionCreateManyUserInput | QuizSubmissionCreateManyUserInput[]
    skipDuplicates?: boolean
  }

  export type GoldenCardCreateWithoutUserInput = {
    id?: string
    cardTier?: $Enums.CardTier
    status?: $Enums.GoldenCardStatus
    state?: $Enums.SpecialCardState
    acquiredDate?: Date | string
    openedAt?: Date | string | null
    quiz?: DailyQuizCreateNestedOneWithoutAwardedCardsInput
    player: PlayerCreateNestedOneWithoutGoldenCardsInput
    teamPlayer?: TeamPlayerCreateNestedOneWithoutGoldenCardInput
  }

  export type GoldenCardUncheckedCreateWithoutUserInput = {
    id?: string
    quizId?: string | null
    playerId: string
    cardTier?: $Enums.CardTier
    status?: $Enums.GoldenCardStatus
    state?: $Enums.SpecialCardState
    acquiredDate?: Date | string
    openedAt?: Date | string | null
    teamPlayer?: TeamPlayerUncheckedCreateNestedOneWithoutGoldenCardInput
  }

  export type GoldenCardCreateOrConnectWithoutUserInput = {
    where: GoldenCardWhereUniqueInput
    create: XOR<GoldenCardCreateWithoutUserInput, GoldenCardUncheckedCreateWithoutUserInput>
  }

  export type GoldenCardCreateManyUserInputEnvelope = {
    data: GoldenCardCreateManyUserInput | GoldenCardCreateManyUserInput[]
    skipDuplicates?: boolean
  }

  export type TeamUpsertWithoutUserInput = {
    update: XOR<TeamUpdateWithoutUserInput, TeamUncheckedUpdateWithoutUserInput>
    create: XOR<TeamCreateWithoutUserInput, TeamUncheckedCreateWithoutUserInput>
    where?: TeamWhereInput
  }

  export type TeamUpdateToOneWithWhereWithoutUserInput = {
    where?: TeamWhereInput
    data: XOR<TeamUpdateWithoutUserInput, TeamUncheckedUpdateWithoutUserInput>
  }

  export type TeamUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    budget?: FloatFieldUpdateOperationsInput | number
    totalPoints?: IntFieldUpdateOperationsInput | number
    formation?: StringFieldUpdateOperationsInput | string
    status?: EnumTeamStatusFieldUpdateOperationsInput | $Enums.TeamStatus
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    players?: TeamPlayerUpdateManyWithoutTeamNestedInput
  }

  export type TeamUncheckedUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    budget?: FloatFieldUpdateOperationsInput | number
    totalPoints?: IntFieldUpdateOperationsInput | number
    formation?: StringFieldUpdateOperationsInput | string
    status?: EnumTeamStatusFieldUpdateOperationsInput | $Enums.TeamStatus
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    players?: TeamPlayerUncheckedUpdateManyWithoutTeamNestedInput
  }

  export type SessionUpsertWithWhereUniqueWithoutUserInput = {
    where: SessionWhereUniqueInput
    update: XOR<SessionUpdateWithoutUserInput, SessionUncheckedUpdateWithoutUserInput>
    create: XOR<SessionCreateWithoutUserInput, SessionUncheckedCreateWithoutUserInput>
  }

  export type SessionUpdateWithWhereUniqueWithoutUserInput = {
    where: SessionWhereUniqueInput
    data: XOR<SessionUpdateWithoutUserInput, SessionUncheckedUpdateWithoutUserInput>
  }

  export type SessionUpdateManyWithWhereWithoutUserInput = {
    where: SessionScalarWhereInput
    data: XOR<SessionUpdateManyMutationInput, SessionUncheckedUpdateManyWithoutUserInput>
  }

  export type SessionScalarWhereInput = {
    AND?: SessionScalarWhereInput | SessionScalarWhereInput[]
    OR?: SessionScalarWhereInput[]
    NOT?: SessionScalarWhereInput | SessionScalarWhereInput[]
    id?: StringFilter<"Session"> | string
    sessionToken?: StringFilter<"Session"> | string
    userId?: StringFilter<"Session"> | string
    expires?: DateTimeFilter<"Session"> | Date | string
  }

  export type PaymentUpsertWithWhereUniqueWithoutUserInput = {
    where: PaymentWhereUniqueInput
    update: XOR<PaymentUpdateWithoutUserInput, PaymentUncheckedUpdateWithoutUserInput>
    create: XOR<PaymentCreateWithoutUserInput, PaymentUncheckedCreateWithoutUserInput>
  }

  export type PaymentUpdateWithWhereUniqueWithoutUserInput = {
    where: PaymentWhereUniqueInput
    data: XOR<PaymentUpdateWithoutUserInput, PaymentUncheckedUpdateWithoutUserInput>
  }

  export type PaymentUpdateManyWithWhereWithoutUserInput = {
    where: PaymentScalarWhereInput
    data: XOR<PaymentUpdateManyMutationInput, PaymentUncheckedUpdateManyWithoutUserInput>
  }

  export type PaymentScalarWhereInput = {
    AND?: PaymentScalarWhereInput | PaymentScalarWhereInput[]
    OR?: PaymentScalarWhereInput[]
    NOT?: PaymentScalarWhereInput | PaymentScalarWhereInput[]
    id?: StringFilter<"Payment"> | string
    userId?: StringFilter<"Payment"> | string
    packageId?: StringFilter<"Payment"> | string
    amount?: IntFilter<"Payment"> | number
    authority?: StringNullableFilter<"Payment"> | string | null
    refId?: StringNullableFilter<"Payment"> | string | null
    status?: EnumPaymentStatusFilter<"Payment"> | $Enums.PaymentStatus
    createdAt?: DateTimeFilter<"Payment"> | Date | string
    updatedAt?: DateTimeFilter<"Payment"> | Date | string
  }

  export type QuizSubmissionUpsertWithWhereUniqueWithoutUserInput = {
    where: QuizSubmissionWhereUniqueInput
    update: XOR<QuizSubmissionUpdateWithoutUserInput, QuizSubmissionUncheckedUpdateWithoutUserInput>
    create: XOR<QuizSubmissionCreateWithoutUserInput, QuizSubmissionUncheckedCreateWithoutUserInput>
  }

  export type QuizSubmissionUpdateWithWhereUniqueWithoutUserInput = {
    where: QuizSubmissionWhereUniqueInput
    data: XOR<QuizSubmissionUpdateWithoutUserInput, QuizSubmissionUncheckedUpdateWithoutUserInput>
  }

  export type QuizSubmissionUpdateManyWithWhereWithoutUserInput = {
    where: QuizSubmissionScalarWhereInput
    data: XOR<QuizSubmissionUpdateManyMutationInput, QuizSubmissionUncheckedUpdateManyWithoutUserInput>
  }

  export type QuizSubmissionScalarWhereInput = {
    AND?: QuizSubmissionScalarWhereInput | QuizSubmissionScalarWhereInput[]
    OR?: QuizSubmissionScalarWhereInput[]
    NOT?: QuizSubmissionScalarWhereInput | QuizSubmissionScalarWhereInput[]
    id?: StringFilter<"QuizSubmission"> | string
    userId?: StringFilter<"QuizSubmission"> | string
    quizId?: StringFilter<"QuizSubmission"> | string
    answers?: IntNullableListFilter<"QuizSubmission">
    correctAnswers?: IntFilter<"QuizSubmission"> | number
    score?: IntFilter<"QuizSubmission"> | number
    submittedAt?: DateTimeFilter<"QuizSubmission"> | Date | string
  }

  export type GoldenCardUpsertWithWhereUniqueWithoutUserInput = {
    where: GoldenCardWhereUniqueInput
    update: XOR<GoldenCardUpdateWithoutUserInput, GoldenCardUncheckedUpdateWithoutUserInput>
    create: XOR<GoldenCardCreateWithoutUserInput, GoldenCardUncheckedCreateWithoutUserInput>
  }

  export type GoldenCardUpdateWithWhereUniqueWithoutUserInput = {
    where: GoldenCardWhereUniqueInput
    data: XOR<GoldenCardUpdateWithoutUserInput, GoldenCardUncheckedUpdateWithoutUserInput>
  }

  export type GoldenCardUpdateManyWithWhereWithoutUserInput = {
    where: GoldenCardScalarWhereInput
    data: XOR<GoldenCardUpdateManyMutationInput, GoldenCardUncheckedUpdateManyWithoutUserInput>
  }

  export type QuizQuestionCreateWithoutQuizInput = {
    id?: string
    questionText: string
    options?: QuizQuestionCreateoptionsInput | string[]
    correctAnswer: number
    order?: number
  }

  export type QuizQuestionUncheckedCreateWithoutQuizInput = {
    id?: string
    questionText: string
    options?: QuizQuestionCreateoptionsInput | string[]
    correctAnswer: number
    order?: number
  }

  export type QuizQuestionCreateOrConnectWithoutQuizInput = {
    where: QuizQuestionWhereUniqueInput
    create: XOR<QuizQuestionCreateWithoutQuizInput, QuizQuestionUncheckedCreateWithoutQuizInput>
  }

  export type QuizQuestionCreateManyQuizInputEnvelope = {
    data: QuizQuestionCreateManyQuizInput | QuizQuestionCreateManyQuizInput[]
    skipDuplicates?: boolean
  }

  export type QuizSubmissionCreateWithoutQuizInput = {
    id?: string
    answers?: QuizSubmissionCreateanswersInput | number[]
    correctAnswers?: number
    score?: number
    submittedAt?: Date | string
    user: UserCreateNestedOneWithoutQuizSubmissionsInput
  }

  export type QuizSubmissionUncheckedCreateWithoutQuizInput = {
    id?: string
    userId: string
    answers?: QuizSubmissionCreateanswersInput | number[]
    correctAnswers?: number
    score?: number
    submittedAt?: Date | string
  }

  export type QuizSubmissionCreateOrConnectWithoutQuizInput = {
    where: QuizSubmissionWhereUniqueInput
    create: XOR<QuizSubmissionCreateWithoutQuizInput, QuizSubmissionUncheckedCreateWithoutQuizInput>
  }

  export type QuizSubmissionCreateManyQuizInputEnvelope = {
    data: QuizSubmissionCreateManyQuizInput | QuizSubmissionCreateManyQuizInput[]
    skipDuplicates?: boolean
  }

  export type GoldenCardCreateWithoutQuizInput = {
    id?: string
    cardTier?: $Enums.CardTier
    status?: $Enums.GoldenCardStatus
    state?: $Enums.SpecialCardState
    acquiredDate?: Date | string
    openedAt?: Date | string | null
    user: UserCreateNestedOneWithoutGoldenCardsInput
    player: PlayerCreateNestedOneWithoutGoldenCardsInput
    teamPlayer?: TeamPlayerCreateNestedOneWithoutGoldenCardInput
  }

  export type GoldenCardUncheckedCreateWithoutQuizInput = {
    id?: string
    userId: string
    playerId: string
    cardTier?: $Enums.CardTier
    status?: $Enums.GoldenCardStatus
    state?: $Enums.SpecialCardState
    acquiredDate?: Date | string
    openedAt?: Date | string | null
    teamPlayer?: TeamPlayerUncheckedCreateNestedOneWithoutGoldenCardInput
  }

  export type GoldenCardCreateOrConnectWithoutQuizInput = {
    where: GoldenCardWhereUniqueInput
    create: XOR<GoldenCardCreateWithoutQuizInput, GoldenCardUncheckedCreateWithoutQuizInput>
  }

  export type GoldenCardCreateManyQuizInputEnvelope = {
    data: GoldenCardCreateManyQuizInput | GoldenCardCreateManyQuizInput[]
    skipDuplicates?: boolean
  }

  export type QuizQuestionUpsertWithWhereUniqueWithoutQuizInput = {
    where: QuizQuestionWhereUniqueInput
    update: XOR<QuizQuestionUpdateWithoutQuizInput, QuizQuestionUncheckedUpdateWithoutQuizInput>
    create: XOR<QuizQuestionCreateWithoutQuizInput, QuizQuestionUncheckedCreateWithoutQuizInput>
  }

  export type QuizQuestionUpdateWithWhereUniqueWithoutQuizInput = {
    where: QuizQuestionWhereUniqueInput
    data: XOR<QuizQuestionUpdateWithoutQuizInput, QuizQuestionUncheckedUpdateWithoutQuizInput>
  }

  export type QuizQuestionUpdateManyWithWhereWithoutQuizInput = {
    where: QuizQuestionScalarWhereInput
    data: XOR<QuizQuestionUpdateManyMutationInput, QuizQuestionUncheckedUpdateManyWithoutQuizInput>
  }

  export type QuizQuestionScalarWhereInput = {
    AND?: QuizQuestionScalarWhereInput | QuizQuestionScalarWhereInput[]
    OR?: QuizQuestionScalarWhereInput[]
    NOT?: QuizQuestionScalarWhereInput | QuizQuestionScalarWhereInput[]
    id?: StringFilter<"QuizQuestion"> | string
    quizId?: StringFilter<"QuizQuestion"> | string
    questionText?: StringFilter<"QuizQuestion"> | string
    options?: StringNullableListFilter<"QuizQuestion">
    correctAnswer?: IntFilter<"QuizQuestion"> | number
    order?: IntFilter<"QuizQuestion"> | number
  }

  export type QuizSubmissionUpsertWithWhereUniqueWithoutQuizInput = {
    where: QuizSubmissionWhereUniqueInput
    update: XOR<QuizSubmissionUpdateWithoutQuizInput, QuizSubmissionUncheckedUpdateWithoutQuizInput>
    create: XOR<QuizSubmissionCreateWithoutQuizInput, QuizSubmissionUncheckedCreateWithoutQuizInput>
  }

  export type QuizSubmissionUpdateWithWhereUniqueWithoutQuizInput = {
    where: QuizSubmissionWhereUniqueInput
    data: XOR<QuizSubmissionUpdateWithoutQuizInput, QuizSubmissionUncheckedUpdateWithoutQuizInput>
  }

  export type QuizSubmissionUpdateManyWithWhereWithoutQuizInput = {
    where: QuizSubmissionScalarWhereInput
    data: XOR<QuizSubmissionUpdateManyMutationInput, QuizSubmissionUncheckedUpdateManyWithoutQuizInput>
  }

  export type GoldenCardUpsertWithWhereUniqueWithoutQuizInput = {
    where: GoldenCardWhereUniqueInput
    update: XOR<GoldenCardUpdateWithoutQuizInput, GoldenCardUncheckedUpdateWithoutQuizInput>
    create: XOR<GoldenCardCreateWithoutQuizInput, GoldenCardUncheckedCreateWithoutQuizInput>
  }

  export type GoldenCardUpdateWithWhereUniqueWithoutQuizInput = {
    where: GoldenCardWhereUniqueInput
    data: XOR<GoldenCardUpdateWithoutQuizInput, GoldenCardUncheckedUpdateWithoutQuizInput>
  }

  export type GoldenCardUpdateManyWithWhereWithoutQuizInput = {
    where: GoldenCardScalarWhereInput
    data: XOR<GoldenCardUpdateManyMutationInput, GoldenCardUncheckedUpdateManyWithoutQuizInput>
  }

  export type DailyQuizCreateWithoutQuestionsInput = {
    id?: string
    date: Date | string
    windowStart: Date | string
    windowEnd: Date | string
    goldWinnersCount?: number
    silverWinnersCount?: number
    bronzeWinnersCount?: number
    goldMinCorrect?: number | null
    silverMinCorrect?: number | null
    bronzeMinCorrect?: number | null
    isProcessed?: boolean
    createdAt?: Date | string
    submissions?: QuizSubmissionCreateNestedManyWithoutQuizInput
    awardedCards?: GoldenCardCreateNestedManyWithoutQuizInput
  }

  export type DailyQuizUncheckedCreateWithoutQuestionsInput = {
    id?: string
    date: Date | string
    windowStart: Date | string
    windowEnd: Date | string
    goldWinnersCount?: number
    silverWinnersCount?: number
    bronzeWinnersCount?: number
    goldMinCorrect?: number | null
    silverMinCorrect?: number | null
    bronzeMinCorrect?: number | null
    isProcessed?: boolean
    createdAt?: Date | string
    submissions?: QuizSubmissionUncheckedCreateNestedManyWithoutQuizInput
    awardedCards?: GoldenCardUncheckedCreateNestedManyWithoutQuizInput
  }

  export type DailyQuizCreateOrConnectWithoutQuestionsInput = {
    where: DailyQuizWhereUniqueInput
    create: XOR<DailyQuizCreateWithoutQuestionsInput, DailyQuizUncheckedCreateWithoutQuestionsInput>
  }

  export type DailyQuizUpsertWithoutQuestionsInput = {
    update: XOR<DailyQuizUpdateWithoutQuestionsInput, DailyQuizUncheckedUpdateWithoutQuestionsInput>
    create: XOR<DailyQuizCreateWithoutQuestionsInput, DailyQuizUncheckedCreateWithoutQuestionsInput>
    where?: DailyQuizWhereInput
  }

  export type DailyQuizUpdateToOneWithWhereWithoutQuestionsInput = {
    where?: DailyQuizWhereInput
    data: XOR<DailyQuizUpdateWithoutQuestionsInput, DailyQuizUncheckedUpdateWithoutQuestionsInput>
  }

  export type DailyQuizUpdateWithoutQuestionsInput = {
    id?: StringFieldUpdateOperationsInput | string
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    windowStart?: DateTimeFieldUpdateOperationsInput | Date | string
    windowEnd?: DateTimeFieldUpdateOperationsInput | Date | string
    goldWinnersCount?: IntFieldUpdateOperationsInput | number
    silverWinnersCount?: IntFieldUpdateOperationsInput | number
    bronzeWinnersCount?: IntFieldUpdateOperationsInput | number
    goldMinCorrect?: NullableIntFieldUpdateOperationsInput | number | null
    silverMinCorrect?: NullableIntFieldUpdateOperationsInput | number | null
    bronzeMinCorrect?: NullableIntFieldUpdateOperationsInput | number | null
    isProcessed?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    submissions?: QuizSubmissionUpdateManyWithoutQuizNestedInput
    awardedCards?: GoldenCardUpdateManyWithoutQuizNestedInput
  }

  export type DailyQuizUncheckedUpdateWithoutQuestionsInput = {
    id?: StringFieldUpdateOperationsInput | string
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    windowStart?: DateTimeFieldUpdateOperationsInput | Date | string
    windowEnd?: DateTimeFieldUpdateOperationsInput | Date | string
    goldWinnersCount?: IntFieldUpdateOperationsInput | number
    silverWinnersCount?: IntFieldUpdateOperationsInput | number
    bronzeWinnersCount?: IntFieldUpdateOperationsInput | number
    goldMinCorrect?: NullableIntFieldUpdateOperationsInput | number | null
    silverMinCorrect?: NullableIntFieldUpdateOperationsInput | number | null
    bronzeMinCorrect?: NullableIntFieldUpdateOperationsInput | number | null
    isProcessed?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    submissions?: QuizSubmissionUncheckedUpdateManyWithoutQuizNestedInput
    awardedCards?: GoldenCardUncheckedUpdateManyWithoutQuizNestedInput
  }

  export type UserCreateWithoutQuizSubmissionsInput = {
    id?: string
    name?: string | null
    email: string
    phone?: string | null
    password: string
    role?: $Enums.Role
    createdAt?: Date | string
    team?: TeamCreateNestedOneWithoutUserInput
    sessions?: SessionCreateNestedManyWithoutUserInput
    payments?: PaymentCreateNestedManyWithoutUserInput
    goldenCards?: GoldenCardCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutQuizSubmissionsInput = {
    id?: string
    name?: string | null
    email: string
    phone?: string | null
    password: string
    role?: $Enums.Role
    createdAt?: Date | string
    team?: TeamUncheckedCreateNestedOneWithoutUserInput
    sessions?: SessionUncheckedCreateNestedManyWithoutUserInput
    payments?: PaymentUncheckedCreateNestedManyWithoutUserInput
    goldenCards?: GoldenCardUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutQuizSubmissionsInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutQuizSubmissionsInput, UserUncheckedCreateWithoutQuizSubmissionsInput>
  }

  export type DailyQuizCreateWithoutSubmissionsInput = {
    id?: string
    date: Date | string
    windowStart: Date | string
    windowEnd: Date | string
    goldWinnersCount?: number
    silverWinnersCount?: number
    bronzeWinnersCount?: number
    goldMinCorrect?: number | null
    silverMinCorrect?: number | null
    bronzeMinCorrect?: number | null
    isProcessed?: boolean
    createdAt?: Date | string
    questions?: QuizQuestionCreateNestedManyWithoutQuizInput
    awardedCards?: GoldenCardCreateNestedManyWithoutQuizInput
  }

  export type DailyQuizUncheckedCreateWithoutSubmissionsInput = {
    id?: string
    date: Date | string
    windowStart: Date | string
    windowEnd: Date | string
    goldWinnersCount?: number
    silverWinnersCount?: number
    bronzeWinnersCount?: number
    goldMinCorrect?: number | null
    silverMinCorrect?: number | null
    bronzeMinCorrect?: number | null
    isProcessed?: boolean
    createdAt?: Date | string
    questions?: QuizQuestionUncheckedCreateNestedManyWithoutQuizInput
    awardedCards?: GoldenCardUncheckedCreateNestedManyWithoutQuizInput
  }

  export type DailyQuizCreateOrConnectWithoutSubmissionsInput = {
    where: DailyQuizWhereUniqueInput
    create: XOR<DailyQuizCreateWithoutSubmissionsInput, DailyQuizUncheckedCreateWithoutSubmissionsInput>
  }

  export type UserUpsertWithoutQuizSubmissionsInput = {
    update: XOR<UserUpdateWithoutQuizSubmissionsInput, UserUncheckedUpdateWithoutQuizSubmissionsInput>
    create: XOR<UserCreateWithoutQuizSubmissionsInput, UserUncheckedCreateWithoutQuizSubmissionsInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutQuizSubmissionsInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutQuizSubmissionsInput, UserUncheckedUpdateWithoutQuizSubmissionsInput>
  }

  export type UserUpdateWithoutQuizSubmissionsInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: NullableStringFieldUpdateOperationsInput | string | null
    email?: StringFieldUpdateOperationsInput | string
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    password?: StringFieldUpdateOperationsInput | string
    role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    team?: TeamUpdateOneWithoutUserNestedInput
    sessions?: SessionUpdateManyWithoutUserNestedInput
    payments?: PaymentUpdateManyWithoutUserNestedInput
    goldenCards?: GoldenCardUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutQuizSubmissionsInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: NullableStringFieldUpdateOperationsInput | string | null
    email?: StringFieldUpdateOperationsInput | string
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    password?: StringFieldUpdateOperationsInput | string
    role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    team?: TeamUncheckedUpdateOneWithoutUserNestedInput
    sessions?: SessionUncheckedUpdateManyWithoutUserNestedInput
    payments?: PaymentUncheckedUpdateManyWithoutUserNestedInput
    goldenCards?: GoldenCardUncheckedUpdateManyWithoutUserNestedInput
  }

  export type DailyQuizUpsertWithoutSubmissionsInput = {
    update: XOR<DailyQuizUpdateWithoutSubmissionsInput, DailyQuizUncheckedUpdateWithoutSubmissionsInput>
    create: XOR<DailyQuizCreateWithoutSubmissionsInput, DailyQuizUncheckedCreateWithoutSubmissionsInput>
    where?: DailyQuizWhereInput
  }

  export type DailyQuizUpdateToOneWithWhereWithoutSubmissionsInput = {
    where?: DailyQuizWhereInput
    data: XOR<DailyQuizUpdateWithoutSubmissionsInput, DailyQuizUncheckedUpdateWithoutSubmissionsInput>
  }

  export type DailyQuizUpdateWithoutSubmissionsInput = {
    id?: StringFieldUpdateOperationsInput | string
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    windowStart?: DateTimeFieldUpdateOperationsInput | Date | string
    windowEnd?: DateTimeFieldUpdateOperationsInput | Date | string
    goldWinnersCount?: IntFieldUpdateOperationsInput | number
    silverWinnersCount?: IntFieldUpdateOperationsInput | number
    bronzeWinnersCount?: IntFieldUpdateOperationsInput | number
    goldMinCorrect?: NullableIntFieldUpdateOperationsInput | number | null
    silverMinCorrect?: NullableIntFieldUpdateOperationsInput | number | null
    bronzeMinCorrect?: NullableIntFieldUpdateOperationsInput | number | null
    isProcessed?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    questions?: QuizQuestionUpdateManyWithoutQuizNestedInput
    awardedCards?: GoldenCardUpdateManyWithoutQuizNestedInput
  }

  export type DailyQuizUncheckedUpdateWithoutSubmissionsInput = {
    id?: StringFieldUpdateOperationsInput | string
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    windowStart?: DateTimeFieldUpdateOperationsInput | Date | string
    windowEnd?: DateTimeFieldUpdateOperationsInput | Date | string
    goldWinnersCount?: IntFieldUpdateOperationsInput | number
    silverWinnersCount?: IntFieldUpdateOperationsInput | number
    bronzeWinnersCount?: IntFieldUpdateOperationsInput | number
    goldMinCorrect?: NullableIntFieldUpdateOperationsInput | number | null
    silverMinCorrect?: NullableIntFieldUpdateOperationsInput | number | null
    bronzeMinCorrect?: NullableIntFieldUpdateOperationsInput | number | null
    isProcessed?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    questions?: QuizQuestionUncheckedUpdateManyWithoutQuizNestedInput
    awardedCards?: GoldenCardUncheckedUpdateManyWithoutQuizNestedInput
  }

  export type UserCreateWithoutGoldenCardsInput = {
    id?: string
    name?: string | null
    email: string
    phone?: string | null
    password: string
    role?: $Enums.Role
    createdAt?: Date | string
    team?: TeamCreateNestedOneWithoutUserInput
    sessions?: SessionCreateNestedManyWithoutUserInput
    payments?: PaymentCreateNestedManyWithoutUserInput
    quizSubmissions?: QuizSubmissionCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutGoldenCardsInput = {
    id?: string
    name?: string | null
    email: string
    phone?: string | null
    password: string
    role?: $Enums.Role
    createdAt?: Date | string
    team?: TeamUncheckedCreateNestedOneWithoutUserInput
    sessions?: SessionUncheckedCreateNestedManyWithoutUserInput
    payments?: PaymentUncheckedCreateNestedManyWithoutUserInput
    quizSubmissions?: QuizSubmissionUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutGoldenCardsInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutGoldenCardsInput, UserUncheckedCreateWithoutGoldenCardsInput>
  }

  export type DailyQuizCreateWithoutAwardedCardsInput = {
    id?: string
    date: Date | string
    windowStart: Date | string
    windowEnd: Date | string
    goldWinnersCount?: number
    silverWinnersCount?: number
    bronzeWinnersCount?: number
    goldMinCorrect?: number | null
    silverMinCorrect?: number | null
    bronzeMinCorrect?: number | null
    isProcessed?: boolean
    createdAt?: Date | string
    questions?: QuizQuestionCreateNestedManyWithoutQuizInput
    submissions?: QuizSubmissionCreateNestedManyWithoutQuizInput
  }

  export type DailyQuizUncheckedCreateWithoutAwardedCardsInput = {
    id?: string
    date: Date | string
    windowStart: Date | string
    windowEnd: Date | string
    goldWinnersCount?: number
    silverWinnersCount?: number
    bronzeWinnersCount?: number
    goldMinCorrect?: number | null
    silverMinCorrect?: number | null
    bronzeMinCorrect?: number | null
    isProcessed?: boolean
    createdAt?: Date | string
    questions?: QuizQuestionUncheckedCreateNestedManyWithoutQuizInput
    submissions?: QuizSubmissionUncheckedCreateNestedManyWithoutQuizInput
  }

  export type DailyQuizCreateOrConnectWithoutAwardedCardsInput = {
    where: DailyQuizWhereUniqueInput
    create: XOR<DailyQuizCreateWithoutAwardedCardsInput, DailyQuizUncheckedCreateWithoutAwardedCardsInput>
  }

  export type PlayerCreateWithoutGoldenCardsInput = {
    id?: string
    name: string
    image?: string | null
    position: $Enums.Position
    price?: number
    totalPoints?: number
    isActive?: boolean
    isGoldenCardEligible?: boolean
    cardTier?: $Enums.CardTier
    createdAt?: Date | string
    updatedAt?: Date | string
    country: CountryCreateNestedOneWithoutPlayersInput
    matchStats?: PlayerMatchStatCreateNestedManyWithoutPlayerInput
    teamPlayers?: TeamPlayerCreateNestedManyWithoutPlayerInput
    events?: MatchEventCreateNestedManyWithoutPlayerInput
  }

  export type PlayerUncheckedCreateWithoutGoldenCardsInput = {
    id?: string
    name: string
    image?: string | null
    position: $Enums.Position
    countryId: string
    price?: number
    totalPoints?: number
    isActive?: boolean
    isGoldenCardEligible?: boolean
    cardTier?: $Enums.CardTier
    createdAt?: Date | string
    updatedAt?: Date | string
    matchStats?: PlayerMatchStatUncheckedCreateNestedManyWithoutPlayerInput
    teamPlayers?: TeamPlayerUncheckedCreateNestedManyWithoutPlayerInput
    events?: MatchEventUncheckedCreateNestedManyWithoutPlayerInput
  }

  export type PlayerCreateOrConnectWithoutGoldenCardsInput = {
    where: PlayerWhereUniqueInput
    create: XOR<PlayerCreateWithoutGoldenCardsInput, PlayerUncheckedCreateWithoutGoldenCardsInput>
  }

  export type TeamPlayerCreateWithoutGoldenCardInput = {
    isCaptain?: boolean
    isViceCaptain?: boolean
    isBench?: boolean
    positionIndex?: number
    team: TeamCreateNestedOneWithoutPlayersInput
    player: PlayerCreateNestedOneWithoutTeamPlayersInput
  }

  export type TeamPlayerUncheckedCreateWithoutGoldenCardInput = {
    teamId: string
    playerId: string
    isCaptain?: boolean
    isViceCaptain?: boolean
    isBench?: boolean
    positionIndex?: number
  }

  export type TeamPlayerCreateOrConnectWithoutGoldenCardInput = {
    where: TeamPlayerWhereUniqueInput
    create: XOR<TeamPlayerCreateWithoutGoldenCardInput, TeamPlayerUncheckedCreateWithoutGoldenCardInput>
  }

  export type UserUpsertWithoutGoldenCardsInput = {
    update: XOR<UserUpdateWithoutGoldenCardsInput, UserUncheckedUpdateWithoutGoldenCardsInput>
    create: XOR<UserCreateWithoutGoldenCardsInput, UserUncheckedCreateWithoutGoldenCardsInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutGoldenCardsInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutGoldenCardsInput, UserUncheckedUpdateWithoutGoldenCardsInput>
  }

  export type UserUpdateWithoutGoldenCardsInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: NullableStringFieldUpdateOperationsInput | string | null
    email?: StringFieldUpdateOperationsInput | string
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    password?: StringFieldUpdateOperationsInput | string
    role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    team?: TeamUpdateOneWithoutUserNestedInput
    sessions?: SessionUpdateManyWithoutUserNestedInput
    payments?: PaymentUpdateManyWithoutUserNestedInput
    quizSubmissions?: QuizSubmissionUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutGoldenCardsInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: NullableStringFieldUpdateOperationsInput | string | null
    email?: StringFieldUpdateOperationsInput | string
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    password?: StringFieldUpdateOperationsInput | string
    role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    team?: TeamUncheckedUpdateOneWithoutUserNestedInput
    sessions?: SessionUncheckedUpdateManyWithoutUserNestedInput
    payments?: PaymentUncheckedUpdateManyWithoutUserNestedInput
    quizSubmissions?: QuizSubmissionUncheckedUpdateManyWithoutUserNestedInput
  }

  export type DailyQuizUpsertWithoutAwardedCardsInput = {
    update: XOR<DailyQuizUpdateWithoutAwardedCardsInput, DailyQuizUncheckedUpdateWithoutAwardedCardsInput>
    create: XOR<DailyQuizCreateWithoutAwardedCardsInput, DailyQuizUncheckedCreateWithoutAwardedCardsInput>
    where?: DailyQuizWhereInput
  }

  export type DailyQuizUpdateToOneWithWhereWithoutAwardedCardsInput = {
    where?: DailyQuizWhereInput
    data: XOR<DailyQuizUpdateWithoutAwardedCardsInput, DailyQuizUncheckedUpdateWithoutAwardedCardsInput>
  }

  export type DailyQuizUpdateWithoutAwardedCardsInput = {
    id?: StringFieldUpdateOperationsInput | string
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    windowStart?: DateTimeFieldUpdateOperationsInput | Date | string
    windowEnd?: DateTimeFieldUpdateOperationsInput | Date | string
    goldWinnersCount?: IntFieldUpdateOperationsInput | number
    silverWinnersCount?: IntFieldUpdateOperationsInput | number
    bronzeWinnersCount?: IntFieldUpdateOperationsInput | number
    goldMinCorrect?: NullableIntFieldUpdateOperationsInput | number | null
    silverMinCorrect?: NullableIntFieldUpdateOperationsInput | number | null
    bronzeMinCorrect?: NullableIntFieldUpdateOperationsInput | number | null
    isProcessed?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    questions?: QuizQuestionUpdateManyWithoutQuizNestedInput
    submissions?: QuizSubmissionUpdateManyWithoutQuizNestedInput
  }

  export type DailyQuizUncheckedUpdateWithoutAwardedCardsInput = {
    id?: StringFieldUpdateOperationsInput | string
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    windowStart?: DateTimeFieldUpdateOperationsInput | Date | string
    windowEnd?: DateTimeFieldUpdateOperationsInput | Date | string
    goldWinnersCount?: IntFieldUpdateOperationsInput | number
    silverWinnersCount?: IntFieldUpdateOperationsInput | number
    bronzeWinnersCount?: IntFieldUpdateOperationsInput | number
    goldMinCorrect?: NullableIntFieldUpdateOperationsInput | number | null
    silverMinCorrect?: NullableIntFieldUpdateOperationsInput | number | null
    bronzeMinCorrect?: NullableIntFieldUpdateOperationsInput | number | null
    isProcessed?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    questions?: QuizQuestionUncheckedUpdateManyWithoutQuizNestedInput
    submissions?: QuizSubmissionUncheckedUpdateManyWithoutQuizNestedInput
  }

  export type PlayerUpsertWithoutGoldenCardsInput = {
    update: XOR<PlayerUpdateWithoutGoldenCardsInput, PlayerUncheckedUpdateWithoutGoldenCardsInput>
    create: XOR<PlayerCreateWithoutGoldenCardsInput, PlayerUncheckedCreateWithoutGoldenCardsInput>
    where?: PlayerWhereInput
  }

  export type PlayerUpdateToOneWithWhereWithoutGoldenCardsInput = {
    where?: PlayerWhereInput
    data: XOR<PlayerUpdateWithoutGoldenCardsInput, PlayerUncheckedUpdateWithoutGoldenCardsInput>
  }

  export type PlayerUpdateWithoutGoldenCardsInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    image?: NullableStringFieldUpdateOperationsInput | string | null
    position?: EnumPositionFieldUpdateOperationsInput | $Enums.Position
    price?: FloatFieldUpdateOperationsInput | number
    totalPoints?: IntFieldUpdateOperationsInput | number
    isActive?: BoolFieldUpdateOperationsInput | boolean
    isGoldenCardEligible?: BoolFieldUpdateOperationsInput | boolean
    cardTier?: EnumCardTierFieldUpdateOperationsInput | $Enums.CardTier
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    country?: CountryUpdateOneRequiredWithoutPlayersNestedInput
    matchStats?: PlayerMatchStatUpdateManyWithoutPlayerNestedInput
    teamPlayers?: TeamPlayerUpdateManyWithoutPlayerNestedInput
    events?: MatchEventUpdateManyWithoutPlayerNestedInput
  }

  export type PlayerUncheckedUpdateWithoutGoldenCardsInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    image?: NullableStringFieldUpdateOperationsInput | string | null
    position?: EnumPositionFieldUpdateOperationsInput | $Enums.Position
    countryId?: StringFieldUpdateOperationsInput | string
    price?: FloatFieldUpdateOperationsInput | number
    totalPoints?: IntFieldUpdateOperationsInput | number
    isActive?: BoolFieldUpdateOperationsInput | boolean
    isGoldenCardEligible?: BoolFieldUpdateOperationsInput | boolean
    cardTier?: EnumCardTierFieldUpdateOperationsInput | $Enums.CardTier
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    matchStats?: PlayerMatchStatUncheckedUpdateManyWithoutPlayerNestedInput
    teamPlayers?: TeamPlayerUncheckedUpdateManyWithoutPlayerNestedInput
    events?: MatchEventUncheckedUpdateManyWithoutPlayerNestedInput
  }

  export type TeamPlayerUpsertWithoutGoldenCardInput = {
    update: XOR<TeamPlayerUpdateWithoutGoldenCardInput, TeamPlayerUncheckedUpdateWithoutGoldenCardInput>
    create: XOR<TeamPlayerCreateWithoutGoldenCardInput, TeamPlayerUncheckedCreateWithoutGoldenCardInput>
    where?: TeamPlayerWhereInput
  }

  export type TeamPlayerUpdateToOneWithWhereWithoutGoldenCardInput = {
    where?: TeamPlayerWhereInput
    data: XOR<TeamPlayerUpdateWithoutGoldenCardInput, TeamPlayerUncheckedUpdateWithoutGoldenCardInput>
  }

  export type TeamPlayerUpdateWithoutGoldenCardInput = {
    isCaptain?: BoolFieldUpdateOperationsInput | boolean
    isViceCaptain?: BoolFieldUpdateOperationsInput | boolean
    isBench?: BoolFieldUpdateOperationsInput | boolean
    positionIndex?: IntFieldUpdateOperationsInput | number
    team?: TeamUpdateOneRequiredWithoutPlayersNestedInput
    player?: PlayerUpdateOneRequiredWithoutTeamPlayersNestedInput
  }

  export type TeamPlayerUncheckedUpdateWithoutGoldenCardInput = {
    teamId?: StringFieldUpdateOperationsInput | string
    playerId?: StringFieldUpdateOperationsInput | string
    isCaptain?: BoolFieldUpdateOperationsInput | boolean
    isViceCaptain?: BoolFieldUpdateOperationsInput | boolean
    isBench?: BoolFieldUpdateOperationsInput | boolean
    positionIndex?: IntFieldUpdateOperationsInput | number
  }

  export type UserCreateWithoutSessionsInput = {
    id?: string
    name?: string | null
    email: string
    phone?: string | null
    password: string
    role?: $Enums.Role
    createdAt?: Date | string
    team?: TeamCreateNestedOneWithoutUserInput
    payments?: PaymentCreateNestedManyWithoutUserInput
    quizSubmissions?: QuizSubmissionCreateNestedManyWithoutUserInput
    goldenCards?: GoldenCardCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutSessionsInput = {
    id?: string
    name?: string | null
    email: string
    phone?: string | null
    password: string
    role?: $Enums.Role
    createdAt?: Date | string
    team?: TeamUncheckedCreateNestedOneWithoutUserInput
    payments?: PaymentUncheckedCreateNestedManyWithoutUserInput
    quizSubmissions?: QuizSubmissionUncheckedCreateNestedManyWithoutUserInput
    goldenCards?: GoldenCardUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutSessionsInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutSessionsInput, UserUncheckedCreateWithoutSessionsInput>
  }

  export type UserUpsertWithoutSessionsInput = {
    update: XOR<UserUpdateWithoutSessionsInput, UserUncheckedUpdateWithoutSessionsInput>
    create: XOR<UserCreateWithoutSessionsInput, UserUncheckedCreateWithoutSessionsInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutSessionsInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutSessionsInput, UserUncheckedUpdateWithoutSessionsInput>
  }

  export type UserUpdateWithoutSessionsInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: NullableStringFieldUpdateOperationsInput | string | null
    email?: StringFieldUpdateOperationsInput | string
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    password?: StringFieldUpdateOperationsInput | string
    role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    team?: TeamUpdateOneWithoutUserNestedInput
    payments?: PaymentUpdateManyWithoutUserNestedInput
    quizSubmissions?: QuizSubmissionUpdateManyWithoutUserNestedInput
    goldenCards?: GoldenCardUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutSessionsInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: NullableStringFieldUpdateOperationsInput | string | null
    email?: StringFieldUpdateOperationsInput | string
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    password?: StringFieldUpdateOperationsInput | string
    role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    team?: TeamUncheckedUpdateOneWithoutUserNestedInput
    payments?: PaymentUncheckedUpdateManyWithoutUserNestedInput
    quizSubmissions?: QuizSubmissionUncheckedUpdateManyWithoutUserNestedInput
    goldenCards?: GoldenCardUncheckedUpdateManyWithoutUserNestedInput
  }

  export type UserCreateWithoutTeamInput = {
    id?: string
    name?: string | null
    email: string
    phone?: string | null
    password: string
    role?: $Enums.Role
    createdAt?: Date | string
    sessions?: SessionCreateNestedManyWithoutUserInput
    payments?: PaymentCreateNestedManyWithoutUserInput
    quizSubmissions?: QuizSubmissionCreateNestedManyWithoutUserInput
    goldenCards?: GoldenCardCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutTeamInput = {
    id?: string
    name?: string | null
    email: string
    phone?: string | null
    password: string
    role?: $Enums.Role
    createdAt?: Date | string
    sessions?: SessionUncheckedCreateNestedManyWithoutUserInput
    payments?: PaymentUncheckedCreateNestedManyWithoutUserInput
    quizSubmissions?: QuizSubmissionUncheckedCreateNestedManyWithoutUserInput
    goldenCards?: GoldenCardUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutTeamInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutTeamInput, UserUncheckedCreateWithoutTeamInput>
  }

  export type TeamPlayerCreateWithoutTeamInput = {
    isCaptain?: boolean
    isViceCaptain?: boolean
    isBench?: boolean
    positionIndex?: number
    player: PlayerCreateNestedOneWithoutTeamPlayersInput
    goldenCard?: GoldenCardCreateNestedOneWithoutTeamPlayerInput
  }

  export type TeamPlayerUncheckedCreateWithoutTeamInput = {
    playerId: string
    goldenCardId?: string | null
    isCaptain?: boolean
    isViceCaptain?: boolean
    isBench?: boolean
    positionIndex?: number
  }

  export type TeamPlayerCreateOrConnectWithoutTeamInput = {
    where: TeamPlayerWhereUniqueInput
    create: XOR<TeamPlayerCreateWithoutTeamInput, TeamPlayerUncheckedCreateWithoutTeamInput>
  }

  export type TeamPlayerCreateManyTeamInputEnvelope = {
    data: TeamPlayerCreateManyTeamInput | TeamPlayerCreateManyTeamInput[]
    skipDuplicates?: boolean
  }

  export type UserUpsertWithoutTeamInput = {
    update: XOR<UserUpdateWithoutTeamInput, UserUncheckedUpdateWithoutTeamInput>
    create: XOR<UserCreateWithoutTeamInput, UserUncheckedCreateWithoutTeamInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutTeamInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutTeamInput, UserUncheckedUpdateWithoutTeamInput>
  }

  export type UserUpdateWithoutTeamInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: NullableStringFieldUpdateOperationsInput | string | null
    email?: StringFieldUpdateOperationsInput | string
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    password?: StringFieldUpdateOperationsInput | string
    role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    sessions?: SessionUpdateManyWithoutUserNestedInput
    payments?: PaymentUpdateManyWithoutUserNestedInput
    quizSubmissions?: QuizSubmissionUpdateManyWithoutUserNestedInput
    goldenCards?: GoldenCardUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutTeamInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: NullableStringFieldUpdateOperationsInput | string | null
    email?: StringFieldUpdateOperationsInput | string
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    password?: StringFieldUpdateOperationsInput | string
    role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    sessions?: SessionUncheckedUpdateManyWithoutUserNestedInput
    payments?: PaymentUncheckedUpdateManyWithoutUserNestedInput
    quizSubmissions?: QuizSubmissionUncheckedUpdateManyWithoutUserNestedInput
    goldenCards?: GoldenCardUncheckedUpdateManyWithoutUserNestedInput
  }

  export type TeamPlayerUpsertWithWhereUniqueWithoutTeamInput = {
    where: TeamPlayerWhereUniqueInput
    update: XOR<TeamPlayerUpdateWithoutTeamInput, TeamPlayerUncheckedUpdateWithoutTeamInput>
    create: XOR<TeamPlayerCreateWithoutTeamInput, TeamPlayerUncheckedCreateWithoutTeamInput>
  }

  export type TeamPlayerUpdateWithWhereUniqueWithoutTeamInput = {
    where: TeamPlayerWhereUniqueInput
    data: XOR<TeamPlayerUpdateWithoutTeamInput, TeamPlayerUncheckedUpdateWithoutTeamInput>
  }

  export type TeamPlayerUpdateManyWithWhereWithoutTeamInput = {
    where: TeamPlayerScalarWhereInput
    data: XOR<TeamPlayerUpdateManyMutationInput, TeamPlayerUncheckedUpdateManyWithoutTeamInput>
  }

  export type TeamCreateWithoutPlayersInput = {
    id?: string
    name: string
    budget?: number
    totalPoints?: number
    formation?: string
    status?: $Enums.TeamStatus
    createdAt?: Date | string
    user: UserCreateNestedOneWithoutTeamInput
  }

  export type TeamUncheckedCreateWithoutPlayersInput = {
    id?: string
    name: string
    userId: string
    budget?: number
    totalPoints?: number
    formation?: string
    status?: $Enums.TeamStatus
    createdAt?: Date | string
  }

  export type TeamCreateOrConnectWithoutPlayersInput = {
    where: TeamWhereUniqueInput
    create: XOR<TeamCreateWithoutPlayersInput, TeamUncheckedCreateWithoutPlayersInput>
  }

  export type PlayerCreateWithoutTeamPlayersInput = {
    id?: string
    name: string
    image?: string | null
    position: $Enums.Position
    price?: number
    totalPoints?: number
    isActive?: boolean
    isGoldenCardEligible?: boolean
    cardTier?: $Enums.CardTier
    createdAt?: Date | string
    updatedAt?: Date | string
    country: CountryCreateNestedOneWithoutPlayersInput
    matchStats?: PlayerMatchStatCreateNestedManyWithoutPlayerInput
    events?: MatchEventCreateNestedManyWithoutPlayerInput
    goldenCards?: GoldenCardCreateNestedManyWithoutPlayerInput
  }

  export type PlayerUncheckedCreateWithoutTeamPlayersInput = {
    id?: string
    name: string
    image?: string | null
    position: $Enums.Position
    countryId: string
    price?: number
    totalPoints?: number
    isActive?: boolean
    isGoldenCardEligible?: boolean
    cardTier?: $Enums.CardTier
    createdAt?: Date | string
    updatedAt?: Date | string
    matchStats?: PlayerMatchStatUncheckedCreateNestedManyWithoutPlayerInput
    events?: MatchEventUncheckedCreateNestedManyWithoutPlayerInput
    goldenCards?: GoldenCardUncheckedCreateNestedManyWithoutPlayerInput
  }

  export type PlayerCreateOrConnectWithoutTeamPlayersInput = {
    where: PlayerWhereUniqueInput
    create: XOR<PlayerCreateWithoutTeamPlayersInput, PlayerUncheckedCreateWithoutTeamPlayersInput>
  }

  export type GoldenCardCreateWithoutTeamPlayerInput = {
    id?: string
    cardTier?: $Enums.CardTier
    status?: $Enums.GoldenCardStatus
    state?: $Enums.SpecialCardState
    acquiredDate?: Date | string
    openedAt?: Date | string | null
    user: UserCreateNestedOneWithoutGoldenCardsInput
    quiz?: DailyQuizCreateNestedOneWithoutAwardedCardsInput
    player: PlayerCreateNestedOneWithoutGoldenCardsInput
  }

  export type GoldenCardUncheckedCreateWithoutTeamPlayerInput = {
    id?: string
    userId: string
    quizId?: string | null
    playerId: string
    cardTier?: $Enums.CardTier
    status?: $Enums.GoldenCardStatus
    state?: $Enums.SpecialCardState
    acquiredDate?: Date | string
    openedAt?: Date | string | null
  }

  export type GoldenCardCreateOrConnectWithoutTeamPlayerInput = {
    where: GoldenCardWhereUniqueInput
    create: XOR<GoldenCardCreateWithoutTeamPlayerInput, GoldenCardUncheckedCreateWithoutTeamPlayerInput>
  }

  export type TeamUpsertWithoutPlayersInput = {
    update: XOR<TeamUpdateWithoutPlayersInput, TeamUncheckedUpdateWithoutPlayersInput>
    create: XOR<TeamCreateWithoutPlayersInput, TeamUncheckedCreateWithoutPlayersInput>
    where?: TeamWhereInput
  }

  export type TeamUpdateToOneWithWhereWithoutPlayersInput = {
    where?: TeamWhereInput
    data: XOR<TeamUpdateWithoutPlayersInput, TeamUncheckedUpdateWithoutPlayersInput>
  }

  export type TeamUpdateWithoutPlayersInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    budget?: FloatFieldUpdateOperationsInput | number
    totalPoints?: IntFieldUpdateOperationsInput | number
    formation?: StringFieldUpdateOperationsInput | string
    status?: EnumTeamStatusFieldUpdateOperationsInput | $Enums.TeamStatus
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    user?: UserUpdateOneRequiredWithoutTeamNestedInput
  }

  export type TeamUncheckedUpdateWithoutPlayersInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    budget?: FloatFieldUpdateOperationsInput | number
    totalPoints?: IntFieldUpdateOperationsInput | number
    formation?: StringFieldUpdateOperationsInput | string
    status?: EnumTeamStatusFieldUpdateOperationsInput | $Enums.TeamStatus
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type PlayerUpsertWithoutTeamPlayersInput = {
    update: XOR<PlayerUpdateWithoutTeamPlayersInput, PlayerUncheckedUpdateWithoutTeamPlayersInput>
    create: XOR<PlayerCreateWithoutTeamPlayersInput, PlayerUncheckedCreateWithoutTeamPlayersInput>
    where?: PlayerWhereInput
  }

  export type PlayerUpdateToOneWithWhereWithoutTeamPlayersInput = {
    where?: PlayerWhereInput
    data: XOR<PlayerUpdateWithoutTeamPlayersInput, PlayerUncheckedUpdateWithoutTeamPlayersInput>
  }

  export type PlayerUpdateWithoutTeamPlayersInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    image?: NullableStringFieldUpdateOperationsInput | string | null
    position?: EnumPositionFieldUpdateOperationsInput | $Enums.Position
    price?: FloatFieldUpdateOperationsInput | number
    totalPoints?: IntFieldUpdateOperationsInput | number
    isActive?: BoolFieldUpdateOperationsInput | boolean
    isGoldenCardEligible?: BoolFieldUpdateOperationsInput | boolean
    cardTier?: EnumCardTierFieldUpdateOperationsInput | $Enums.CardTier
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    country?: CountryUpdateOneRequiredWithoutPlayersNestedInput
    matchStats?: PlayerMatchStatUpdateManyWithoutPlayerNestedInput
    events?: MatchEventUpdateManyWithoutPlayerNestedInput
    goldenCards?: GoldenCardUpdateManyWithoutPlayerNestedInput
  }

  export type PlayerUncheckedUpdateWithoutTeamPlayersInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    image?: NullableStringFieldUpdateOperationsInput | string | null
    position?: EnumPositionFieldUpdateOperationsInput | $Enums.Position
    countryId?: StringFieldUpdateOperationsInput | string
    price?: FloatFieldUpdateOperationsInput | number
    totalPoints?: IntFieldUpdateOperationsInput | number
    isActive?: BoolFieldUpdateOperationsInput | boolean
    isGoldenCardEligible?: BoolFieldUpdateOperationsInput | boolean
    cardTier?: EnumCardTierFieldUpdateOperationsInput | $Enums.CardTier
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    matchStats?: PlayerMatchStatUncheckedUpdateManyWithoutPlayerNestedInput
    events?: MatchEventUncheckedUpdateManyWithoutPlayerNestedInput
    goldenCards?: GoldenCardUncheckedUpdateManyWithoutPlayerNestedInput
  }

  export type GoldenCardUpsertWithoutTeamPlayerInput = {
    update: XOR<GoldenCardUpdateWithoutTeamPlayerInput, GoldenCardUncheckedUpdateWithoutTeamPlayerInput>
    create: XOR<GoldenCardCreateWithoutTeamPlayerInput, GoldenCardUncheckedCreateWithoutTeamPlayerInput>
    where?: GoldenCardWhereInput
  }

  export type GoldenCardUpdateToOneWithWhereWithoutTeamPlayerInput = {
    where?: GoldenCardWhereInput
    data: XOR<GoldenCardUpdateWithoutTeamPlayerInput, GoldenCardUncheckedUpdateWithoutTeamPlayerInput>
  }

  export type GoldenCardUpdateWithoutTeamPlayerInput = {
    id?: StringFieldUpdateOperationsInput | string
    cardTier?: EnumCardTierFieldUpdateOperationsInput | $Enums.CardTier
    status?: EnumGoldenCardStatusFieldUpdateOperationsInput | $Enums.GoldenCardStatus
    state?: EnumSpecialCardStateFieldUpdateOperationsInput | $Enums.SpecialCardState
    acquiredDate?: DateTimeFieldUpdateOperationsInput | Date | string
    openedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    user?: UserUpdateOneRequiredWithoutGoldenCardsNestedInput
    quiz?: DailyQuizUpdateOneWithoutAwardedCardsNestedInput
    player?: PlayerUpdateOneRequiredWithoutGoldenCardsNestedInput
  }

  export type GoldenCardUncheckedUpdateWithoutTeamPlayerInput = {
    id?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    quizId?: NullableStringFieldUpdateOperationsInput | string | null
    playerId?: StringFieldUpdateOperationsInput | string
    cardTier?: EnumCardTierFieldUpdateOperationsInput | $Enums.CardTier
    status?: EnumGoldenCardStatusFieldUpdateOperationsInput | $Enums.GoldenCardStatus
    state?: EnumSpecialCardStateFieldUpdateOperationsInput | $Enums.SpecialCardState
    acquiredDate?: DateTimeFieldUpdateOperationsInput | Date | string
    openedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type PaymentCreateWithoutPackageInput = {
    id?: string
    amount: number
    authority?: string | null
    refId?: string | null
    status?: $Enums.PaymentStatus
    createdAt?: Date | string
    updatedAt?: Date | string
    user: UserCreateNestedOneWithoutPaymentsInput
  }

  export type PaymentUncheckedCreateWithoutPackageInput = {
    id?: string
    userId: string
    amount: number
    authority?: string | null
    refId?: string | null
    status?: $Enums.PaymentStatus
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type PaymentCreateOrConnectWithoutPackageInput = {
    where: PaymentWhereUniqueInput
    create: XOR<PaymentCreateWithoutPackageInput, PaymentUncheckedCreateWithoutPackageInput>
  }

  export type PaymentCreateManyPackageInputEnvelope = {
    data: PaymentCreateManyPackageInput | PaymentCreateManyPackageInput[]
    skipDuplicates?: boolean
  }

  export type PaymentUpsertWithWhereUniqueWithoutPackageInput = {
    where: PaymentWhereUniqueInput
    update: XOR<PaymentUpdateWithoutPackageInput, PaymentUncheckedUpdateWithoutPackageInput>
    create: XOR<PaymentCreateWithoutPackageInput, PaymentUncheckedCreateWithoutPackageInput>
  }

  export type PaymentUpdateWithWhereUniqueWithoutPackageInput = {
    where: PaymentWhereUniqueInput
    data: XOR<PaymentUpdateWithoutPackageInput, PaymentUncheckedUpdateWithoutPackageInput>
  }

  export type PaymentUpdateManyWithWhereWithoutPackageInput = {
    where: PaymentScalarWhereInput
    data: XOR<PaymentUpdateManyMutationInput, PaymentUncheckedUpdateManyWithoutPackageInput>
  }

  export type UserCreateWithoutPaymentsInput = {
    id?: string
    name?: string | null
    email: string
    phone?: string | null
    password: string
    role?: $Enums.Role
    createdAt?: Date | string
    team?: TeamCreateNestedOneWithoutUserInput
    sessions?: SessionCreateNestedManyWithoutUserInput
    quizSubmissions?: QuizSubmissionCreateNestedManyWithoutUserInput
    goldenCards?: GoldenCardCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutPaymentsInput = {
    id?: string
    name?: string | null
    email: string
    phone?: string | null
    password: string
    role?: $Enums.Role
    createdAt?: Date | string
    team?: TeamUncheckedCreateNestedOneWithoutUserInput
    sessions?: SessionUncheckedCreateNestedManyWithoutUserInput
    quizSubmissions?: QuizSubmissionUncheckedCreateNestedManyWithoutUserInput
    goldenCards?: GoldenCardUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutPaymentsInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutPaymentsInput, UserUncheckedCreateWithoutPaymentsInput>
  }

  export type PackageCreateWithoutPaymentsInput = {
    id?: string
    name: string
    budgetBonus: number
    price: number
    description?: string | null
    isActive?: boolean
  }

  export type PackageUncheckedCreateWithoutPaymentsInput = {
    id?: string
    name: string
    budgetBonus: number
    price: number
    description?: string | null
    isActive?: boolean
  }

  export type PackageCreateOrConnectWithoutPaymentsInput = {
    where: PackageWhereUniqueInput
    create: XOR<PackageCreateWithoutPaymentsInput, PackageUncheckedCreateWithoutPaymentsInput>
  }

  export type UserUpsertWithoutPaymentsInput = {
    update: XOR<UserUpdateWithoutPaymentsInput, UserUncheckedUpdateWithoutPaymentsInput>
    create: XOR<UserCreateWithoutPaymentsInput, UserUncheckedCreateWithoutPaymentsInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutPaymentsInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutPaymentsInput, UserUncheckedUpdateWithoutPaymentsInput>
  }

  export type UserUpdateWithoutPaymentsInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: NullableStringFieldUpdateOperationsInput | string | null
    email?: StringFieldUpdateOperationsInput | string
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    password?: StringFieldUpdateOperationsInput | string
    role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    team?: TeamUpdateOneWithoutUserNestedInput
    sessions?: SessionUpdateManyWithoutUserNestedInput
    quizSubmissions?: QuizSubmissionUpdateManyWithoutUserNestedInput
    goldenCards?: GoldenCardUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutPaymentsInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: NullableStringFieldUpdateOperationsInput | string | null
    email?: StringFieldUpdateOperationsInput | string
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    password?: StringFieldUpdateOperationsInput | string
    role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    team?: TeamUncheckedUpdateOneWithoutUserNestedInput
    sessions?: SessionUncheckedUpdateManyWithoutUserNestedInput
    quizSubmissions?: QuizSubmissionUncheckedUpdateManyWithoutUserNestedInput
    goldenCards?: GoldenCardUncheckedUpdateManyWithoutUserNestedInput
  }

  export type PackageUpsertWithoutPaymentsInput = {
    update: XOR<PackageUpdateWithoutPaymentsInput, PackageUncheckedUpdateWithoutPaymentsInput>
    create: XOR<PackageCreateWithoutPaymentsInput, PackageUncheckedCreateWithoutPaymentsInput>
    where?: PackageWhereInput
  }

  export type PackageUpdateToOneWithWhereWithoutPaymentsInput = {
    where?: PackageWhereInput
    data: XOR<PackageUpdateWithoutPaymentsInput, PackageUncheckedUpdateWithoutPaymentsInput>
  }

  export type PackageUpdateWithoutPaymentsInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    budgetBonus?: FloatFieldUpdateOperationsInput | number
    price?: IntFieldUpdateOperationsInput | number
    description?: NullableStringFieldUpdateOperationsInput | string | null
    isActive?: BoolFieldUpdateOperationsInput | boolean
  }

  export type PackageUncheckedUpdateWithoutPaymentsInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    budgetBonus?: FloatFieldUpdateOperationsInput | number
    price?: IntFieldUpdateOperationsInput | number
    description?: NullableStringFieldUpdateOperationsInput | string | null
    isActive?: BoolFieldUpdateOperationsInput | boolean
  }

  export type PlayerCreateManyCountryInput = {
    id?: string
    name: string
    image?: string | null
    position: $Enums.Position
    price?: number
    totalPoints?: number
    isActive?: boolean
    isGoldenCardEligible?: boolean
    cardTier?: $Enums.CardTier
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type MatchCreateManyHomeTeamInput = {
    id?: string
    awayTeamId: string
    homeScore?: number | null
    awayScore?: number | null
    stage?: $Enums.MatchStage
    status?: $Enums.MatchStatus
    matchDate: Date | string
    matchDatePersian?: string | null
    stadium?: string | null
    city?: string | null
    referee?: string | null
    assistant1?: string | null
    assistant2?: string | null
    fourthOfficial?: string | null
    attendance?: number | null
    weather?: string | null
    description?: string | null
    roundId?: string | null
    createdAt?: Date | string
  }

  export type MatchCreateManyAwayTeamInput = {
    id?: string
    homeTeamId: string
    homeScore?: number | null
    awayScore?: number | null
    stage?: $Enums.MatchStage
    status?: $Enums.MatchStatus
    matchDate: Date | string
    matchDatePersian?: string | null
    stadium?: string | null
    city?: string | null
    referee?: string | null
    assistant1?: string | null
    assistant2?: string | null
    fourthOfficial?: string | null
    attendance?: number | null
    weather?: string | null
    description?: string | null
    roundId?: string | null
    createdAt?: Date | string
  }

  export type PlayerUpdateWithoutCountryInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    image?: NullableStringFieldUpdateOperationsInput | string | null
    position?: EnumPositionFieldUpdateOperationsInput | $Enums.Position
    price?: FloatFieldUpdateOperationsInput | number
    totalPoints?: IntFieldUpdateOperationsInput | number
    isActive?: BoolFieldUpdateOperationsInput | boolean
    isGoldenCardEligible?: BoolFieldUpdateOperationsInput | boolean
    cardTier?: EnumCardTierFieldUpdateOperationsInput | $Enums.CardTier
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    matchStats?: PlayerMatchStatUpdateManyWithoutPlayerNestedInput
    teamPlayers?: TeamPlayerUpdateManyWithoutPlayerNestedInput
    events?: MatchEventUpdateManyWithoutPlayerNestedInput
    goldenCards?: GoldenCardUpdateManyWithoutPlayerNestedInput
  }

  export type PlayerUncheckedUpdateWithoutCountryInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    image?: NullableStringFieldUpdateOperationsInput | string | null
    position?: EnumPositionFieldUpdateOperationsInput | $Enums.Position
    price?: FloatFieldUpdateOperationsInput | number
    totalPoints?: IntFieldUpdateOperationsInput | number
    isActive?: BoolFieldUpdateOperationsInput | boolean
    isGoldenCardEligible?: BoolFieldUpdateOperationsInput | boolean
    cardTier?: EnumCardTierFieldUpdateOperationsInput | $Enums.CardTier
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    matchStats?: PlayerMatchStatUncheckedUpdateManyWithoutPlayerNestedInput
    teamPlayers?: TeamPlayerUncheckedUpdateManyWithoutPlayerNestedInput
    events?: MatchEventUncheckedUpdateManyWithoutPlayerNestedInput
    goldenCards?: GoldenCardUncheckedUpdateManyWithoutPlayerNestedInput
  }

  export type PlayerUncheckedUpdateManyWithoutCountryInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    image?: NullableStringFieldUpdateOperationsInput | string | null
    position?: EnumPositionFieldUpdateOperationsInput | $Enums.Position
    price?: FloatFieldUpdateOperationsInput | number
    totalPoints?: IntFieldUpdateOperationsInput | number
    isActive?: BoolFieldUpdateOperationsInput | boolean
    isGoldenCardEligible?: BoolFieldUpdateOperationsInput | boolean
    cardTier?: EnumCardTierFieldUpdateOperationsInput | $Enums.CardTier
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type MatchUpdateWithoutHomeTeamInput = {
    id?: StringFieldUpdateOperationsInput | string
    homeScore?: NullableIntFieldUpdateOperationsInput | number | null
    awayScore?: NullableIntFieldUpdateOperationsInput | number | null
    stage?: EnumMatchStageFieldUpdateOperationsInput | $Enums.MatchStage
    status?: EnumMatchStatusFieldUpdateOperationsInput | $Enums.MatchStatus
    matchDate?: DateTimeFieldUpdateOperationsInput | Date | string
    matchDatePersian?: NullableStringFieldUpdateOperationsInput | string | null
    stadium?: NullableStringFieldUpdateOperationsInput | string | null
    city?: NullableStringFieldUpdateOperationsInput | string | null
    referee?: NullableStringFieldUpdateOperationsInput | string | null
    assistant1?: NullableStringFieldUpdateOperationsInput | string | null
    assistant2?: NullableStringFieldUpdateOperationsInput | string | null
    fourthOfficial?: NullableStringFieldUpdateOperationsInput | string | null
    attendance?: NullableIntFieldUpdateOperationsInput | number | null
    weather?: NullableStringFieldUpdateOperationsInput | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    awayTeam?: CountryUpdateOneRequiredWithoutAwayMatchesNestedInput
    round?: RoundUpdateOneWithoutMatchesNestedInput
    playerStats?: PlayerMatchStatUpdateManyWithoutMatchNestedInput
    events?: MatchEventUpdateManyWithoutMatchNestedInput
    lineups?: MatchLineupUpdateManyWithoutMatchNestedInput
  }

  export type MatchUncheckedUpdateWithoutHomeTeamInput = {
    id?: StringFieldUpdateOperationsInput | string
    awayTeamId?: StringFieldUpdateOperationsInput | string
    homeScore?: NullableIntFieldUpdateOperationsInput | number | null
    awayScore?: NullableIntFieldUpdateOperationsInput | number | null
    stage?: EnumMatchStageFieldUpdateOperationsInput | $Enums.MatchStage
    status?: EnumMatchStatusFieldUpdateOperationsInput | $Enums.MatchStatus
    matchDate?: DateTimeFieldUpdateOperationsInput | Date | string
    matchDatePersian?: NullableStringFieldUpdateOperationsInput | string | null
    stadium?: NullableStringFieldUpdateOperationsInput | string | null
    city?: NullableStringFieldUpdateOperationsInput | string | null
    referee?: NullableStringFieldUpdateOperationsInput | string | null
    assistant1?: NullableStringFieldUpdateOperationsInput | string | null
    assistant2?: NullableStringFieldUpdateOperationsInput | string | null
    fourthOfficial?: NullableStringFieldUpdateOperationsInput | string | null
    attendance?: NullableIntFieldUpdateOperationsInput | number | null
    weather?: NullableStringFieldUpdateOperationsInput | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    roundId?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    playerStats?: PlayerMatchStatUncheckedUpdateManyWithoutMatchNestedInput
    events?: MatchEventUncheckedUpdateManyWithoutMatchNestedInput
    lineups?: MatchLineupUncheckedUpdateManyWithoutMatchNestedInput
  }

  export type MatchUncheckedUpdateManyWithoutHomeTeamInput = {
    id?: StringFieldUpdateOperationsInput | string
    awayTeamId?: StringFieldUpdateOperationsInput | string
    homeScore?: NullableIntFieldUpdateOperationsInput | number | null
    awayScore?: NullableIntFieldUpdateOperationsInput | number | null
    stage?: EnumMatchStageFieldUpdateOperationsInput | $Enums.MatchStage
    status?: EnumMatchStatusFieldUpdateOperationsInput | $Enums.MatchStatus
    matchDate?: DateTimeFieldUpdateOperationsInput | Date | string
    matchDatePersian?: NullableStringFieldUpdateOperationsInput | string | null
    stadium?: NullableStringFieldUpdateOperationsInput | string | null
    city?: NullableStringFieldUpdateOperationsInput | string | null
    referee?: NullableStringFieldUpdateOperationsInput | string | null
    assistant1?: NullableStringFieldUpdateOperationsInput | string | null
    assistant2?: NullableStringFieldUpdateOperationsInput | string | null
    fourthOfficial?: NullableStringFieldUpdateOperationsInput | string | null
    attendance?: NullableIntFieldUpdateOperationsInput | number | null
    weather?: NullableStringFieldUpdateOperationsInput | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    roundId?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type MatchUpdateWithoutAwayTeamInput = {
    id?: StringFieldUpdateOperationsInput | string
    homeScore?: NullableIntFieldUpdateOperationsInput | number | null
    awayScore?: NullableIntFieldUpdateOperationsInput | number | null
    stage?: EnumMatchStageFieldUpdateOperationsInput | $Enums.MatchStage
    status?: EnumMatchStatusFieldUpdateOperationsInput | $Enums.MatchStatus
    matchDate?: DateTimeFieldUpdateOperationsInput | Date | string
    matchDatePersian?: NullableStringFieldUpdateOperationsInput | string | null
    stadium?: NullableStringFieldUpdateOperationsInput | string | null
    city?: NullableStringFieldUpdateOperationsInput | string | null
    referee?: NullableStringFieldUpdateOperationsInput | string | null
    assistant1?: NullableStringFieldUpdateOperationsInput | string | null
    assistant2?: NullableStringFieldUpdateOperationsInput | string | null
    fourthOfficial?: NullableStringFieldUpdateOperationsInput | string | null
    attendance?: NullableIntFieldUpdateOperationsInput | number | null
    weather?: NullableStringFieldUpdateOperationsInput | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    homeTeam?: CountryUpdateOneRequiredWithoutHomeMatchesNestedInput
    round?: RoundUpdateOneWithoutMatchesNestedInput
    playerStats?: PlayerMatchStatUpdateManyWithoutMatchNestedInput
    events?: MatchEventUpdateManyWithoutMatchNestedInput
    lineups?: MatchLineupUpdateManyWithoutMatchNestedInput
  }

  export type MatchUncheckedUpdateWithoutAwayTeamInput = {
    id?: StringFieldUpdateOperationsInput | string
    homeTeamId?: StringFieldUpdateOperationsInput | string
    homeScore?: NullableIntFieldUpdateOperationsInput | number | null
    awayScore?: NullableIntFieldUpdateOperationsInput | number | null
    stage?: EnumMatchStageFieldUpdateOperationsInput | $Enums.MatchStage
    status?: EnumMatchStatusFieldUpdateOperationsInput | $Enums.MatchStatus
    matchDate?: DateTimeFieldUpdateOperationsInput | Date | string
    matchDatePersian?: NullableStringFieldUpdateOperationsInput | string | null
    stadium?: NullableStringFieldUpdateOperationsInput | string | null
    city?: NullableStringFieldUpdateOperationsInput | string | null
    referee?: NullableStringFieldUpdateOperationsInput | string | null
    assistant1?: NullableStringFieldUpdateOperationsInput | string | null
    assistant2?: NullableStringFieldUpdateOperationsInput | string | null
    fourthOfficial?: NullableStringFieldUpdateOperationsInput | string | null
    attendance?: NullableIntFieldUpdateOperationsInput | number | null
    weather?: NullableStringFieldUpdateOperationsInput | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    roundId?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    playerStats?: PlayerMatchStatUncheckedUpdateManyWithoutMatchNestedInput
    events?: MatchEventUncheckedUpdateManyWithoutMatchNestedInput
    lineups?: MatchLineupUncheckedUpdateManyWithoutMatchNestedInput
  }

  export type MatchUncheckedUpdateManyWithoutAwayTeamInput = {
    id?: StringFieldUpdateOperationsInput | string
    homeTeamId?: StringFieldUpdateOperationsInput | string
    homeScore?: NullableIntFieldUpdateOperationsInput | number | null
    awayScore?: NullableIntFieldUpdateOperationsInput | number | null
    stage?: EnumMatchStageFieldUpdateOperationsInput | $Enums.MatchStage
    status?: EnumMatchStatusFieldUpdateOperationsInput | $Enums.MatchStatus
    matchDate?: DateTimeFieldUpdateOperationsInput | Date | string
    matchDatePersian?: NullableStringFieldUpdateOperationsInput | string | null
    stadium?: NullableStringFieldUpdateOperationsInput | string | null
    city?: NullableStringFieldUpdateOperationsInput | string | null
    referee?: NullableStringFieldUpdateOperationsInput | string | null
    assistant1?: NullableStringFieldUpdateOperationsInput | string | null
    assistant2?: NullableStringFieldUpdateOperationsInput | string | null
    fourthOfficial?: NullableStringFieldUpdateOperationsInput | string | null
    attendance?: NullableIntFieldUpdateOperationsInput | number | null
    weather?: NullableStringFieldUpdateOperationsInput | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    roundId?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type CountryCreateManyGroupInput = {
    id?: string
    name: string
    code: string
    flagUrl?: string | null
    flagImage?: string | null
    confederation?: string | null
    qualificationMethod?: string | null
    qualificationDate?: string | null
    participationHistory?: string | null
    bestResult?: string | null
    description?: string | null
    defaultFormation?: string
    defaultLineupPlayerIds?: CountryCreatedefaultLineupPlayerIdsInput | string[]
    defaultCaptainId?: string | null
    isEliminated?: boolean
  }

  export type CountryUpdateWithoutGroupInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    code?: StringFieldUpdateOperationsInput | string
    flagUrl?: NullableStringFieldUpdateOperationsInput | string | null
    flagImage?: NullableStringFieldUpdateOperationsInput | string | null
    confederation?: NullableStringFieldUpdateOperationsInput | string | null
    qualificationMethod?: NullableStringFieldUpdateOperationsInput | string | null
    qualificationDate?: NullableStringFieldUpdateOperationsInput | string | null
    participationHistory?: NullableStringFieldUpdateOperationsInput | string | null
    bestResult?: NullableStringFieldUpdateOperationsInput | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    defaultFormation?: StringFieldUpdateOperationsInput | string
    defaultLineupPlayerIds?: CountryUpdatedefaultLineupPlayerIdsInput | string[]
    defaultCaptainId?: NullableStringFieldUpdateOperationsInput | string | null
    isEliminated?: BoolFieldUpdateOperationsInput | boolean
    players?: PlayerUpdateManyWithoutCountryNestedInput
    homeMatches?: MatchUpdateManyWithoutHomeTeamNestedInput
    awayMatches?: MatchUpdateManyWithoutAwayTeamNestedInput
  }

  export type CountryUncheckedUpdateWithoutGroupInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    code?: StringFieldUpdateOperationsInput | string
    flagUrl?: NullableStringFieldUpdateOperationsInput | string | null
    flagImage?: NullableStringFieldUpdateOperationsInput | string | null
    confederation?: NullableStringFieldUpdateOperationsInput | string | null
    qualificationMethod?: NullableStringFieldUpdateOperationsInput | string | null
    qualificationDate?: NullableStringFieldUpdateOperationsInput | string | null
    participationHistory?: NullableStringFieldUpdateOperationsInput | string | null
    bestResult?: NullableStringFieldUpdateOperationsInput | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    defaultFormation?: StringFieldUpdateOperationsInput | string
    defaultLineupPlayerIds?: CountryUpdatedefaultLineupPlayerIdsInput | string[]
    defaultCaptainId?: NullableStringFieldUpdateOperationsInput | string | null
    isEliminated?: BoolFieldUpdateOperationsInput | boolean
    players?: PlayerUncheckedUpdateManyWithoutCountryNestedInput
    homeMatches?: MatchUncheckedUpdateManyWithoutHomeTeamNestedInput
    awayMatches?: MatchUncheckedUpdateManyWithoutAwayTeamNestedInput
  }

  export type CountryUncheckedUpdateManyWithoutGroupInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    code?: StringFieldUpdateOperationsInput | string
    flagUrl?: NullableStringFieldUpdateOperationsInput | string | null
    flagImage?: NullableStringFieldUpdateOperationsInput | string | null
    confederation?: NullableStringFieldUpdateOperationsInput | string | null
    qualificationMethod?: NullableStringFieldUpdateOperationsInput | string | null
    qualificationDate?: NullableStringFieldUpdateOperationsInput | string | null
    participationHistory?: NullableStringFieldUpdateOperationsInput | string | null
    bestResult?: NullableStringFieldUpdateOperationsInput | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    defaultFormation?: StringFieldUpdateOperationsInput | string
    defaultLineupPlayerIds?: CountryUpdatedefaultLineupPlayerIdsInput | string[]
    defaultCaptainId?: NullableStringFieldUpdateOperationsInput | string | null
    isEliminated?: BoolFieldUpdateOperationsInput | boolean
  }

  export type PlayerMatchStatCreateManyPlayerInput = {
    id?: string
    matchId: string
    goals?: number
    assists?: number
    yellowCards?: number
    redCards?: number
    minutesPlayed?: number
    cleanSheet?: boolean
    penaltySaved?: number
    penaltyMissed?: number
    ownGoals?: number
    isMotm?: boolean
    extraTimeBonus?: number
    points?: number
  }

  export type TeamPlayerCreateManyPlayerInput = {
    teamId: string
    goldenCardId?: string | null
    isCaptain?: boolean
    isViceCaptain?: boolean
    isBench?: boolean
    positionIndex?: number
  }

  export type MatchEventCreateManyPlayerInput = {
    id?: string
    matchId: string
    type: $Enums.EventType
    minute?: number | null
    extraInfo?: string | null
    createdAt?: Date | string
  }

  export type GoldenCardCreateManyPlayerInput = {
    id?: string
    userId: string
    quizId?: string | null
    cardTier?: $Enums.CardTier
    status?: $Enums.GoldenCardStatus
    state?: $Enums.SpecialCardState
    acquiredDate?: Date | string
    openedAt?: Date | string | null
  }

  export type PlayerMatchStatUpdateWithoutPlayerInput = {
    id?: StringFieldUpdateOperationsInput | string
    goals?: IntFieldUpdateOperationsInput | number
    assists?: IntFieldUpdateOperationsInput | number
    yellowCards?: IntFieldUpdateOperationsInput | number
    redCards?: IntFieldUpdateOperationsInput | number
    minutesPlayed?: IntFieldUpdateOperationsInput | number
    cleanSheet?: BoolFieldUpdateOperationsInput | boolean
    penaltySaved?: IntFieldUpdateOperationsInput | number
    penaltyMissed?: IntFieldUpdateOperationsInput | number
    ownGoals?: IntFieldUpdateOperationsInput | number
    isMotm?: BoolFieldUpdateOperationsInput | boolean
    extraTimeBonus?: IntFieldUpdateOperationsInput | number
    points?: IntFieldUpdateOperationsInput | number
    match?: MatchUpdateOneRequiredWithoutPlayerStatsNestedInput
  }

  export type PlayerMatchStatUncheckedUpdateWithoutPlayerInput = {
    id?: StringFieldUpdateOperationsInput | string
    matchId?: StringFieldUpdateOperationsInput | string
    goals?: IntFieldUpdateOperationsInput | number
    assists?: IntFieldUpdateOperationsInput | number
    yellowCards?: IntFieldUpdateOperationsInput | number
    redCards?: IntFieldUpdateOperationsInput | number
    minutesPlayed?: IntFieldUpdateOperationsInput | number
    cleanSheet?: BoolFieldUpdateOperationsInput | boolean
    penaltySaved?: IntFieldUpdateOperationsInput | number
    penaltyMissed?: IntFieldUpdateOperationsInput | number
    ownGoals?: IntFieldUpdateOperationsInput | number
    isMotm?: BoolFieldUpdateOperationsInput | boolean
    extraTimeBonus?: IntFieldUpdateOperationsInput | number
    points?: IntFieldUpdateOperationsInput | number
  }

  export type PlayerMatchStatUncheckedUpdateManyWithoutPlayerInput = {
    id?: StringFieldUpdateOperationsInput | string
    matchId?: StringFieldUpdateOperationsInput | string
    goals?: IntFieldUpdateOperationsInput | number
    assists?: IntFieldUpdateOperationsInput | number
    yellowCards?: IntFieldUpdateOperationsInput | number
    redCards?: IntFieldUpdateOperationsInput | number
    minutesPlayed?: IntFieldUpdateOperationsInput | number
    cleanSheet?: BoolFieldUpdateOperationsInput | boolean
    penaltySaved?: IntFieldUpdateOperationsInput | number
    penaltyMissed?: IntFieldUpdateOperationsInput | number
    ownGoals?: IntFieldUpdateOperationsInput | number
    isMotm?: BoolFieldUpdateOperationsInput | boolean
    extraTimeBonus?: IntFieldUpdateOperationsInput | number
    points?: IntFieldUpdateOperationsInput | number
  }

  export type TeamPlayerUpdateWithoutPlayerInput = {
    isCaptain?: BoolFieldUpdateOperationsInput | boolean
    isViceCaptain?: BoolFieldUpdateOperationsInput | boolean
    isBench?: BoolFieldUpdateOperationsInput | boolean
    positionIndex?: IntFieldUpdateOperationsInput | number
    team?: TeamUpdateOneRequiredWithoutPlayersNestedInput
    goldenCard?: GoldenCardUpdateOneWithoutTeamPlayerNestedInput
  }

  export type TeamPlayerUncheckedUpdateWithoutPlayerInput = {
    teamId?: StringFieldUpdateOperationsInput | string
    goldenCardId?: NullableStringFieldUpdateOperationsInput | string | null
    isCaptain?: BoolFieldUpdateOperationsInput | boolean
    isViceCaptain?: BoolFieldUpdateOperationsInput | boolean
    isBench?: BoolFieldUpdateOperationsInput | boolean
    positionIndex?: IntFieldUpdateOperationsInput | number
  }

  export type TeamPlayerUncheckedUpdateManyWithoutPlayerInput = {
    teamId?: StringFieldUpdateOperationsInput | string
    goldenCardId?: NullableStringFieldUpdateOperationsInput | string | null
    isCaptain?: BoolFieldUpdateOperationsInput | boolean
    isViceCaptain?: BoolFieldUpdateOperationsInput | boolean
    isBench?: BoolFieldUpdateOperationsInput | boolean
    positionIndex?: IntFieldUpdateOperationsInput | number
  }

  export type MatchEventUpdateWithoutPlayerInput = {
    id?: StringFieldUpdateOperationsInput | string
    type?: EnumEventTypeFieldUpdateOperationsInput | $Enums.EventType
    minute?: NullableIntFieldUpdateOperationsInput | number | null
    extraInfo?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    match?: MatchUpdateOneRequiredWithoutEventsNestedInput
  }

  export type MatchEventUncheckedUpdateWithoutPlayerInput = {
    id?: StringFieldUpdateOperationsInput | string
    matchId?: StringFieldUpdateOperationsInput | string
    type?: EnumEventTypeFieldUpdateOperationsInput | $Enums.EventType
    minute?: NullableIntFieldUpdateOperationsInput | number | null
    extraInfo?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type MatchEventUncheckedUpdateManyWithoutPlayerInput = {
    id?: StringFieldUpdateOperationsInput | string
    matchId?: StringFieldUpdateOperationsInput | string
    type?: EnumEventTypeFieldUpdateOperationsInput | $Enums.EventType
    minute?: NullableIntFieldUpdateOperationsInput | number | null
    extraInfo?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type GoldenCardUpdateWithoutPlayerInput = {
    id?: StringFieldUpdateOperationsInput | string
    cardTier?: EnumCardTierFieldUpdateOperationsInput | $Enums.CardTier
    status?: EnumGoldenCardStatusFieldUpdateOperationsInput | $Enums.GoldenCardStatus
    state?: EnumSpecialCardStateFieldUpdateOperationsInput | $Enums.SpecialCardState
    acquiredDate?: DateTimeFieldUpdateOperationsInput | Date | string
    openedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    user?: UserUpdateOneRequiredWithoutGoldenCardsNestedInput
    quiz?: DailyQuizUpdateOneWithoutAwardedCardsNestedInput
    teamPlayer?: TeamPlayerUpdateOneWithoutGoldenCardNestedInput
  }

  export type GoldenCardUncheckedUpdateWithoutPlayerInput = {
    id?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    quizId?: NullableStringFieldUpdateOperationsInput | string | null
    cardTier?: EnumCardTierFieldUpdateOperationsInput | $Enums.CardTier
    status?: EnumGoldenCardStatusFieldUpdateOperationsInput | $Enums.GoldenCardStatus
    state?: EnumSpecialCardStateFieldUpdateOperationsInput | $Enums.SpecialCardState
    acquiredDate?: DateTimeFieldUpdateOperationsInput | Date | string
    openedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    teamPlayer?: TeamPlayerUncheckedUpdateOneWithoutGoldenCardNestedInput
  }

  export type GoldenCardUncheckedUpdateManyWithoutPlayerInput = {
    id?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    quizId?: NullableStringFieldUpdateOperationsInput | string | null
    cardTier?: EnumCardTierFieldUpdateOperationsInput | $Enums.CardTier
    status?: EnumGoldenCardStatusFieldUpdateOperationsInput | $Enums.GoldenCardStatus
    state?: EnumSpecialCardStateFieldUpdateOperationsInput | $Enums.SpecialCardState
    acquiredDate?: DateTimeFieldUpdateOperationsInput | Date | string
    openedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type PlayerMatchStatCreateManyMatchInput = {
    id?: string
    playerId: string
    goals?: number
    assists?: number
    yellowCards?: number
    redCards?: number
    minutesPlayed?: number
    cleanSheet?: boolean
    penaltySaved?: number
    penaltyMissed?: number
    ownGoals?: number
    isMotm?: boolean
    extraTimeBonus?: number
    points?: number
  }

  export type MatchEventCreateManyMatchInput = {
    id?: string
    playerId: string
    type: $Enums.EventType
    minute?: number | null
    extraInfo?: string | null
    createdAt?: Date | string
  }

  export type MatchLineupCreateManyMatchInput = {
    id?: string
    countryId: string
    formation: string
    playerIds?: MatchLineupCreateplayerIdsInput | string[]
  }

  export type PlayerMatchStatUpdateWithoutMatchInput = {
    id?: StringFieldUpdateOperationsInput | string
    goals?: IntFieldUpdateOperationsInput | number
    assists?: IntFieldUpdateOperationsInput | number
    yellowCards?: IntFieldUpdateOperationsInput | number
    redCards?: IntFieldUpdateOperationsInput | number
    minutesPlayed?: IntFieldUpdateOperationsInput | number
    cleanSheet?: BoolFieldUpdateOperationsInput | boolean
    penaltySaved?: IntFieldUpdateOperationsInput | number
    penaltyMissed?: IntFieldUpdateOperationsInput | number
    ownGoals?: IntFieldUpdateOperationsInput | number
    isMotm?: BoolFieldUpdateOperationsInput | boolean
    extraTimeBonus?: IntFieldUpdateOperationsInput | number
    points?: IntFieldUpdateOperationsInput | number
    player?: PlayerUpdateOneRequiredWithoutMatchStatsNestedInput
  }

  export type PlayerMatchStatUncheckedUpdateWithoutMatchInput = {
    id?: StringFieldUpdateOperationsInput | string
    playerId?: StringFieldUpdateOperationsInput | string
    goals?: IntFieldUpdateOperationsInput | number
    assists?: IntFieldUpdateOperationsInput | number
    yellowCards?: IntFieldUpdateOperationsInput | number
    redCards?: IntFieldUpdateOperationsInput | number
    minutesPlayed?: IntFieldUpdateOperationsInput | number
    cleanSheet?: BoolFieldUpdateOperationsInput | boolean
    penaltySaved?: IntFieldUpdateOperationsInput | number
    penaltyMissed?: IntFieldUpdateOperationsInput | number
    ownGoals?: IntFieldUpdateOperationsInput | number
    isMotm?: BoolFieldUpdateOperationsInput | boolean
    extraTimeBonus?: IntFieldUpdateOperationsInput | number
    points?: IntFieldUpdateOperationsInput | number
  }

  export type PlayerMatchStatUncheckedUpdateManyWithoutMatchInput = {
    id?: StringFieldUpdateOperationsInput | string
    playerId?: StringFieldUpdateOperationsInput | string
    goals?: IntFieldUpdateOperationsInput | number
    assists?: IntFieldUpdateOperationsInput | number
    yellowCards?: IntFieldUpdateOperationsInput | number
    redCards?: IntFieldUpdateOperationsInput | number
    minutesPlayed?: IntFieldUpdateOperationsInput | number
    cleanSheet?: BoolFieldUpdateOperationsInput | boolean
    penaltySaved?: IntFieldUpdateOperationsInput | number
    penaltyMissed?: IntFieldUpdateOperationsInput | number
    ownGoals?: IntFieldUpdateOperationsInput | number
    isMotm?: BoolFieldUpdateOperationsInput | boolean
    extraTimeBonus?: IntFieldUpdateOperationsInput | number
    points?: IntFieldUpdateOperationsInput | number
  }

  export type MatchEventUpdateWithoutMatchInput = {
    id?: StringFieldUpdateOperationsInput | string
    type?: EnumEventTypeFieldUpdateOperationsInput | $Enums.EventType
    minute?: NullableIntFieldUpdateOperationsInput | number | null
    extraInfo?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    player?: PlayerUpdateOneRequiredWithoutEventsNestedInput
  }

  export type MatchEventUncheckedUpdateWithoutMatchInput = {
    id?: StringFieldUpdateOperationsInput | string
    playerId?: StringFieldUpdateOperationsInput | string
    type?: EnumEventTypeFieldUpdateOperationsInput | $Enums.EventType
    minute?: NullableIntFieldUpdateOperationsInput | number | null
    extraInfo?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type MatchEventUncheckedUpdateManyWithoutMatchInput = {
    id?: StringFieldUpdateOperationsInput | string
    playerId?: StringFieldUpdateOperationsInput | string
    type?: EnumEventTypeFieldUpdateOperationsInput | $Enums.EventType
    minute?: NullableIntFieldUpdateOperationsInput | number | null
    extraInfo?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type MatchLineupUpdateWithoutMatchInput = {
    id?: StringFieldUpdateOperationsInput | string
    countryId?: StringFieldUpdateOperationsInput | string
    formation?: StringFieldUpdateOperationsInput | string
    playerIds?: MatchLineupUpdateplayerIdsInput | string[]
  }

  export type MatchLineupUncheckedUpdateWithoutMatchInput = {
    id?: StringFieldUpdateOperationsInput | string
    countryId?: StringFieldUpdateOperationsInput | string
    formation?: StringFieldUpdateOperationsInput | string
    playerIds?: MatchLineupUpdateplayerIdsInput | string[]
  }

  export type MatchLineupUncheckedUpdateManyWithoutMatchInput = {
    id?: StringFieldUpdateOperationsInput | string
    countryId?: StringFieldUpdateOperationsInput | string
    formation?: StringFieldUpdateOperationsInput | string
    playerIds?: MatchLineupUpdateplayerIdsInput | string[]
  }

  export type MatchCreateManyRoundInput = {
    id?: string
    homeTeamId: string
    awayTeamId: string
    homeScore?: number | null
    awayScore?: number | null
    stage?: $Enums.MatchStage
    status?: $Enums.MatchStatus
    matchDate: Date | string
    matchDatePersian?: string | null
    stadium?: string | null
    city?: string | null
    referee?: string | null
    assistant1?: string | null
    assistant2?: string | null
    fourthOfficial?: string | null
    attendance?: number | null
    weather?: string | null
    description?: string | null
    createdAt?: Date | string
  }

  export type MatchUpdateWithoutRoundInput = {
    id?: StringFieldUpdateOperationsInput | string
    homeScore?: NullableIntFieldUpdateOperationsInput | number | null
    awayScore?: NullableIntFieldUpdateOperationsInput | number | null
    stage?: EnumMatchStageFieldUpdateOperationsInput | $Enums.MatchStage
    status?: EnumMatchStatusFieldUpdateOperationsInput | $Enums.MatchStatus
    matchDate?: DateTimeFieldUpdateOperationsInput | Date | string
    matchDatePersian?: NullableStringFieldUpdateOperationsInput | string | null
    stadium?: NullableStringFieldUpdateOperationsInput | string | null
    city?: NullableStringFieldUpdateOperationsInput | string | null
    referee?: NullableStringFieldUpdateOperationsInput | string | null
    assistant1?: NullableStringFieldUpdateOperationsInput | string | null
    assistant2?: NullableStringFieldUpdateOperationsInput | string | null
    fourthOfficial?: NullableStringFieldUpdateOperationsInput | string | null
    attendance?: NullableIntFieldUpdateOperationsInput | number | null
    weather?: NullableStringFieldUpdateOperationsInput | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    homeTeam?: CountryUpdateOneRequiredWithoutHomeMatchesNestedInput
    awayTeam?: CountryUpdateOneRequiredWithoutAwayMatchesNestedInput
    playerStats?: PlayerMatchStatUpdateManyWithoutMatchNestedInput
    events?: MatchEventUpdateManyWithoutMatchNestedInput
    lineups?: MatchLineupUpdateManyWithoutMatchNestedInput
  }

  export type MatchUncheckedUpdateWithoutRoundInput = {
    id?: StringFieldUpdateOperationsInput | string
    homeTeamId?: StringFieldUpdateOperationsInput | string
    awayTeamId?: StringFieldUpdateOperationsInput | string
    homeScore?: NullableIntFieldUpdateOperationsInput | number | null
    awayScore?: NullableIntFieldUpdateOperationsInput | number | null
    stage?: EnumMatchStageFieldUpdateOperationsInput | $Enums.MatchStage
    status?: EnumMatchStatusFieldUpdateOperationsInput | $Enums.MatchStatus
    matchDate?: DateTimeFieldUpdateOperationsInput | Date | string
    matchDatePersian?: NullableStringFieldUpdateOperationsInput | string | null
    stadium?: NullableStringFieldUpdateOperationsInput | string | null
    city?: NullableStringFieldUpdateOperationsInput | string | null
    referee?: NullableStringFieldUpdateOperationsInput | string | null
    assistant1?: NullableStringFieldUpdateOperationsInput | string | null
    assistant2?: NullableStringFieldUpdateOperationsInput | string | null
    fourthOfficial?: NullableStringFieldUpdateOperationsInput | string | null
    attendance?: NullableIntFieldUpdateOperationsInput | number | null
    weather?: NullableStringFieldUpdateOperationsInput | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    playerStats?: PlayerMatchStatUncheckedUpdateManyWithoutMatchNestedInput
    events?: MatchEventUncheckedUpdateManyWithoutMatchNestedInput
    lineups?: MatchLineupUncheckedUpdateManyWithoutMatchNestedInput
  }

  export type MatchUncheckedUpdateManyWithoutRoundInput = {
    id?: StringFieldUpdateOperationsInput | string
    homeTeamId?: StringFieldUpdateOperationsInput | string
    awayTeamId?: StringFieldUpdateOperationsInput | string
    homeScore?: NullableIntFieldUpdateOperationsInput | number | null
    awayScore?: NullableIntFieldUpdateOperationsInput | number | null
    stage?: EnumMatchStageFieldUpdateOperationsInput | $Enums.MatchStage
    status?: EnumMatchStatusFieldUpdateOperationsInput | $Enums.MatchStatus
    matchDate?: DateTimeFieldUpdateOperationsInput | Date | string
    matchDatePersian?: NullableStringFieldUpdateOperationsInput | string | null
    stadium?: NullableStringFieldUpdateOperationsInput | string | null
    city?: NullableStringFieldUpdateOperationsInput | string | null
    referee?: NullableStringFieldUpdateOperationsInput | string | null
    assistant1?: NullableStringFieldUpdateOperationsInput | string | null
    assistant2?: NullableStringFieldUpdateOperationsInput | string | null
    fourthOfficial?: NullableStringFieldUpdateOperationsInput | string | null
    attendance?: NullableIntFieldUpdateOperationsInput | number | null
    weather?: NullableStringFieldUpdateOperationsInput | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type SessionCreateManyUserInput = {
    id?: string
    sessionToken: string
    expires: Date | string
  }

  export type PaymentCreateManyUserInput = {
    id?: string
    packageId: string
    amount: number
    authority?: string | null
    refId?: string | null
    status?: $Enums.PaymentStatus
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type QuizSubmissionCreateManyUserInput = {
    id?: string
    quizId: string
    answers?: QuizSubmissionCreateanswersInput | number[]
    correctAnswers?: number
    score?: number
    submittedAt?: Date | string
  }

  export type GoldenCardCreateManyUserInput = {
    id?: string
    quizId?: string | null
    playerId: string
    cardTier?: $Enums.CardTier
    status?: $Enums.GoldenCardStatus
    state?: $Enums.SpecialCardState
    acquiredDate?: Date | string
    openedAt?: Date | string | null
  }

  export type SessionUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    sessionToken?: StringFieldUpdateOperationsInput | string
    expires?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type SessionUncheckedUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    sessionToken?: StringFieldUpdateOperationsInput | string
    expires?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type SessionUncheckedUpdateManyWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    sessionToken?: StringFieldUpdateOperationsInput | string
    expires?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type PaymentUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    amount?: IntFieldUpdateOperationsInput | number
    authority?: NullableStringFieldUpdateOperationsInput | string | null
    refId?: NullableStringFieldUpdateOperationsInput | string | null
    status?: EnumPaymentStatusFieldUpdateOperationsInput | $Enums.PaymentStatus
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    package?: PackageUpdateOneRequiredWithoutPaymentsNestedInput
  }

  export type PaymentUncheckedUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    packageId?: StringFieldUpdateOperationsInput | string
    amount?: IntFieldUpdateOperationsInput | number
    authority?: NullableStringFieldUpdateOperationsInput | string | null
    refId?: NullableStringFieldUpdateOperationsInput | string | null
    status?: EnumPaymentStatusFieldUpdateOperationsInput | $Enums.PaymentStatus
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type PaymentUncheckedUpdateManyWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    packageId?: StringFieldUpdateOperationsInput | string
    amount?: IntFieldUpdateOperationsInput | number
    authority?: NullableStringFieldUpdateOperationsInput | string | null
    refId?: NullableStringFieldUpdateOperationsInput | string | null
    status?: EnumPaymentStatusFieldUpdateOperationsInput | $Enums.PaymentStatus
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type QuizSubmissionUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    answers?: QuizSubmissionUpdateanswersInput | number[]
    correctAnswers?: IntFieldUpdateOperationsInput | number
    score?: IntFieldUpdateOperationsInput | number
    submittedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    quiz?: DailyQuizUpdateOneRequiredWithoutSubmissionsNestedInput
  }

  export type QuizSubmissionUncheckedUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    quizId?: StringFieldUpdateOperationsInput | string
    answers?: QuizSubmissionUpdateanswersInput | number[]
    correctAnswers?: IntFieldUpdateOperationsInput | number
    score?: IntFieldUpdateOperationsInput | number
    submittedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type QuizSubmissionUncheckedUpdateManyWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    quizId?: StringFieldUpdateOperationsInput | string
    answers?: QuizSubmissionUpdateanswersInput | number[]
    correctAnswers?: IntFieldUpdateOperationsInput | number
    score?: IntFieldUpdateOperationsInput | number
    submittedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type GoldenCardUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    cardTier?: EnumCardTierFieldUpdateOperationsInput | $Enums.CardTier
    status?: EnumGoldenCardStatusFieldUpdateOperationsInput | $Enums.GoldenCardStatus
    state?: EnumSpecialCardStateFieldUpdateOperationsInput | $Enums.SpecialCardState
    acquiredDate?: DateTimeFieldUpdateOperationsInput | Date | string
    openedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    quiz?: DailyQuizUpdateOneWithoutAwardedCardsNestedInput
    player?: PlayerUpdateOneRequiredWithoutGoldenCardsNestedInput
    teamPlayer?: TeamPlayerUpdateOneWithoutGoldenCardNestedInput
  }

  export type GoldenCardUncheckedUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    quizId?: NullableStringFieldUpdateOperationsInput | string | null
    playerId?: StringFieldUpdateOperationsInput | string
    cardTier?: EnumCardTierFieldUpdateOperationsInput | $Enums.CardTier
    status?: EnumGoldenCardStatusFieldUpdateOperationsInput | $Enums.GoldenCardStatus
    state?: EnumSpecialCardStateFieldUpdateOperationsInput | $Enums.SpecialCardState
    acquiredDate?: DateTimeFieldUpdateOperationsInput | Date | string
    openedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    teamPlayer?: TeamPlayerUncheckedUpdateOneWithoutGoldenCardNestedInput
  }

  export type GoldenCardUncheckedUpdateManyWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    quizId?: NullableStringFieldUpdateOperationsInput | string | null
    playerId?: StringFieldUpdateOperationsInput | string
    cardTier?: EnumCardTierFieldUpdateOperationsInput | $Enums.CardTier
    status?: EnumGoldenCardStatusFieldUpdateOperationsInput | $Enums.GoldenCardStatus
    state?: EnumSpecialCardStateFieldUpdateOperationsInput | $Enums.SpecialCardState
    acquiredDate?: DateTimeFieldUpdateOperationsInput | Date | string
    openedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type QuizQuestionCreateManyQuizInput = {
    id?: string
    questionText: string
    options?: QuizQuestionCreateoptionsInput | string[]
    correctAnswer: number
    order?: number
  }

  export type QuizSubmissionCreateManyQuizInput = {
    id?: string
    userId: string
    answers?: QuizSubmissionCreateanswersInput | number[]
    correctAnswers?: number
    score?: number
    submittedAt?: Date | string
  }

  export type GoldenCardCreateManyQuizInput = {
    id?: string
    userId: string
    playerId: string
    cardTier?: $Enums.CardTier
    status?: $Enums.GoldenCardStatus
    state?: $Enums.SpecialCardState
    acquiredDate?: Date | string
    openedAt?: Date | string | null
  }

  export type QuizQuestionUpdateWithoutQuizInput = {
    id?: StringFieldUpdateOperationsInput | string
    questionText?: StringFieldUpdateOperationsInput | string
    options?: QuizQuestionUpdateoptionsInput | string[]
    correctAnswer?: IntFieldUpdateOperationsInput | number
    order?: IntFieldUpdateOperationsInput | number
  }

  export type QuizQuestionUncheckedUpdateWithoutQuizInput = {
    id?: StringFieldUpdateOperationsInput | string
    questionText?: StringFieldUpdateOperationsInput | string
    options?: QuizQuestionUpdateoptionsInput | string[]
    correctAnswer?: IntFieldUpdateOperationsInput | number
    order?: IntFieldUpdateOperationsInput | number
  }

  export type QuizQuestionUncheckedUpdateManyWithoutQuizInput = {
    id?: StringFieldUpdateOperationsInput | string
    questionText?: StringFieldUpdateOperationsInput | string
    options?: QuizQuestionUpdateoptionsInput | string[]
    correctAnswer?: IntFieldUpdateOperationsInput | number
    order?: IntFieldUpdateOperationsInput | number
  }

  export type QuizSubmissionUpdateWithoutQuizInput = {
    id?: StringFieldUpdateOperationsInput | string
    answers?: QuizSubmissionUpdateanswersInput | number[]
    correctAnswers?: IntFieldUpdateOperationsInput | number
    score?: IntFieldUpdateOperationsInput | number
    submittedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    user?: UserUpdateOneRequiredWithoutQuizSubmissionsNestedInput
  }

  export type QuizSubmissionUncheckedUpdateWithoutQuizInput = {
    id?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    answers?: QuizSubmissionUpdateanswersInput | number[]
    correctAnswers?: IntFieldUpdateOperationsInput | number
    score?: IntFieldUpdateOperationsInput | number
    submittedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type QuizSubmissionUncheckedUpdateManyWithoutQuizInput = {
    id?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    answers?: QuizSubmissionUpdateanswersInput | number[]
    correctAnswers?: IntFieldUpdateOperationsInput | number
    score?: IntFieldUpdateOperationsInput | number
    submittedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type GoldenCardUpdateWithoutQuizInput = {
    id?: StringFieldUpdateOperationsInput | string
    cardTier?: EnumCardTierFieldUpdateOperationsInput | $Enums.CardTier
    status?: EnumGoldenCardStatusFieldUpdateOperationsInput | $Enums.GoldenCardStatus
    state?: EnumSpecialCardStateFieldUpdateOperationsInput | $Enums.SpecialCardState
    acquiredDate?: DateTimeFieldUpdateOperationsInput | Date | string
    openedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    user?: UserUpdateOneRequiredWithoutGoldenCardsNestedInput
    player?: PlayerUpdateOneRequiredWithoutGoldenCardsNestedInput
    teamPlayer?: TeamPlayerUpdateOneWithoutGoldenCardNestedInput
  }

  export type GoldenCardUncheckedUpdateWithoutQuizInput = {
    id?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    playerId?: StringFieldUpdateOperationsInput | string
    cardTier?: EnumCardTierFieldUpdateOperationsInput | $Enums.CardTier
    status?: EnumGoldenCardStatusFieldUpdateOperationsInput | $Enums.GoldenCardStatus
    state?: EnumSpecialCardStateFieldUpdateOperationsInput | $Enums.SpecialCardState
    acquiredDate?: DateTimeFieldUpdateOperationsInput | Date | string
    openedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    teamPlayer?: TeamPlayerUncheckedUpdateOneWithoutGoldenCardNestedInput
  }

  export type GoldenCardUncheckedUpdateManyWithoutQuizInput = {
    id?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    playerId?: StringFieldUpdateOperationsInput | string
    cardTier?: EnumCardTierFieldUpdateOperationsInput | $Enums.CardTier
    status?: EnumGoldenCardStatusFieldUpdateOperationsInput | $Enums.GoldenCardStatus
    state?: EnumSpecialCardStateFieldUpdateOperationsInput | $Enums.SpecialCardState
    acquiredDate?: DateTimeFieldUpdateOperationsInput | Date | string
    openedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type TeamPlayerCreateManyTeamInput = {
    playerId: string
    goldenCardId?: string | null
    isCaptain?: boolean
    isViceCaptain?: boolean
    isBench?: boolean
    positionIndex?: number
  }

  export type TeamPlayerUpdateWithoutTeamInput = {
    isCaptain?: BoolFieldUpdateOperationsInput | boolean
    isViceCaptain?: BoolFieldUpdateOperationsInput | boolean
    isBench?: BoolFieldUpdateOperationsInput | boolean
    positionIndex?: IntFieldUpdateOperationsInput | number
    player?: PlayerUpdateOneRequiredWithoutTeamPlayersNestedInput
    goldenCard?: GoldenCardUpdateOneWithoutTeamPlayerNestedInput
  }

  export type TeamPlayerUncheckedUpdateWithoutTeamInput = {
    playerId?: StringFieldUpdateOperationsInput | string
    goldenCardId?: NullableStringFieldUpdateOperationsInput | string | null
    isCaptain?: BoolFieldUpdateOperationsInput | boolean
    isViceCaptain?: BoolFieldUpdateOperationsInput | boolean
    isBench?: BoolFieldUpdateOperationsInput | boolean
    positionIndex?: IntFieldUpdateOperationsInput | number
  }

  export type TeamPlayerUncheckedUpdateManyWithoutTeamInput = {
    playerId?: StringFieldUpdateOperationsInput | string
    goldenCardId?: NullableStringFieldUpdateOperationsInput | string | null
    isCaptain?: BoolFieldUpdateOperationsInput | boolean
    isViceCaptain?: BoolFieldUpdateOperationsInput | boolean
    isBench?: BoolFieldUpdateOperationsInput | boolean
    positionIndex?: IntFieldUpdateOperationsInput | number
  }

  export type PaymentCreateManyPackageInput = {
    id?: string
    userId: string
    amount: number
    authority?: string | null
    refId?: string | null
    status?: $Enums.PaymentStatus
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type PaymentUpdateWithoutPackageInput = {
    id?: StringFieldUpdateOperationsInput | string
    amount?: IntFieldUpdateOperationsInput | number
    authority?: NullableStringFieldUpdateOperationsInput | string | null
    refId?: NullableStringFieldUpdateOperationsInput | string | null
    status?: EnumPaymentStatusFieldUpdateOperationsInput | $Enums.PaymentStatus
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    user?: UserUpdateOneRequiredWithoutPaymentsNestedInput
  }

  export type PaymentUncheckedUpdateWithoutPackageInput = {
    id?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    amount?: IntFieldUpdateOperationsInput | number
    authority?: NullableStringFieldUpdateOperationsInput | string | null
    refId?: NullableStringFieldUpdateOperationsInput | string | null
    status?: EnumPaymentStatusFieldUpdateOperationsInput | $Enums.PaymentStatus
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type PaymentUncheckedUpdateManyWithoutPackageInput = {
    id?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    amount?: IntFieldUpdateOperationsInput | number
    authority?: NullableStringFieldUpdateOperationsInput | string | null
    refId?: NullableStringFieldUpdateOperationsInput | string | null
    status?: EnumPaymentStatusFieldUpdateOperationsInput | $Enums.PaymentStatus
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }



  /**
   * Batch Payload for updateMany & deleteMany & createMany
   */

  export type BatchPayload = {
    count: number
  }

  /**
   * DMMF
   */
  export const dmmf: runtime.BaseDMMF
}