
/**
 * Client
**/

import * as runtime from './runtime/library.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 Utilisateur
 * 
 */
export type Utilisateur = $Result.DefaultSelection<Prisma.$UtilisateurPayload>
/**
 * Model Formation
 * 
 */
export type Formation = $Result.DefaultSelection<Prisma.$FormationPayload>
/**
 * Model Video
 * 
 */
export type Video = $Result.DefaultSelection<Prisma.$VideoPayload>
/**
 * Model Commande
 * 
 */
export type Commande = $Result.DefaultSelection<Prisma.$CommandePayload>
/**
 * Model CommandeFormation
 * 
 */
export type CommandeFormation = $Result.DefaultSelection<Prisma.$CommandeFormationPayload>
/**
 * Model Achat
 * 
 */
export type Achat = $Result.DefaultSelection<Prisma.$AchatPayload>
/**
 * Model Tag
 * 
 */
export type Tag = $Result.DefaultSelection<Prisma.$TagPayload>
/**
 * Model TagVideo
 * 
 */
export type TagVideo = $Result.DefaultSelection<Prisma.$TagVideoPayload>

/**
 * ##  Prisma Client ʲˢ
 *
 * Type-safe database client for TypeScript & Node.js
 * @example
 * ```
 * const prisma = new PrismaClient()
 * // Fetch zero or more Utilisateurs
 * const utilisateurs = await prisma.utilisateur.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,
  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 Utilisateurs
   * const utilisateurs = await prisma.utilisateur.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>;

  /**
   * Add a middleware
   * @deprecated since 4.16.0. For new code, prefer client extensions instead.
   * @see https://pris.ly/d/extensions
   */
  $use(cb: Prisma.Middleware): 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.utilisateur`: Exposes CRUD operations for the **Utilisateur** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Utilisateurs
    * const utilisateurs = await prisma.utilisateur.findMany()
    * ```
    */
  get utilisateur(): Prisma.UtilisateurDelegate<ExtArgs, ClientOptions>;

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

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

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

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

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

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

  /**
   * `prisma.tagVideo`: Exposes CRUD operations for the **TagVideo** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more TagVideos
    * const tagVideos = await prisma.tagVideo.findMany()
    * ```
    */
  get tagVideo(): Prisma.TagVideoDelegate<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.6.0
   * Query Engine version: f676762280b54cd07c770017ed3711ddde35f37a
   */
  export type PrismaVersion = {
    client: string
  }

  export const prismaVersion: PrismaVersion

  /**
   * Utility Types
   */


  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: {
    Utilisateur: 'Utilisateur',
    Formation: 'Formation',
    Video: 'Video',
    Commande: 'Commande',
    CommandeFormation: 'CommandeFormation',
    Achat: 'Achat',
    Tag: 'Tag',
    TagVideo: 'TagVideo'
  };

  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: "utilisateur" | "formation" | "video" | "commande" | "commandeFormation" | "achat" | "tag" | "tagVideo"
      txIsolationLevel: Prisma.TransactionIsolationLevel
    }
    model: {
      Utilisateur: {
        payload: Prisma.$UtilisateurPayload<ExtArgs>
        fields: Prisma.UtilisateurFieldRefs
        operations: {
          findUnique: {
            args: Prisma.UtilisateurFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UtilisateurPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.UtilisateurFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UtilisateurPayload>
          }
          findFirst: {
            args: Prisma.UtilisateurFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UtilisateurPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.UtilisateurFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UtilisateurPayload>
          }
          findMany: {
            args: Prisma.UtilisateurFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UtilisateurPayload>[]
          }
          create: {
            args: Prisma.UtilisateurCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UtilisateurPayload>
          }
          createMany: {
            args: Prisma.UtilisateurCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          delete: {
            args: Prisma.UtilisateurDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UtilisateurPayload>
          }
          update: {
            args: Prisma.UtilisateurUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UtilisateurPayload>
          }
          deleteMany: {
            args: Prisma.UtilisateurDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.UtilisateurUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.UtilisateurUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UtilisateurPayload>
          }
          aggregate: {
            args: Prisma.UtilisateurAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateUtilisateur>
          }
          groupBy: {
            args: Prisma.UtilisateurGroupByArgs<ExtArgs>
            result: $Utils.Optional<UtilisateurGroupByOutputType>[]
          }
          count: {
            args: Prisma.UtilisateurCountArgs<ExtArgs>
            result: $Utils.Optional<UtilisateurCountAggregateOutputType> | number
          }
        }
      }
      Formation: {
        payload: Prisma.$FormationPayload<ExtArgs>
        fields: Prisma.FormationFieldRefs
        operations: {
          findUnique: {
            args: Prisma.FormationFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$FormationPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.FormationFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$FormationPayload>
          }
          findFirst: {
            args: Prisma.FormationFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$FormationPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.FormationFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$FormationPayload>
          }
          findMany: {
            args: Prisma.FormationFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$FormationPayload>[]
          }
          create: {
            args: Prisma.FormationCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$FormationPayload>
          }
          createMany: {
            args: Prisma.FormationCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          delete: {
            args: Prisma.FormationDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$FormationPayload>
          }
          update: {
            args: Prisma.FormationUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$FormationPayload>
          }
          deleteMany: {
            args: Prisma.FormationDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.FormationUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.FormationUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$FormationPayload>
          }
          aggregate: {
            args: Prisma.FormationAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateFormation>
          }
          groupBy: {
            args: Prisma.FormationGroupByArgs<ExtArgs>
            result: $Utils.Optional<FormationGroupByOutputType>[]
          }
          count: {
            args: Prisma.FormationCountArgs<ExtArgs>
            result: $Utils.Optional<FormationCountAggregateOutputType> | number
          }
        }
      }
      Video: {
        payload: Prisma.$VideoPayload<ExtArgs>
        fields: Prisma.VideoFieldRefs
        operations: {
          findUnique: {
            args: Prisma.VideoFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$VideoPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.VideoFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$VideoPayload>
          }
          findFirst: {
            args: Prisma.VideoFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$VideoPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.VideoFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$VideoPayload>
          }
          findMany: {
            args: Prisma.VideoFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$VideoPayload>[]
          }
          create: {
            args: Prisma.VideoCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$VideoPayload>
          }
          createMany: {
            args: Prisma.VideoCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          delete: {
            args: Prisma.VideoDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$VideoPayload>
          }
          update: {
            args: Prisma.VideoUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$VideoPayload>
          }
          deleteMany: {
            args: Prisma.VideoDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.VideoUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.VideoUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$VideoPayload>
          }
          aggregate: {
            args: Prisma.VideoAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateVideo>
          }
          groupBy: {
            args: Prisma.VideoGroupByArgs<ExtArgs>
            result: $Utils.Optional<VideoGroupByOutputType>[]
          }
          count: {
            args: Prisma.VideoCountArgs<ExtArgs>
            result: $Utils.Optional<VideoCountAggregateOutputType> | number
          }
        }
      }
      Commande: {
        payload: Prisma.$CommandePayload<ExtArgs>
        fields: Prisma.CommandeFieldRefs
        operations: {
          findUnique: {
            args: Prisma.CommandeFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CommandePayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.CommandeFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CommandePayload>
          }
          findFirst: {
            args: Prisma.CommandeFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CommandePayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.CommandeFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CommandePayload>
          }
          findMany: {
            args: Prisma.CommandeFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CommandePayload>[]
          }
          create: {
            args: Prisma.CommandeCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CommandePayload>
          }
          createMany: {
            args: Prisma.CommandeCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          delete: {
            args: Prisma.CommandeDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CommandePayload>
          }
          update: {
            args: Prisma.CommandeUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CommandePayload>
          }
          deleteMany: {
            args: Prisma.CommandeDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.CommandeUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.CommandeUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CommandePayload>
          }
          aggregate: {
            args: Prisma.CommandeAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateCommande>
          }
          groupBy: {
            args: Prisma.CommandeGroupByArgs<ExtArgs>
            result: $Utils.Optional<CommandeGroupByOutputType>[]
          }
          count: {
            args: Prisma.CommandeCountArgs<ExtArgs>
            result: $Utils.Optional<CommandeCountAggregateOutputType> | number
          }
        }
      }
      CommandeFormation: {
        payload: Prisma.$CommandeFormationPayload<ExtArgs>
        fields: Prisma.CommandeFormationFieldRefs
        operations: {
          findUnique: {
            args: Prisma.CommandeFormationFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CommandeFormationPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.CommandeFormationFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CommandeFormationPayload>
          }
          findFirst: {
            args: Prisma.CommandeFormationFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CommandeFormationPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.CommandeFormationFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CommandeFormationPayload>
          }
          findMany: {
            args: Prisma.CommandeFormationFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CommandeFormationPayload>[]
          }
          create: {
            args: Prisma.CommandeFormationCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CommandeFormationPayload>
          }
          createMany: {
            args: Prisma.CommandeFormationCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          delete: {
            args: Prisma.CommandeFormationDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CommandeFormationPayload>
          }
          update: {
            args: Prisma.CommandeFormationUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CommandeFormationPayload>
          }
          deleteMany: {
            args: Prisma.CommandeFormationDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.CommandeFormationUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.CommandeFormationUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CommandeFormationPayload>
          }
          aggregate: {
            args: Prisma.CommandeFormationAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateCommandeFormation>
          }
          groupBy: {
            args: Prisma.CommandeFormationGroupByArgs<ExtArgs>
            result: $Utils.Optional<CommandeFormationGroupByOutputType>[]
          }
          count: {
            args: Prisma.CommandeFormationCountArgs<ExtArgs>
            result: $Utils.Optional<CommandeFormationCountAggregateOutputType> | number
          }
        }
      }
      Achat: {
        payload: Prisma.$AchatPayload<ExtArgs>
        fields: Prisma.AchatFieldRefs
        operations: {
          findUnique: {
            args: Prisma.AchatFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AchatPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.AchatFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AchatPayload>
          }
          findFirst: {
            args: Prisma.AchatFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AchatPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.AchatFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AchatPayload>
          }
          findMany: {
            args: Prisma.AchatFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AchatPayload>[]
          }
          create: {
            args: Prisma.AchatCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AchatPayload>
          }
          createMany: {
            args: Prisma.AchatCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          delete: {
            args: Prisma.AchatDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AchatPayload>
          }
          update: {
            args: Prisma.AchatUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AchatPayload>
          }
          deleteMany: {
            args: Prisma.AchatDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.AchatUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.AchatUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AchatPayload>
          }
          aggregate: {
            args: Prisma.AchatAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateAchat>
          }
          groupBy: {
            args: Prisma.AchatGroupByArgs<ExtArgs>
            result: $Utils.Optional<AchatGroupByOutputType>[]
          }
          count: {
            args: Prisma.AchatCountArgs<ExtArgs>
            result: $Utils.Optional<AchatCountAggregateOutputType> | number
          }
        }
      }
      Tag: {
        payload: Prisma.$TagPayload<ExtArgs>
        fields: Prisma.TagFieldRefs
        operations: {
          findUnique: {
            args: Prisma.TagFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TagPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.TagFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TagPayload>
          }
          findFirst: {
            args: Prisma.TagFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TagPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.TagFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TagPayload>
          }
          findMany: {
            args: Prisma.TagFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TagPayload>[]
          }
          create: {
            args: Prisma.TagCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TagPayload>
          }
          createMany: {
            args: Prisma.TagCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          delete: {
            args: Prisma.TagDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TagPayload>
          }
          update: {
            args: Prisma.TagUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TagPayload>
          }
          deleteMany: {
            args: Prisma.TagDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.TagUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.TagUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TagPayload>
          }
          aggregate: {
            args: Prisma.TagAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateTag>
          }
          groupBy: {
            args: Prisma.TagGroupByArgs<ExtArgs>
            result: $Utils.Optional<TagGroupByOutputType>[]
          }
          count: {
            args: Prisma.TagCountArgs<ExtArgs>
            result: $Utils.Optional<TagCountAggregateOutputType> | number
          }
        }
      }
      TagVideo: {
        payload: Prisma.$TagVideoPayload<ExtArgs>
        fields: Prisma.TagVideoFieldRefs
        operations: {
          findUnique: {
            args: Prisma.TagVideoFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TagVideoPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.TagVideoFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TagVideoPayload>
          }
          findFirst: {
            args: Prisma.TagVideoFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TagVideoPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.TagVideoFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TagVideoPayload>
          }
          findMany: {
            args: Prisma.TagVideoFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TagVideoPayload>[]
          }
          create: {
            args: Prisma.TagVideoCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TagVideoPayload>
          }
          createMany: {
            args: Prisma.TagVideoCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          delete: {
            args: Prisma.TagVideoDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TagVideoPayload>
          }
          update: {
            args: Prisma.TagVideoUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TagVideoPayload>
          }
          deleteMany: {
            args: Prisma.TagVideoDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.TagVideoUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.TagVideoUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TagVideoPayload>
          }
          aggregate: {
            args: Prisma.TagVideoAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateTagVideo>
          }
          groupBy: {
            args: Prisma.TagVideoGroupByArgs<ExtArgs>
            result: $Utils.Optional<TagVideoGroupByOutputType>[]
          }
          count: {
            args: Prisma.TagVideoCountArgs<ExtArgs>
            result: $Utils.Optional<TagVideoCountAggregateOutputType> | 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
     * ```
     * // Defaults to stdout
     * log: ['query', 'info', 'warn', 'error']
     * 
     * // Emit as events
     * log: [
     *   { 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
    }
    /**
     * Global configuration for omitting model fields by default.
     * 
     * @example
     * ```
     * const prisma = new PrismaClient({
     *   omit: {
     *     user: {
     *       password: true
     *     }
     *   }
     * })
     * ```
     */
    omit?: Prisma.GlobalOmitConfig
  }
  export type GlobalOmitConfig = {
    utilisateur?: UtilisateurOmit
    formation?: FormationOmit
    video?: VideoOmit
    commande?: CommandeOmit
    commandeFormation?: CommandeFormationOmit
    achat?: AchatOmit
    tag?: TagOmit
    tagVideo?: TagVideoOmit
  }

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

  export type GetLogType<T extends LogLevel | LogDefinition> = T extends LogDefinition ? T['emit'] extends 'event' ? T['level'] : never : never
  export type GetEvents<T extends any> = T extends Array<LogLevel | LogDefinition> ?
    GetLogType<T[0]> | GetLogType<T[1]> | GetLogType<T[2]> | GetLogType<T[3]>
    : 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'

  /**
   * These options are being passed into the middleware as "params"
   */
  export type MiddlewareParams = {
    model?: ModelName
    action: PrismaAction
    args: any
    dataPath: string[]
    runInTransaction: boolean
  }

  /**
   * The `T` type makes sure, that the `return proceed` is not forgotten in the middleware implementation
   */
  export type Middleware<T = any> = (
    params: MiddlewareParams,
    next: (params: MiddlewareParams) => $Utils.JsPromise<T>,
  ) => $Utils.JsPromise<T>

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

  export type UtilisateurCountOutputType = {
    commande: number
    achat: number
  }

  export type UtilisateurCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    commande?: boolean | UtilisateurCountOutputTypeCountCommandeArgs
    achat?: boolean | UtilisateurCountOutputTypeCountAchatArgs
  }

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

  /**
   * UtilisateurCountOutputType without action
   */
  export type UtilisateurCountOutputTypeCountCommandeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: CommandeWhereInput
  }

  /**
   * UtilisateurCountOutputType without action
   */
  export type UtilisateurCountOutputTypeCountAchatArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: AchatWhereInput
  }


  /**
   * Count Type FormationCountOutputType
   */

  export type FormationCountOutputType = {
    fo_video: number
    commandeFormation: number
    achat: number
  }

  export type FormationCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    fo_video?: boolean | FormationCountOutputTypeCountFo_videoArgs
    commandeFormation?: boolean | FormationCountOutputTypeCountCommandeFormationArgs
    achat?: boolean | FormationCountOutputTypeCountAchatArgs
  }

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

  /**
   * FormationCountOutputType without action
   */
  export type FormationCountOutputTypeCountFo_videoArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: VideoWhereInput
  }

  /**
   * FormationCountOutputType without action
   */
  export type FormationCountOutputTypeCountCommandeFormationArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: CommandeFormationWhereInput
  }

  /**
   * FormationCountOutputType without action
   */
  export type FormationCountOutputTypeCountAchatArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: AchatWhereInput
  }


  /**
   * Count Type VideoCountOutputType
   */

  export type VideoCountOutputType = {
    vi_tv: number
  }

  export type VideoCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    vi_tv?: boolean | VideoCountOutputTypeCountVi_tvArgs
  }

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

  /**
   * VideoCountOutputType without action
   */
  export type VideoCountOutputTypeCountVi_tvArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: TagVideoWhereInput
  }


  /**
   * Count Type TagCountOutputType
   */

  export type TagCountOutputType = {
    vi_tv: number
  }

  export type TagCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    vi_tv?: boolean | TagCountOutputTypeCountVi_tvArgs
  }

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

  /**
   * TagCountOutputType without action
   */
  export type TagCountOutputTypeCountVi_tvArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: TagVideoWhereInput
  }


  /**
   * Models
   */

  /**
   * Model Utilisateur
   */

  export type AggregateUtilisateur = {
    _count: UtilisateurCountAggregateOutputType | null
    _avg: UtilisateurAvgAggregateOutputType | null
    _sum: UtilisateurSumAggregateOutputType | null
    _min: UtilisateurMinAggregateOutputType | null
    _max: UtilisateurMaxAggregateOutputType | null
  }

  export type UtilisateurAvgAggregateOutputType = {
    ut_id: number | null
    ut_type_cliente: number | null
    ut_nb_rdv: number | null
    ut_nb_rdv_honores: number | null
    ut_prix_moyen: number | null
    ut_pdp: number | null
    ut_panier: number | null
    ut_mdp: number | null
    ut_telephone: number | null
  }

  export type UtilisateurSumAggregateOutputType = {
    ut_id: number | null
    ut_type_cliente: number | null
    ut_nb_rdv: number | null
    ut_nb_rdv_honores: number | null
    ut_prix_moyen: number | null
    ut_pdp: number | null
    ut_panier: number | null
    ut_mdp: number | null
    ut_telephone: number | null
  }

  export type UtilisateurMinAggregateOutputType = {
    ut_id: number | null
    ut_nom: string | null
    ut_prenom: string | null
    ut_mail: string | null
    ut_type_cliente: number | null
    ut_age: Date | null
    ut_nb_rdv: number | null
    ut_nb_rdv_honores: number | null
    ut_prix_moyen: number | null
    ut_pdp: number | null
    ut_panier: number | null
    ut_mdp: number | null
    ut_telephone: number | null
    ut_date_inscription: Date | null
    ut_derniere_connexion: Date | null
  }

  export type UtilisateurMaxAggregateOutputType = {
    ut_id: number | null
    ut_nom: string | null
    ut_prenom: string | null
    ut_mail: string | null
    ut_type_cliente: number | null
    ut_age: Date | null
    ut_nb_rdv: number | null
    ut_nb_rdv_honores: number | null
    ut_prix_moyen: number | null
    ut_pdp: number | null
    ut_panier: number | null
    ut_mdp: number | null
    ut_telephone: number | null
    ut_date_inscription: Date | null
    ut_derniere_connexion: Date | null
  }

  export type UtilisateurCountAggregateOutputType = {
    ut_id: number
    ut_nom: number
    ut_prenom: number
    ut_mail: number
    ut_type_cliente: number
    ut_age: number
    ut_nb_rdv: number
    ut_nb_rdv_honores: number
    ut_prix_moyen: number
    ut_pdp: number
    ut_panier: number
    ut_mdp: number
    ut_telephone: number
    ut_date_inscription: number
    ut_derniere_connexion: number
    _all: number
  }


  export type UtilisateurAvgAggregateInputType = {
    ut_id?: true
    ut_type_cliente?: true
    ut_nb_rdv?: true
    ut_nb_rdv_honores?: true
    ut_prix_moyen?: true
    ut_pdp?: true
    ut_panier?: true
    ut_mdp?: true
    ut_telephone?: true
  }

  export type UtilisateurSumAggregateInputType = {
    ut_id?: true
    ut_type_cliente?: true
    ut_nb_rdv?: true
    ut_nb_rdv_honores?: true
    ut_prix_moyen?: true
    ut_pdp?: true
    ut_panier?: true
    ut_mdp?: true
    ut_telephone?: true
  }

  export type UtilisateurMinAggregateInputType = {
    ut_id?: true
    ut_nom?: true
    ut_prenom?: true
    ut_mail?: true
    ut_type_cliente?: true
    ut_age?: true
    ut_nb_rdv?: true
    ut_nb_rdv_honores?: true
    ut_prix_moyen?: true
    ut_pdp?: true
    ut_panier?: true
    ut_mdp?: true
    ut_telephone?: true
    ut_date_inscription?: true
    ut_derniere_connexion?: true
  }

  export type UtilisateurMaxAggregateInputType = {
    ut_id?: true
    ut_nom?: true
    ut_prenom?: true
    ut_mail?: true
    ut_type_cliente?: true
    ut_age?: true
    ut_nb_rdv?: true
    ut_nb_rdv_honores?: true
    ut_prix_moyen?: true
    ut_pdp?: true
    ut_panier?: true
    ut_mdp?: true
    ut_telephone?: true
    ut_date_inscription?: true
    ut_derniere_connexion?: true
  }

  export type UtilisateurCountAggregateInputType = {
    ut_id?: true
    ut_nom?: true
    ut_prenom?: true
    ut_mail?: true
    ut_type_cliente?: true
    ut_age?: true
    ut_nb_rdv?: true
    ut_nb_rdv_honores?: true
    ut_prix_moyen?: true
    ut_pdp?: true
    ut_panier?: true
    ut_mdp?: true
    ut_telephone?: true
    ut_date_inscription?: true
    ut_derniere_connexion?: true
    _all?: true
  }

  export type UtilisateurAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Utilisateur to aggregate.
     */
    where?: UtilisateurWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Utilisateurs to fetch.
     */
    orderBy?: UtilisateurOrderByWithRelationInput | UtilisateurOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: UtilisateurWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Utilisateurs 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` Utilisateurs.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned Utilisateurs
    **/
    _count?: true | UtilisateurCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: UtilisateurAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: UtilisateurSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: UtilisateurMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: UtilisateurMaxAggregateInputType
  }

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




  export type UtilisateurGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: UtilisateurWhereInput
    orderBy?: UtilisateurOrderByWithAggregationInput | UtilisateurOrderByWithAggregationInput[]
    by: UtilisateurScalarFieldEnum[] | UtilisateurScalarFieldEnum
    having?: UtilisateurScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: UtilisateurCountAggregateInputType | true
    _avg?: UtilisateurAvgAggregateInputType
    _sum?: UtilisateurSumAggregateInputType
    _min?: UtilisateurMinAggregateInputType
    _max?: UtilisateurMaxAggregateInputType
  }

  export type UtilisateurGroupByOutputType = {
    ut_id: number
    ut_nom: string | null
    ut_prenom: string | null
    ut_mail: string | null
    ut_type_cliente: number | null
    ut_age: Date | null
    ut_nb_rdv: number | null
    ut_nb_rdv_honores: number | null
    ut_prix_moyen: number | null
    ut_pdp: number | null
    ut_panier: number | null
    ut_mdp: number | null
    ut_telephone: number | null
    ut_date_inscription: Date
    ut_derniere_connexion: Date | null
    _count: UtilisateurCountAggregateOutputType | null
    _avg: UtilisateurAvgAggregateOutputType | null
    _sum: UtilisateurSumAggregateOutputType | null
    _min: UtilisateurMinAggregateOutputType | null
    _max: UtilisateurMaxAggregateOutputType | null
  }

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


  export type UtilisateurSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    ut_id?: boolean
    ut_nom?: boolean
    ut_prenom?: boolean
    ut_mail?: boolean
    ut_type_cliente?: boolean
    ut_age?: boolean
    ut_nb_rdv?: boolean
    ut_nb_rdv_honores?: boolean
    ut_prix_moyen?: boolean
    ut_pdp?: boolean
    ut_panier?: boolean
    ut_mdp?: boolean
    ut_telephone?: boolean
    ut_date_inscription?: boolean
    ut_derniere_connexion?: boolean
    commande?: boolean | Utilisateur$commandeArgs<ExtArgs>
    achat?: boolean | Utilisateur$achatArgs<ExtArgs>
    _count?: boolean | UtilisateurCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["utilisateur"]>



  export type UtilisateurSelectScalar = {
    ut_id?: boolean
    ut_nom?: boolean
    ut_prenom?: boolean
    ut_mail?: boolean
    ut_type_cliente?: boolean
    ut_age?: boolean
    ut_nb_rdv?: boolean
    ut_nb_rdv_honores?: boolean
    ut_prix_moyen?: boolean
    ut_pdp?: boolean
    ut_panier?: boolean
    ut_mdp?: boolean
    ut_telephone?: boolean
    ut_date_inscription?: boolean
    ut_derniere_connexion?: boolean
  }

  export type UtilisateurOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"ut_id" | "ut_nom" | "ut_prenom" | "ut_mail" | "ut_type_cliente" | "ut_age" | "ut_nb_rdv" | "ut_nb_rdv_honores" | "ut_prix_moyen" | "ut_pdp" | "ut_panier" | "ut_mdp" | "ut_telephone" | "ut_date_inscription" | "ut_derniere_connexion", ExtArgs["result"]["utilisateur"]>
  export type UtilisateurInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    commande?: boolean | Utilisateur$commandeArgs<ExtArgs>
    achat?: boolean | Utilisateur$achatArgs<ExtArgs>
    _count?: boolean | UtilisateurCountOutputTypeDefaultArgs<ExtArgs>
  }

  export type $UtilisateurPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Utilisateur"
    objects: {
      commande: Prisma.$CommandePayload<ExtArgs>[]
      achat: Prisma.$AchatPayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      ut_id: number
      ut_nom: string | null
      ut_prenom: string | null
      ut_mail: string | null
      ut_type_cliente: number | null
      ut_age: Date | null
      ut_nb_rdv: number | null
      ut_nb_rdv_honores: number | null
      ut_prix_moyen: number | null
      ut_pdp: number | null
      ut_panier: number | null
      ut_mdp: number | null
      ut_telephone: number | null
      ut_date_inscription: Date
      ut_derniere_connexion: Date | null
    }, ExtArgs["result"]["utilisateur"]>
    composites: {}
  }

  type UtilisateurGetPayload<S extends boolean | null | undefined | UtilisateurDefaultArgs> = $Result.GetResult<Prisma.$UtilisateurPayload, S>

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

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

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

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

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

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

    /**
     * Create a Utilisateur.
     * @param {UtilisateurCreateArgs} args - Arguments to create a Utilisateur.
     * @example
     * // Create one Utilisateur
     * const Utilisateur = await prisma.utilisateur.create({
     *   data: {
     *     // ... data to create a Utilisateur
     *   }
     * })
     * 
     */
    create<T extends UtilisateurCreateArgs>(args: SelectSubset<T, UtilisateurCreateArgs<ExtArgs>>): Prisma__UtilisateurClient<$Result.GetResult<Prisma.$UtilisateurPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

    /**
     * Delete a Utilisateur.
     * @param {UtilisateurDeleteArgs} args - Arguments to delete one Utilisateur.
     * @example
     * // Delete one Utilisateur
     * const Utilisateur = await prisma.utilisateur.delete({
     *   where: {
     *     // ... filter to delete one Utilisateur
     *   }
     * })
     * 
     */
    delete<T extends UtilisateurDeleteArgs>(args: SelectSubset<T, UtilisateurDeleteArgs<ExtArgs>>): Prisma__UtilisateurClient<$Result.GetResult<Prisma.$UtilisateurPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

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

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for Utilisateur.
   * 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__UtilisateurClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    commande<T extends Utilisateur$commandeArgs<ExtArgs> = {}>(args?: Subset<T, Utilisateur$commandeArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$CommandePayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    achat<T extends Utilisateur$achatArgs<ExtArgs> = {}>(args?: Subset<T, Utilisateur$achatArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$AchatPayload<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 Utilisateur model
   */
  interface UtilisateurFieldRefs {
    readonly ut_id: FieldRef<"Utilisateur", 'Int'>
    readonly ut_nom: FieldRef<"Utilisateur", 'String'>
    readonly ut_prenom: FieldRef<"Utilisateur", 'String'>
    readonly ut_mail: FieldRef<"Utilisateur", 'String'>
    readonly ut_type_cliente: FieldRef<"Utilisateur", 'Int'>
    readonly ut_age: FieldRef<"Utilisateur", 'DateTime'>
    readonly ut_nb_rdv: FieldRef<"Utilisateur", 'Int'>
    readonly ut_nb_rdv_honores: FieldRef<"Utilisateur", 'Int'>
    readonly ut_prix_moyen: FieldRef<"Utilisateur", 'Int'>
    readonly ut_pdp: FieldRef<"Utilisateur", 'Int'>
    readonly ut_panier: FieldRef<"Utilisateur", 'Int'>
    readonly ut_mdp: FieldRef<"Utilisateur", 'Int'>
    readonly ut_telephone: FieldRef<"Utilisateur", 'Int'>
    readonly ut_date_inscription: FieldRef<"Utilisateur", 'DateTime'>
    readonly ut_derniere_connexion: FieldRef<"Utilisateur", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * Utilisateur findUnique
   */
  export type UtilisateurFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Utilisateur
     */
    select?: UtilisateurSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Utilisateur
     */
    omit?: UtilisateurOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UtilisateurInclude<ExtArgs> | null
    /**
     * Filter, which Utilisateur to fetch.
     */
    where: UtilisateurWhereUniqueInput
  }

  /**
   * Utilisateur findUniqueOrThrow
   */
  export type UtilisateurFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Utilisateur
     */
    select?: UtilisateurSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Utilisateur
     */
    omit?: UtilisateurOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UtilisateurInclude<ExtArgs> | null
    /**
     * Filter, which Utilisateur to fetch.
     */
    where: UtilisateurWhereUniqueInput
  }

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

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

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

  /**
   * Utilisateur create
   */
  export type UtilisateurCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Utilisateur
     */
    select?: UtilisateurSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Utilisateur
     */
    omit?: UtilisateurOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UtilisateurInclude<ExtArgs> | null
    /**
     * The data needed to create a Utilisateur.
     */
    data?: XOR<UtilisateurCreateInput, UtilisateurUncheckedCreateInput>
  }

  /**
   * Utilisateur createMany
   */
  export type UtilisateurCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many Utilisateurs.
     */
    data: UtilisateurCreateManyInput | UtilisateurCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * Utilisateur update
   */
  export type UtilisateurUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Utilisateur
     */
    select?: UtilisateurSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Utilisateur
     */
    omit?: UtilisateurOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UtilisateurInclude<ExtArgs> | null
    /**
     * The data needed to update a Utilisateur.
     */
    data: XOR<UtilisateurUpdateInput, UtilisateurUncheckedUpdateInput>
    /**
     * Choose, which Utilisateur to update.
     */
    where: UtilisateurWhereUniqueInput
  }

  /**
   * Utilisateur updateMany
   */
  export type UtilisateurUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Utilisateurs.
     */
    data: XOR<UtilisateurUpdateManyMutationInput, UtilisateurUncheckedUpdateManyInput>
    /**
     * Filter which Utilisateurs to update
     */
    where?: UtilisateurWhereInput
    /**
     * Limit how many Utilisateurs to update.
     */
    limit?: number
  }

  /**
   * Utilisateur upsert
   */
  export type UtilisateurUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Utilisateur
     */
    select?: UtilisateurSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Utilisateur
     */
    omit?: UtilisateurOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UtilisateurInclude<ExtArgs> | null
    /**
     * The filter to search for the Utilisateur to update in case it exists.
     */
    where: UtilisateurWhereUniqueInput
    /**
     * In case the Utilisateur found by the `where` argument doesn't exist, create a new Utilisateur with this data.
     */
    create: XOR<UtilisateurCreateInput, UtilisateurUncheckedCreateInput>
    /**
     * In case the Utilisateur was found with the provided `where` argument, update it with this data.
     */
    update: XOR<UtilisateurUpdateInput, UtilisateurUncheckedUpdateInput>
  }

  /**
   * Utilisateur delete
   */
  export type UtilisateurDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Utilisateur
     */
    select?: UtilisateurSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Utilisateur
     */
    omit?: UtilisateurOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UtilisateurInclude<ExtArgs> | null
    /**
     * Filter which Utilisateur to delete.
     */
    where: UtilisateurWhereUniqueInput
  }

  /**
   * Utilisateur deleteMany
   */
  export type UtilisateurDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Utilisateurs to delete
     */
    where?: UtilisateurWhereInput
    /**
     * Limit how many Utilisateurs to delete.
     */
    limit?: number
  }

  /**
   * Utilisateur.commande
   */
  export type Utilisateur$commandeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Commande
     */
    select?: CommandeSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Commande
     */
    omit?: CommandeOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CommandeInclude<ExtArgs> | null
    where?: CommandeWhereInput
    orderBy?: CommandeOrderByWithRelationInput | CommandeOrderByWithRelationInput[]
    cursor?: CommandeWhereUniqueInput
    take?: number
    skip?: number
    distinct?: CommandeScalarFieldEnum | CommandeScalarFieldEnum[]
  }

  /**
   * Utilisateur.achat
   */
  export type Utilisateur$achatArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Achat
     */
    select?: AchatSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Achat
     */
    omit?: AchatOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AchatInclude<ExtArgs> | null
    where?: AchatWhereInput
    orderBy?: AchatOrderByWithRelationInput | AchatOrderByWithRelationInput[]
    cursor?: AchatWhereUniqueInput
    take?: number
    skip?: number
    distinct?: AchatScalarFieldEnum | AchatScalarFieldEnum[]
  }

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


  /**
   * Model Formation
   */

  export type AggregateFormation = {
    _count: FormationCountAggregateOutputType | null
    _avg: FormationAvgAggregateOutputType | null
    _sum: FormationSumAggregateOutputType | null
    _min: FormationMinAggregateOutputType | null
    _max: FormationMaxAggregateOutputType | null
  }

  export type FormationAvgAggregateOutputType = {
    fo_id: number | null
  }

  export type FormationSumAggregateOutputType = {
    fo_id: number | null
  }

  export type FormationMinAggregateOutputType = {
    fo_id: number | null
    fo_titre: string | null
    fo_description: string | null
    fo_prix: string | null
    fo_miniature: Uint8Array | null
    fo_teaser: string | null
    fo_date_publication: Date | null
  }

  export type FormationMaxAggregateOutputType = {
    fo_id: number | null
    fo_titre: string | null
    fo_description: string | null
    fo_prix: string | null
    fo_miniature: Uint8Array | null
    fo_teaser: string | null
    fo_date_publication: Date | null
  }

  export type FormationCountAggregateOutputType = {
    fo_id: number
    fo_titre: number
    fo_description: number
    fo_prix: number
    fo_miniature: number
    fo_teaser: number
    fo_date_publication: number
    _all: number
  }


  export type FormationAvgAggregateInputType = {
    fo_id?: true
  }

  export type FormationSumAggregateInputType = {
    fo_id?: true
  }

  export type FormationMinAggregateInputType = {
    fo_id?: true
    fo_titre?: true
    fo_description?: true
    fo_prix?: true
    fo_miniature?: true
    fo_teaser?: true
    fo_date_publication?: true
  }

  export type FormationMaxAggregateInputType = {
    fo_id?: true
    fo_titre?: true
    fo_description?: true
    fo_prix?: true
    fo_miniature?: true
    fo_teaser?: true
    fo_date_publication?: true
  }

  export type FormationCountAggregateInputType = {
    fo_id?: true
    fo_titre?: true
    fo_description?: true
    fo_prix?: true
    fo_miniature?: true
    fo_teaser?: true
    fo_date_publication?: true
    _all?: true
  }

  export type FormationAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Formation to aggregate.
     */
    where?: FormationWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Formations to fetch.
     */
    orderBy?: FormationOrderByWithRelationInput | FormationOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: FormationWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Formations 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` Formations.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned Formations
    **/
    _count?: true | FormationCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: FormationAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: FormationSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: FormationMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: FormationMaxAggregateInputType
  }

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




  export type FormationGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: FormationWhereInput
    orderBy?: FormationOrderByWithAggregationInput | FormationOrderByWithAggregationInput[]
    by: FormationScalarFieldEnum[] | FormationScalarFieldEnum
    having?: FormationScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: FormationCountAggregateInputType | true
    _avg?: FormationAvgAggregateInputType
    _sum?: FormationSumAggregateInputType
    _min?: FormationMinAggregateInputType
    _max?: FormationMaxAggregateInputType
  }

  export type FormationGroupByOutputType = {
    fo_id: number
    fo_titre: string | null
    fo_description: string | null
    fo_prix: string | null
    fo_miniature: Uint8Array | null
    fo_teaser: string | null
    fo_date_publication: Date
    _count: FormationCountAggregateOutputType | null
    _avg: FormationAvgAggregateOutputType | null
    _sum: FormationSumAggregateOutputType | null
    _min: FormationMinAggregateOutputType | null
    _max: FormationMaxAggregateOutputType | null
  }

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


  export type FormationSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    fo_id?: boolean
    fo_titre?: boolean
    fo_description?: boolean
    fo_prix?: boolean
    fo_miniature?: boolean
    fo_teaser?: boolean
    fo_date_publication?: boolean
    fo_video?: boolean | Formation$fo_videoArgs<ExtArgs>
    commandeFormation?: boolean | Formation$commandeFormationArgs<ExtArgs>
    achat?: boolean | Formation$achatArgs<ExtArgs>
    _count?: boolean | FormationCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["formation"]>



  export type FormationSelectScalar = {
    fo_id?: boolean
    fo_titre?: boolean
    fo_description?: boolean
    fo_prix?: boolean
    fo_miniature?: boolean
    fo_teaser?: boolean
    fo_date_publication?: boolean
  }

  export type FormationOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"fo_id" | "fo_titre" | "fo_description" | "fo_prix" | "fo_miniature" | "fo_teaser" | "fo_date_publication", ExtArgs["result"]["formation"]>
  export type FormationInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    fo_video?: boolean | Formation$fo_videoArgs<ExtArgs>
    commandeFormation?: boolean | Formation$commandeFormationArgs<ExtArgs>
    achat?: boolean | Formation$achatArgs<ExtArgs>
    _count?: boolean | FormationCountOutputTypeDefaultArgs<ExtArgs>
  }

  export type $FormationPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Formation"
    objects: {
      fo_video: Prisma.$VideoPayload<ExtArgs>[]
      commandeFormation: Prisma.$CommandeFormationPayload<ExtArgs>[]
      achat: Prisma.$AchatPayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      fo_id: number
      fo_titre: string | null
      fo_description: string | null
      fo_prix: string | null
      fo_miniature: Uint8Array | null
      fo_teaser: string | null
      fo_date_publication: Date
    }, ExtArgs["result"]["formation"]>
    composites: {}
  }

  type FormationGetPayload<S extends boolean | null | undefined | FormationDefaultArgs> = $Result.GetResult<Prisma.$FormationPayload, S>

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

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

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

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

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

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

    /**
     * Create a Formation.
     * @param {FormationCreateArgs} args - Arguments to create a Formation.
     * @example
     * // Create one Formation
     * const Formation = await prisma.formation.create({
     *   data: {
     *     // ... data to create a Formation
     *   }
     * })
     * 
     */
    create<T extends FormationCreateArgs>(args: SelectSubset<T, FormationCreateArgs<ExtArgs>>): Prisma__FormationClient<$Result.GetResult<Prisma.$FormationPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

    /**
     * Delete a Formation.
     * @param {FormationDeleteArgs} args - Arguments to delete one Formation.
     * @example
     * // Delete one Formation
     * const Formation = await prisma.formation.delete({
     *   where: {
     *     // ... filter to delete one Formation
     *   }
     * })
     * 
     */
    delete<T extends FormationDeleteArgs>(args: SelectSubset<T, FormationDeleteArgs<ExtArgs>>): Prisma__FormationClient<$Result.GetResult<Prisma.$FormationPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

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

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for Formation.
   * 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__FormationClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    fo_video<T extends Formation$fo_videoArgs<ExtArgs> = {}>(args?: Subset<T, Formation$fo_videoArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$VideoPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    commandeFormation<T extends Formation$commandeFormationArgs<ExtArgs> = {}>(args?: Subset<T, Formation$commandeFormationArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$CommandeFormationPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    achat<T extends Formation$achatArgs<ExtArgs> = {}>(args?: Subset<T, Formation$achatArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$AchatPayload<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 Formation model
   */
  interface FormationFieldRefs {
    readonly fo_id: FieldRef<"Formation", 'Int'>
    readonly fo_titre: FieldRef<"Formation", 'String'>
    readonly fo_description: FieldRef<"Formation", 'String'>
    readonly fo_prix: FieldRef<"Formation", 'String'>
    readonly fo_miniature: FieldRef<"Formation", 'Bytes'>
    readonly fo_teaser: FieldRef<"Formation", 'String'>
    readonly fo_date_publication: FieldRef<"Formation", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * Formation findUnique
   */
  export type FormationFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Formation
     */
    select?: FormationSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Formation
     */
    omit?: FormationOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: FormationInclude<ExtArgs> | null
    /**
     * Filter, which Formation to fetch.
     */
    where: FormationWhereUniqueInput
  }

  /**
   * Formation findUniqueOrThrow
   */
  export type FormationFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Formation
     */
    select?: FormationSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Formation
     */
    omit?: FormationOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: FormationInclude<ExtArgs> | null
    /**
     * Filter, which Formation to fetch.
     */
    where: FormationWhereUniqueInput
  }

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

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

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

  /**
   * Formation create
   */
  export type FormationCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Formation
     */
    select?: FormationSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Formation
     */
    omit?: FormationOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: FormationInclude<ExtArgs> | null
    /**
     * The data needed to create a Formation.
     */
    data?: XOR<FormationCreateInput, FormationUncheckedCreateInput>
  }

  /**
   * Formation createMany
   */
  export type FormationCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many Formations.
     */
    data: FormationCreateManyInput | FormationCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * Formation update
   */
  export type FormationUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Formation
     */
    select?: FormationSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Formation
     */
    omit?: FormationOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: FormationInclude<ExtArgs> | null
    /**
     * The data needed to update a Formation.
     */
    data: XOR<FormationUpdateInput, FormationUncheckedUpdateInput>
    /**
     * Choose, which Formation to update.
     */
    where: FormationWhereUniqueInput
  }

  /**
   * Formation updateMany
   */
  export type FormationUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Formations.
     */
    data: XOR<FormationUpdateManyMutationInput, FormationUncheckedUpdateManyInput>
    /**
     * Filter which Formations to update
     */
    where?: FormationWhereInput
    /**
     * Limit how many Formations to update.
     */
    limit?: number
  }

  /**
   * Formation upsert
   */
  export type FormationUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Formation
     */
    select?: FormationSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Formation
     */
    omit?: FormationOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: FormationInclude<ExtArgs> | null
    /**
     * The filter to search for the Formation to update in case it exists.
     */
    where: FormationWhereUniqueInput
    /**
     * In case the Formation found by the `where` argument doesn't exist, create a new Formation with this data.
     */
    create: XOR<FormationCreateInput, FormationUncheckedCreateInput>
    /**
     * In case the Formation was found with the provided `where` argument, update it with this data.
     */
    update: XOR<FormationUpdateInput, FormationUncheckedUpdateInput>
  }

  /**
   * Formation delete
   */
  export type FormationDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Formation
     */
    select?: FormationSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Formation
     */
    omit?: FormationOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: FormationInclude<ExtArgs> | null
    /**
     * Filter which Formation to delete.
     */
    where: FormationWhereUniqueInput
  }

  /**
   * Formation deleteMany
   */
  export type FormationDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Formations to delete
     */
    where?: FormationWhereInput
    /**
     * Limit how many Formations to delete.
     */
    limit?: number
  }

  /**
   * Formation.fo_video
   */
  export type Formation$fo_videoArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Video
     */
    select?: VideoSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Video
     */
    omit?: VideoOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: VideoInclude<ExtArgs> | null
    where?: VideoWhereInput
    orderBy?: VideoOrderByWithRelationInput | VideoOrderByWithRelationInput[]
    cursor?: VideoWhereUniqueInput
    take?: number
    skip?: number
    distinct?: VideoScalarFieldEnum | VideoScalarFieldEnum[]
  }

  /**
   * Formation.commandeFormation
   */
  export type Formation$commandeFormationArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CommandeFormation
     */
    select?: CommandeFormationSelect<ExtArgs> | null
    /**
     * Omit specific fields from the CommandeFormation
     */
    omit?: CommandeFormationOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CommandeFormationInclude<ExtArgs> | null
    where?: CommandeFormationWhereInput
    orderBy?: CommandeFormationOrderByWithRelationInput | CommandeFormationOrderByWithRelationInput[]
    cursor?: CommandeFormationWhereUniqueInput
    take?: number
    skip?: number
    distinct?: CommandeFormationScalarFieldEnum | CommandeFormationScalarFieldEnum[]
  }

  /**
   * Formation.achat
   */
  export type Formation$achatArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Achat
     */
    select?: AchatSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Achat
     */
    omit?: AchatOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AchatInclude<ExtArgs> | null
    where?: AchatWhereInput
    orderBy?: AchatOrderByWithRelationInput | AchatOrderByWithRelationInput[]
    cursor?: AchatWhereUniqueInput
    take?: number
    skip?: number
    distinct?: AchatScalarFieldEnum | AchatScalarFieldEnum[]
  }

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


  /**
   * Model Video
   */

  export type AggregateVideo = {
    _count: VideoCountAggregateOutputType | null
    _avg: VideoAvgAggregateOutputType | null
    _sum: VideoSumAggregateOutputType | null
    _min: VideoMinAggregateOutputType | null
    _max: VideoMaxAggregateOutputType | null
  }

  export type VideoAvgAggregateOutputType = {
    vi_fo_id: number | null
    vi_id: number | null
    vi_etape: number | null
  }

  export type VideoSumAggregateOutputType = {
    vi_fo_id: number | null
    vi_id: number | null
    vi_etape: number | null
  }

  export type VideoMinAggregateOutputType = {
    vi_fo_id: number | null
    vi_id: number | null
    vi_titre: string | null
    vi_description: string | null
    vi_etape: number | null
    vi_url: string | null
  }

  export type VideoMaxAggregateOutputType = {
    vi_fo_id: number | null
    vi_id: number | null
    vi_titre: string | null
    vi_description: string | null
    vi_etape: number | null
    vi_url: string | null
  }

  export type VideoCountAggregateOutputType = {
    vi_fo_id: number
    vi_id: number
    vi_titre: number
    vi_description: number
    vi_etape: number
    vi_url: number
    _all: number
  }


  export type VideoAvgAggregateInputType = {
    vi_fo_id?: true
    vi_id?: true
    vi_etape?: true
  }

  export type VideoSumAggregateInputType = {
    vi_fo_id?: true
    vi_id?: true
    vi_etape?: true
  }

  export type VideoMinAggregateInputType = {
    vi_fo_id?: true
    vi_id?: true
    vi_titre?: true
    vi_description?: true
    vi_etape?: true
    vi_url?: true
  }

  export type VideoMaxAggregateInputType = {
    vi_fo_id?: true
    vi_id?: true
    vi_titre?: true
    vi_description?: true
    vi_etape?: true
    vi_url?: true
  }

  export type VideoCountAggregateInputType = {
    vi_fo_id?: true
    vi_id?: true
    vi_titre?: true
    vi_description?: true
    vi_etape?: true
    vi_url?: true
    _all?: true
  }

  export type VideoAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Video to aggregate.
     */
    where?: VideoWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Videos to fetch.
     */
    orderBy?: VideoOrderByWithRelationInput | VideoOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: VideoWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Videos 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` Videos.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned Videos
    **/
    _count?: true | VideoCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: VideoAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: VideoSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: VideoMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: VideoMaxAggregateInputType
  }

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




  export type VideoGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: VideoWhereInput
    orderBy?: VideoOrderByWithAggregationInput | VideoOrderByWithAggregationInput[]
    by: VideoScalarFieldEnum[] | VideoScalarFieldEnum
    having?: VideoScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: VideoCountAggregateInputType | true
    _avg?: VideoAvgAggregateInputType
    _sum?: VideoSumAggregateInputType
    _min?: VideoMinAggregateInputType
    _max?: VideoMaxAggregateInputType
  }

  export type VideoGroupByOutputType = {
    vi_fo_id: number
    vi_id: number
    vi_titre: string | null
    vi_description: string | null
    vi_etape: number | null
    vi_url: string | null
    _count: VideoCountAggregateOutputType | null
    _avg: VideoAvgAggregateOutputType | null
    _sum: VideoSumAggregateOutputType | null
    _min: VideoMinAggregateOutputType | null
    _max: VideoMaxAggregateOutputType | null
  }

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


  export type VideoSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    vi_fo_id?: boolean
    vi_id?: boolean
    vi_titre?: boolean
    vi_description?: boolean
    vi_etape?: boolean
    vi_url?: boolean
    formation?: boolean | FormationDefaultArgs<ExtArgs>
    vi_tv?: boolean | Video$vi_tvArgs<ExtArgs>
    _count?: boolean | VideoCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["video"]>



  export type VideoSelectScalar = {
    vi_fo_id?: boolean
    vi_id?: boolean
    vi_titre?: boolean
    vi_description?: boolean
    vi_etape?: boolean
    vi_url?: boolean
  }

  export type VideoOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"vi_fo_id" | "vi_id" | "vi_titre" | "vi_description" | "vi_etape" | "vi_url", ExtArgs["result"]["video"]>
  export type VideoInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    formation?: boolean | FormationDefaultArgs<ExtArgs>
    vi_tv?: boolean | Video$vi_tvArgs<ExtArgs>
    _count?: boolean | VideoCountOutputTypeDefaultArgs<ExtArgs>
  }

  export type $VideoPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Video"
    objects: {
      formation: Prisma.$FormationPayload<ExtArgs>
      vi_tv: Prisma.$TagVideoPayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      vi_fo_id: number
      vi_id: number
      vi_titre: string | null
      vi_description: string | null
      vi_etape: number | null
      vi_url: string | null
    }, ExtArgs["result"]["video"]>
    composites: {}
  }

  type VideoGetPayload<S extends boolean | null | undefined | VideoDefaultArgs> = $Result.GetResult<Prisma.$VideoPayload, S>

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

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

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

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

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

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

    /**
     * Create a Video.
     * @param {VideoCreateArgs} args - Arguments to create a Video.
     * @example
     * // Create one Video
     * const Video = await prisma.video.create({
     *   data: {
     *     // ... data to create a Video
     *   }
     * })
     * 
     */
    create<T extends VideoCreateArgs>(args: SelectSubset<T, VideoCreateArgs<ExtArgs>>): Prisma__VideoClient<$Result.GetResult<Prisma.$VideoPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

    /**
     * Delete a Video.
     * @param {VideoDeleteArgs} args - Arguments to delete one Video.
     * @example
     * // Delete one Video
     * const Video = await prisma.video.delete({
     *   where: {
     *     // ... filter to delete one Video
     *   }
     * })
     * 
     */
    delete<T extends VideoDeleteArgs>(args: SelectSubset<T, VideoDeleteArgs<ExtArgs>>): Prisma__VideoClient<$Result.GetResult<Prisma.$VideoPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

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

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for Video.
   * 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__VideoClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    formation<T extends FormationDefaultArgs<ExtArgs> = {}>(args?: Subset<T, FormationDefaultArgs<ExtArgs>>): Prisma__FormationClient<$Result.GetResult<Prisma.$FormationPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
    vi_tv<T extends Video$vi_tvArgs<ExtArgs> = {}>(args?: Subset<T, Video$vi_tvArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$TagVideoPayload<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 Video model
   */
  interface VideoFieldRefs {
    readonly vi_fo_id: FieldRef<"Video", 'Int'>
    readonly vi_id: FieldRef<"Video", 'Int'>
    readonly vi_titre: FieldRef<"Video", 'String'>
    readonly vi_description: FieldRef<"Video", 'String'>
    readonly vi_etape: FieldRef<"Video", 'Int'>
    readonly vi_url: FieldRef<"Video", 'String'>
  }
    

  // Custom InputTypes
  /**
   * Video findUnique
   */
  export type VideoFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Video
     */
    select?: VideoSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Video
     */
    omit?: VideoOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: VideoInclude<ExtArgs> | null
    /**
     * Filter, which Video to fetch.
     */
    where: VideoWhereUniqueInput
  }

  /**
   * Video findUniqueOrThrow
   */
  export type VideoFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Video
     */
    select?: VideoSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Video
     */
    omit?: VideoOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: VideoInclude<ExtArgs> | null
    /**
     * Filter, which Video to fetch.
     */
    where: VideoWhereUniqueInput
  }

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

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

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

  /**
   * Video create
   */
  export type VideoCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Video
     */
    select?: VideoSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Video
     */
    omit?: VideoOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: VideoInclude<ExtArgs> | null
    /**
     * The data needed to create a Video.
     */
    data: XOR<VideoCreateInput, VideoUncheckedCreateInput>
  }

  /**
   * Video createMany
   */
  export type VideoCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many Videos.
     */
    data: VideoCreateManyInput | VideoCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * Video update
   */
  export type VideoUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Video
     */
    select?: VideoSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Video
     */
    omit?: VideoOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: VideoInclude<ExtArgs> | null
    /**
     * The data needed to update a Video.
     */
    data: XOR<VideoUpdateInput, VideoUncheckedUpdateInput>
    /**
     * Choose, which Video to update.
     */
    where: VideoWhereUniqueInput
  }

  /**
   * Video updateMany
   */
  export type VideoUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Videos.
     */
    data: XOR<VideoUpdateManyMutationInput, VideoUncheckedUpdateManyInput>
    /**
     * Filter which Videos to update
     */
    where?: VideoWhereInput
    /**
     * Limit how many Videos to update.
     */
    limit?: number
  }

  /**
   * Video upsert
   */
  export type VideoUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Video
     */
    select?: VideoSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Video
     */
    omit?: VideoOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: VideoInclude<ExtArgs> | null
    /**
     * The filter to search for the Video to update in case it exists.
     */
    where: VideoWhereUniqueInput
    /**
     * In case the Video found by the `where` argument doesn't exist, create a new Video with this data.
     */
    create: XOR<VideoCreateInput, VideoUncheckedCreateInput>
    /**
     * In case the Video was found with the provided `where` argument, update it with this data.
     */
    update: XOR<VideoUpdateInput, VideoUncheckedUpdateInput>
  }

  /**
   * Video delete
   */
  export type VideoDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Video
     */
    select?: VideoSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Video
     */
    omit?: VideoOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: VideoInclude<ExtArgs> | null
    /**
     * Filter which Video to delete.
     */
    where: VideoWhereUniqueInput
  }

  /**
   * Video deleteMany
   */
  export type VideoDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Videos to delete
     */
    where?: VideoWhereInput
    /**
     * Limit how many Videos to delete.
     */
    limit?: number
  }

  /**
   * Video.vi_tv
   */
  export type Video$vi_tvArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TagVideo
     */
    select?: TagVideoSelect<ExtArgs> | null
    /**
     * Omit specific fields from the TagVideo
     */
    omit?: TagVideoOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TagVideoInclude<ExtArgs> | null
    where?: TagVideoWhereInput
    orderBy?: TagVideoOrderByWithRelationInput | TagVideoOrderByWithRelationInput[]
    cursor?: TagVideoWhereUniqueInput
    take?: number
    skip?: number
    distinct?: TagVideoScalarFieldEnum | TagVideoScalarFieldEnum[]
  }

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


  /**
   * Model Commande
   */

  export type AggregateCommande = {
    _count: CommandeCountAggregateOutputType | null
    _avg: CommandeAvgAggregateOutputType | null
    _sum: CommandeSumAggregateOutputType | null
    _min: CommandeMinAggregateOutputType | null
    _max: CommandeMaxAggregateOutputType | null
  }

  export type CommandeAvgAggregateOutputType = {
    co_id: number | null
    co_utilisateur: number | null
  }

  export type CommandeSumAggregateOutputType = {
    co_id: number | null
    co_utilisateur: number | null
  }

  export type CommandeMinAggregateOutputType = {
    co_id: number | null
    co_utilisateur: number | null
    co_date_creation: Date | null
    co_date_update: Date | null
    co_status: string | null
  }

  export type CommandeMaxAggregateOutputType = {
    co_id: number | null
    co_utilisateur: number | null
    co_date_creation: Date | null
    co_date_update: Date | null
    co_status: string | null
  }

  export type CommandeCountAggregateOutputType = {
    co_id: number
    co_utilisateur: number
    co_date_creation: number
    co_date_update: number
    co_status: number
    _all: number
  }


  export type CommandeAvgAggregateInputType = {
    co_id?: true
    co_utilisateur?: true
  }

  export type CommandeSumAggregateInputType = {
    co_id?: true
    co_utilisateur?: true
  }

  export type CommandeMinAggregateInputType = {
    co_id?: true
    co_utilisateur?: true
    co_date_creation?: true
    co_date_update?: true
    co_status?: true
  }

  export type CommandeMaxAggregateInputType = {
    co_id?: true
    co_utilisateur?: true
    co_date_creation?: true
    co_date_update?: true
    co_status?: true
  }

  export type CommandeCountAggregateInputType = {
    co_id?: true
    co_utilisateur?: true
    co_date_creation?: true
    co_date_update?: true
    co_status?: true
    _all?: true
  }

  export type CommandeAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Commande to aggregate.
     */
    where?: CommandeWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Commandes to fetch.
     */
    orderBy?: CommandeOrderByWithRelationInput | CommandeOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: CommandeWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Commandes 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` Commandes.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned Commandes
    **/
    _count?: true | CommandeCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: CommandeAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: CommandeSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: CommandeMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: CommandeMaxAggregateInputType
  }

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




  export type CommandeGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: CommandeWhereInput
    orderBy?: CommandeOrderByWithAggregationInput | CommandeOrderByWithAggregationInput[]
    by: CommandeScalarFieldEnum[] | CommandeScalarFieldEnum
    having?: CommandeScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: CommandeCountAggregateInputType | true
    _avg?: CommandeAvgAggregateInputType
    _sum?: CommandeSumAggregateInputType
    _min?: CommandeMinAggregateInputType
    _max?: CommandeMaxAggregateInputType
  }

  export type CommandeGroupByOutputType = {
    co_id: number
    co_utilisateur: number
    co_date_creation: Date
    co_date_update: Date | null
    co_status: string
    _count: CommandeCountAggregateOutputType | null
    _avg: CommandeAvgAggregateOutputType | null
    _sum: CommandeSumAggregateOutputType | null
    _min: CommandeMinAggregateOutputType | null
    _max: CommandeMaxAggregateOutputType | null
  }

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


  export type CommandeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    co_id?: boolean
    co_utilisateur?: boolean
    co_date_creation?: boolean
    co_date_update?: boolean
    co_status?: boolean
    utilisateur?: boolean | UtilisateurDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["commande"]>



  export type CommandeSelectScalar = {
    co_id?: boolean
    co_utilisateur?: boolean
    co_date_creation?: boolean
    co_date_update?: boolean
    co_status?: boolean
  }

  export type CommandeOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"co_id" | "co_utilisateur" | "co_date_creation" | "co_date_update" | "co_status", ExtArgs["result"]["commande"]>
  export type CommandeInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    utilisateur?: boolean | UtilisateurDefaultArgs<ExtArgs>
  }

  export type $CommandePayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Commande"
    objects: {
      utilisateur: Prisma.$UtilisateurPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      co_id: number
      co_utilisateur: number
      co_date_creation: Date
      co_date_update: Date | null
      co_status: string
    }, ExtArgs["result"]["commande"]>
    composites: {}
  }

  type CommandeGetPayload<S extends boolean | null | undefined | CommandeDefaultArgs> = $Result.GetResult<Prisma.$CommandePayload, S>

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

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

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

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

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

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

    /**
     * Create a Commande.
     * @param {CommandeCreateArgs} args - Arguments to create a Commande.
     * @example
     * // Create one Commande
     * const Commande = await prisma.commande.create({
     *   data: {
     *     // ... data to create a Commande
     *   }
     * })
     * 
     */
    create<T extends CommandeCreateArgs>(args: SelectSubset<T, CommandeCreateArgs<ExtArgs>>): Prisma__CommandeClient<$Result.GetResult<Prisma.$CommandePayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

    /**
     * Delete a Commande.
     * @param {CommandeDeleteArgs} args - Arguments to delete one Commande.
     * @example
     * // Delete one Commande
     * const Commande = await prisma.commande.delete({
     *   where: {
     *     // ... filter to delete one Commande
     *   }
     * })
     * 
     */
    delete<T extends CommandeDeleteArgs>(args: SelectSubset<T, CommandeDeleteArgs<ExtArgs>>): Prisma__CommandeClient<$Result.GetResult<Prisma.$CommandePayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

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

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for Commande.
   * 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__CommandeClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    utilisateur<T extends UtilisateurDefaultArgs<ExtArgs> = {}>(args?: Subset<T, UtilisateurDefaultArgs<ExtArgs>>): Prisma__UtilisateurClient<$Result.GetResult<Prisma.$UtilisateurPayload<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 Commande model
   */
  interface CommandeFieldRefs {
    readonly co_id: FieldRef<"Commande", 'Int'>
    readonly co_utilisateur: FieldRef<"Commande", 'Int'>
    readonly co_date_creation: FieldRef<"Commande", 'DateTime'>
    readonly co_date_update: FieldRef<"Commande", 'DateTime'>
    readonly co_status: FieldRef<"Commande", 'String'>
  }
    

  // Custom InputTypes
  /**
   * Commande findUnique
   */
  export type CommandeFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Commande
     */
    select?: CommandeSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Commande
     */
    omit?: CommandeOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CommandeInclude<ExtArgs> | null
    /**
     * Filter, which Commande to fetch.
     */
    where: CommandeWhereUniqueInput
  }

  /**
   * Commande findUniqueOrThrow
   */
  export type CommandeFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Commande
     */
    select?: CommandeSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Commande
     */
    omit?: CommandeOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CommandeInclude<ExtArgs> | null
    /**
     * Filter, which Commande to fetch.
     */
    where: CommandeWhereUniqueInput
  }

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

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

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

  /**
   * Commande create
   */
  export type CommandeCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Commande
     */
    select?: CommandeSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Commande
     */
    omit?: CommandeOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CommandeInclude<ExtArgs> | null
    /**
     * The data needed to create a Commande.
     */
    data: XOR<CommandeCreateInput, CommandeUncheckedCreateInput>
  }

  /**
   * Commande createMany
   */
  export type CommandeCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many Commandes.
     */
    data: CommandeCreateManyInput | CommandeCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * Commande update
   */
  export type CommandeUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Commande
     */
    select?: CommandeSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Commande
     */
    omit?: CommandeOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CommandeInclude<ExtArgs> | null
    /**
     * The data needed to update a Commande.
     */
    data: XOR<CommandeUpdateInput, CommandeUncheckedUpdateInput>
    /**
     * Choose, which Commande to update.
     */
    where: CommandeWhereUniqueInput
  }

  /**
   * Commande updateMany
   */
  export type CommandeUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Commandes.
     */
    data: XOR<CommandeUpdateManyMutationInput, CommandeUncheckedUpdateManyInput>
    /**
     * Filter which Commandes to update
     */
    where?: CommandeWhereInput
    /**
     * Limit how many Commandes to update.
     */
    limit?: number
  }

  /**
   * Commande upsert
   */
  export type CommandeUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Commande
     */
    select?: CommandeSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Commande
     */
    omit?: CommandeOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CommandeInclude<ExtArgs> | null
    /**
     * The filter to search for the Commande to update in case it exists.
     */
    where: CommandeWhereUniqueInput
    /**
     * In case the Commande found by the `where` argument doesn't exist, create a new Commande with this data.
     */
    create: XOR<CommandeCreateInput, CommandeUncheckedCreateInput>
    /**
     * In case the Commande was found with the provided `where` argument, update it with this data.
     */
    update: XOR<CommandeUpdateInput, CommandeUncheckedUpdateInput>
  }

  /**
   * Commande delete
   */
  export type CommandeDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Commande
     */
    select?: CommandeSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Commande
     */
    omit?: CommandeOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CommandeInclude<ExtArgs> | null
    /**
     * Filter which Commande to delete.
     */
    where: CommandeWhereUniqueInput
  }

  /**
   * Commande deleteMany
   */
  export type CommandeDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Commandes to delete
     */
    where?: CommandeWhereInput
    /**
     * Limit how many Commandes to delete.
     */
    limit?: number
  }

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


  /**
   * Model CommandeFormation
   */

  export type AggregateCommandeFormation = {
    _count: CommandeFormationCountAggregateOutputType | null
    _avg: CommandeFormationAvgAggregateOutputType | null
    _sum: CommandeFormationSumAggregateOutputType | null
    _min: CommandeFormationMinAggregateOutputType | null
    _max: CommandeFormationMaxAggregateOutputType | null
  }

  export type CommandeFormationAvgAggregateOutputType = {
    cof_id: number | null
    cof_formation: number | null
  }

  export type CommandeFormationSumAggregateOutputType = {
    cof_id: number | null
    cof_formation: number | null
  }

  export type CommandeFormationMinAggregateOutputType = {
    cof_id: number | null
    cof_formation: number | null
  }

  export type CommandeFormationMaxAggregateOutputType = {
    cof_id: number | null
    cof_formation: number | null
  }

  export type CommandeFormationCountAggregateOutputType = {
    cof_id: number
    cof_formation: number
    _all: number
  }


  export type CommandeFormationAvgAggregateInputType = {
    cof_id?: true
    cof_formation?: true
  }

  export type CommandeFormationSumAggregateInputType = {
    cof_id?: true
    cof_formation?: true
  }

  export type CommandeFormationMinAggregateInputType = {
    cof_id?: true
    cof_formation?: true
  }

  export type CommandeFormationMaxAggregateInputType = {
    cof_id?: true
    cof_formation?: true
  }

  export type CommandeFormationCountAggregateInputType = {
    cof_id?: true
    cof_formation?: true
    _all?: true
  }

  export type CommandeFormationAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which CommandeFormation to aggregate.
     */
    where?: CommandeFormationWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of CommandeFormations to fetch.
     */
    orderBy?: CommandeFormationOrderByWithRelationInput | CommandeFormationOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: CommandeFormationWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` CommandeFormations 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` CommandeFormations.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned CommandeFormations
    **/
    _count?: true | CommandeFormationCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: CommandeFormationAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: CommandeFormationSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: CommandeFormationMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: CommandeFormationMaxAggregateInputType
  }

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




  export type CommandeFormationGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: CommandeFormationWhereInput
    orderBy?: CommandeFormationOrderByWithAggregationInput | CommandeFormationOrderByWithAggregationInput[]
    by: CommandeFormationScalarFieldEnum[] | CommandeFormationScalarFieldEnum
    having?: CommandeFormationScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: CommandeFormationCountAggregateInputType | true
    _avg?: CommandeFormationAvgAggregateInputType
    _sum?: CommandeFormationSumAggregateInputType
    _min?: CommandeFormationMinAggregateInputType
    _max?: CommandeFormationMaxAggregateInputType
  }

  export type CommandeFormationGroupByOutputType = {
    cof_id: number
    cof_formation: number
    _count: CommandeFormationCountAggregateOutputType | null
    _avg: CommandeFormationAvgAggregateOutputType | null
    _sum: CommandeFormationSumAggregateOutputType | null
    _min: CommandeFormationMinAggregateOutputType | null
    _max: CommandeFormationMaxAggregateOutputType | null
  }

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


  export type CommandeFormationSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    cof_id?: boolean
    cof_formation?: boolean
    formation?: boolean | FormationDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["commandeFormation"]>



  export type CommandeFormationSelectScalar = {
    cof_id?: boolean
    cof_formation?: boolean
  }

  export type CommandeFormationOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"cof_id" | "cof_formation", ExtArgs["result"]["commandeFormation"]>
  export type CommandeFormationInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    formation?: boolean | FormationDefaultArgs<ExtArgs>
  }

  export type $CommandeFormationPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "CommandeFormation"
    objects: {
      formation: Prisma.$FormationPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      cof_id: number
      cof_formation: number
    }, ExtArgs["result"]["commandeFormation"]>
    composites: {}
  }

  type CommandeFormationGetPayload<S extends boolean | null | undefined | CommandeFormationDefaultArgs> = $Result.GetResult<Prisma.$CommandeFormationPayload, S>

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

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

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

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

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

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

    /**
     * Create a CommandeFormation.
     * @param {CommandeFormationCreateArgs} args - Arguments to create a CommandeFormation.
     * @example
     * // Create one CommandeFormation
     * const CommandeFormation = await prisma.commandeFormation.create({
     *   data: {
     *     // ... data to create a CommandeFormation
     *   }
     * })
     * 
     */
    create<T extends CommandeFormationCreateArgs>(args: SelectSubset<T, CommandeFormationCreateArgs<ExtArgs>>): Prisma__CommandeFormationClient<$Result.GetResult<Prisma.$CommandeFormationPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

    /**
     * Delete a CommandeFormation.
     * @param {CommandeFormationDeleteArgs} args - Arguments to delete one CommandeFormation.
     * @example
     * // Delete one CommandeFormation
     * const CommandeFormation = await prisma.commandeFormation.delete({
     *   where: {
     *     // ... filter to delete one CommandeFormation
     *   }
     * })
     * 
     */
    delete<T extends CommandeFormationDeleteArgs>(args: SelectSubset<T, CommandeFormationDeleteArgs<ExtArgs>>): Prisma__CommandeFormationClient<$Result.GetResult<Prisma.$CommandeFormationPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

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

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for CommandeFormation.
   * 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__CommandeFormationClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    formation<T extends FormationDefaultArgs<ExtArgs> = {}>(args?: Subset<T, FormationDefaultArgs<ExtArgs>>): Prisma__FormationClient<$Result.GetResult<Prisma.$FormationPayload<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 CommandeFormation model
   */
  interface CommandeFormationFieldRefs {
    readonly cof_id: FieldRef<"CommandeFormation", 'Int'>
    readonly cof_formation: FieldRef<"CommandeFormation", 'Int'>
  }
    

  // Custom InputTypes
  /**
   * CommandeFormation findUnique
   */
  export type CommandeFormationFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CommandeFormation
     */
    select?: CommandeFormationSelect<ExtArgs> | null
    /**
     * Omit specific fields from the CommandeFormation
     */
    omit?: CommandeFormationOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CommandeFormationInclude<ExtArgs> | null
    /**
     * Filter, which CommandeFormation to fetch.
     */
    where: CommandeFormationWhereUniqueInput
  }

  /**
   * CommandeFormation findUniqueOrThrow
   */
  export type CommandeFormationFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CommandeFormation
     */
    select?: CommandeFormationSelect<ExtArgs> | null
    /**
     * Omit specific fields from the CommandeFormation
     */
    omit?: CommandeFormationOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CommandeFormationInclude<ExtArgs> | null
    /**
     * Filter, which CommandeFormation to fetch.
     */
    where: CommandeFormationWhereUniqueInput
  }

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

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

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

  /**
   * CommandeFormation create
   */
  export type CommandeFormationCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CommandeFormation
     */
    select?: CommandeFormationSelect<ExtArgs> | null
    /**
     * Omit specific fields from the CommandeFormation
     */
    omit?: CommandeFormationOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CommandeFormationInclude<ExtArgs> | null
    /**
     * The data needed to create a CommandeFormation.
     */
    data: XOR<CommandeFormationCreateInput, CommandeFormationUncheckedCreateInput>
  }

  /**
   * CommandeFormation createMany
   */
  export type CommandeFormationCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many CommandeFormations.
     */
    data: CommandeFormationCreateManyInput | CommandeFormationCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * CommandeFormation update
   */
  export type CommandeFormationUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CommandeFormation
     */
    select?: CommandeFormationSelect<ExtArgs> | null
    /**
     * Omit specific fields from the CommandeFormation
     */
    omit?: CommandeFormationOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CommandeFormationInclude<ExtArgs> | null
    /**
     * The data needed to update a CommandeFormation.
     */
    data: XOR<CommandeFormationUpdateInput, CommandeFormationUncheckedUpdateInput>
    /**
     * Choose, which CommandeFormation to update.
     */
    where: CommandeFormationWhereUniqueInput
  }

  /**
   * CommandeFormation updateMany
   */
  export type CommandeFormationUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update CommandeFormations.
     */
    data: XOR<CommandeFormationUpdateManyMutationInput, CommandeFormationUncheckedUpdateManyInput>
    /**
     * Filter which CommandeFormations to update
     */
    where?: CommandeFormationWhereInput
    /**
     * Limit how many CommandeFormations to update.
     */
    limit?: number
  }

  /**
   * CommandeFormation upsert
   */
  export type CommandeFormationUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CommandeFormation
     */
    select?: CommandeFormationSelect<ExtArgs> | null
    /**
     * Omit specific fields from the CommandeFormation
     */
    omit?: CommandeFormationOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CommandeFormationInclude<ExtArgs> | null
    /**
     * The filter to search for the CommandeFormation to update in case it exists.
     */
    where: CommandeFormationWhereUniqueInput
    /**
     * In case the CommandeFormation found by the `where` argument doesn't exist, create a new CommandeFormation with this data.
     */
    create: XOR<CommandeFormationCreateInput, CommandeFormationUncheckedCreateInput>
    /**
     * In case the CommandeFormation was found with the provided `where` argument, update it with this data.
     */
    update: XOR<CommandeFormationUpdateInput, CommandeFormationUncheckedUpdateInput>
  }

  /**
   * CommandeFormation delete
   */
  export type CommandeFormationDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CommandeFormation
     */
    select?: CommandeFormationSelect<ExtArgs> | null
    /**
     * Omit specific fields from the CommandeFormation
     */
    omit?: CommandeFormationOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CommandeFormationInclude<ExtArgs> | null
    /**
     * Filter which CommandeFormation to delete.
     */
    where: CommandeFormationWhereUniqueInput
  }

  /**
   * CommandeFormation deleteMany
   */
  export type CommandeFormationDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which CommandeFormations to delete
     */
    where?: CommandeFormationWhereInput
    /**
     * Limit how many CommandeFormations to delete.
     */
    limit?: number
  }

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


  /**
   * Model Achat
   */

  export type AggregateAchat = {
    _count: AchatCountAggregateOutputType | null
    _avg: AchatAvgAggregateOutputType | null
    _sum: AchatSumAggregateOutputType | null
    _min: AchatMinAggregateOutputType | null
    _max: AchatMaxAggregateOutputType | null
  }

  export type AchatAvgAggregateOutputType = {
    ac_id: number | null
    ac_utilisateur: number | null
    ac_formation: number | null
  }

  export type AchatSumAggregateOutputType = {
    ac_id: number | null
    ac_utilisateur: number | null
    ac_formation: number | null
  }

  export type AchatMinAggregateOutputType = {
    ac_id: number | null
    ac_utilisateur: number | null
    ac_formation: number | null
    ac_type: string | null
    ac_date_achat: Date | null
    ac_date_fin: Date | null
  }

  export type AchatMaxAggregateOutputType = {
    ac_id: number | null
    ac_utilisateur: number | null
    ac_formation: number | null
    ac_type: string | null
    ac_date_achat: Date | null
    ac_date_fin: Date | null
  }

  export type AchatCountAggregateOutputType = {
    ac_id: number
    ac_utilisateur: number
    ac_formation: number
    ac_type: number
    ac_date_achat: number
    ac_date_fin: number
    _all: number
  }


  export type AchatAvgAggregateInputType = {
    ac_id?: true
    ac_utilisateur?: true
    ac_formation?: true
  }

  export type AchatSumAggregateInputType = {
    ac_id?: true
    ac_utilisateur?: true
    ac_formation?: true
  }

  export type AchatMinAggregateInputType = {
    ac_id?: true
    ac_utilisateur?: true
    ac_formation?: true
    ac_type?: true
    ac_date_achat?: true
    ac_date_fin?: true
  }

  export type AchatMaxAggregateInputType = {
    ac_id?: true
    ac_utilisateur?: true
    ac_formation?: true
    ac_type?: true
    ac_date_achat?: true
    ac_date_fin?: true
  }

  export type AchatCountAggregateInputType = {
    ac_id?: true
    ac_utilisateur?: true
    ac_formation?: true
    ac_type?: true
    ac_date_achat?: true
    ac_date_fin?: true
    _all?: true
  }

  export type AchatAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Achat to aggregate.
     */
    where?: AchatWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Achats to fetch.
     */
    orderBy?: AchatOrderByWithRelationInput | AchatOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: AchatWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Achats 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` Achats.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned Achats
    **/
    _count?: true | AchatCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: AchatAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: AchatSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: AchatMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: AchatMaxAggregateInputType
  }

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




  export type AchatGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: AchatWhereInput
    orderBy?: AchatOrderByWithAggregationInput | AchatOrderByWithAggregationInput[]
    by: AchatScalarFieldEnum[] | AchatScalarFieldEnum
    having?: AchatScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: AchatCountAggregateInputType | true
    _avg?: AchatAvgAggregateInputType
    _sum?: AchatSumAggregateInputType
    _min?: AchatMinAggregateInputType
    _max?: AchatMaxAggregateInputType
  }

  export type AchatGroupByOutputType = {
    ac_id: number
    ac_utilisateur: number
    ac_formation: number
    ac_type: string | null
    ac_date_achat: Date | null
    ac_date_fin: Date | null
    _count: AchatCountAggregateOutputType | null
    _avg: AchatAvgAggregateOutputType | null
    _sum: AchatSumAggregateOutputType | null
    _min: AchatMinAggregateOutputType | null
    _max: AchatMaxAggregateOutputType | null
  }

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


  export type AchatSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    ac_id?: boolean
    ac_utilisateur?: boolean
    ac_formation?: boolean
    ac_type?: boolean
    ac_date_achat?: boolean
    ac_date_fin?: boolean
    utilisateur?: boolean | UtilisateurDefaultArgs<ExtArgs>
    formation?: boolean | FormationDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["achat"]>



  export type AchatSelectScalar = {
    ac_id?: boolean
    ac_utilisateur?: boolean
    ac_formation?: boolean
    ac_type?: boolean
    ac_date_achat?: boolean
    ac_date_fin?: boolean
  }

  export type AchatOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"ac_id" | "ac_utilisateur" | "ac_formation" | "ac_type" | "ac_date_achat" | "ac_date_fin", ExtArgs["result"]["achat"]>
  export type AchatInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    utilisateur?: boolean | UtilisateurDefaultArgs<ExtArgs>
    formation?: boolean | FormationDefaultArgs<ExtArgs>
  }

  export type $AchatPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Achat"
    objects: {
      utilisateur: Prisma.$UtilisateurPayload<ExtArgs>
      formation: Prisma.$FormationPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      ac_id: number
      ac_utilisateur: number
      ac_formation: number
      ac_type: string | null
      ac_date_achat: Date | null
      ac_date_fin: Date | null
    }, ExtArgs["result"]["achat"]>
    composites: {}
  }

  type AchatGetPayload<S extends boolean | null | undefined | AchatDefaultArgs> = $Result.GetResult<Prisma.$AchatPayload, S>

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

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

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

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

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

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

    /**
     * Create a Achat.
     * @param {AchatCreateArgs} args - Arguments to create a Achat.
     * @example
     * // Create one Achat
     * const Achat = await prisma.achat.create({
     *   data: {
     *     // ... data to create a Achat
     *   }
     * })
     * 
     */
    create<T extends AchatCreateArgs>(args: SelectSubset<T, AchatCreateArgs<ExtArgs>>): Prisma__AchatClient<$Result.GetResult<Prisma.$AchatPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

    /**
     * Delete a Achat.
     * @param {AchatDeleteArgs} args - Arguments to delete one Achat.
     * @example
     * // Delete one Achat
     * const Achat = await prisma.achat.delete({
     *   where: {
     *     // ... filter to delete one Achat
     *   }
     * })
     * 
     */
    delete<T extends AchatDeleteArgs>(args: SelectSubset<T, AchatDeleteArgs<ExtArgs>>): Prisma__AchatClient<$Result.GetResult<Prisma.$AchatPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

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

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for Achat.
   * 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__AchatClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    utilisateur<T extends UtilisateurDefaultArgs<ExtArgs> = {}>(args?: Subset<T, UtilisateurDefaultArgs<ExtArgs>>): Prisma__UtilisateurClient<$Result.GetResult<Prisma.$UtilisateurPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
    formation<T extends FormationDefaultArgs<ExtArgs> = {}>(args?: Subset<T, FormationDefaultArgs<ExtArgs>>): Prisma__FormationClient<$Result.GetResult<Prisma.$FormationPayload<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 Achat model
   */
  interface AchatFieldRefs {
    readonly ac_id: FieldRef<"Achat", 'Int'>
    readonly ac_utilisateur: FieldRef<"Achat", 'Int'>
    readonly ac_formation: FieldRef<"Achat", 'Int'>
    readonly ac_type: FieldRef<"Achat", 'String'>
    readonly ac_date_achat: FieldRef<"Achat", 'DateTime'>
    readonly ac_date_fin: FieldRef<"Achat", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * Achat findUnique
   */
  export type AchatFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Achat
     */
    select?: AchatSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Achat
     */
    omit?: AchatOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AchatInclude<ExtArgs> | null
    /**
     * Filter, which Achat to fetch.
     */
    where: AchatWhereUniqueInput
  }

  /**
   * Achat findUniqueOrThrow
   */
  export type AchatFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Achat
     */
    select?: AchatSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Achat
     */
    omit?: AchatOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AchatInclude<ExtArgs> | null
    /**
     * Filter, which Achat to fetch.
     */
    where: AchatWhereUniqueInput
  }

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

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

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

  /**
   * Achat create
   */
  export type AchatCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Achat
     */
    select?: AchatSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Achat
     */
    omit?: AchatOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AchatInclude<ExtArgs> | null
    /**
     * The data needed to create a Achat.
     */
    data: XOR<AchatCreateInput, AchatUncheckedCreateInput>
  }

  /**
   * Achat createMany
   */
  export type AchatCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many Achats.
     */
    data: AchatCreateManyInput | AchatCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * Achat update
   */
  export type AchatUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Achat
     */
    select?: AchatSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Achat
     */
    omit?: AchatOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AchatInclude<ExtArgs> | null
    /**
     * The data needed to update a Achat.
     */
    data: XOR<AchatUpdateInput, AchatUncheckedUpdateInput>
    /**
     * Choose, which Achat to update.
     */
    where: AchatWhereUniqueInput
  }

  /**
   * Achat updateMany
   */
  export type AchatUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Achats.
     */
    data: XOR<AchatUpdateManyMutationInput, AchatUncheckedUpdateManyInput>
    /**
     * Filter which Achats to update
     */
    where?: AchatWhereInput
    /**
     * Limit how many Achats to update.
     */
    limit?: number
  }

  /**
   * Achat upsert
   */
  export type AchatUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Achat
     */
    select?: AchatSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Achat
     */
    omit?: AchatOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AchatInclude<ExtArgs> | null
    /**
     * The filter to search for the Achat to update in case it exists.
     */
    where: AchatWhereUniqueInput
    /**
     * In case the Achat found by the `where` argument doesn't exist, create a new Achat with this data.
     */
    create: XOR<AchatCreateInput, AchatUncheckedCreateInput>
    /**
     * In case the Achat was found with the provided `where` argument, update it with this data.
     */
    update: XOR<AchatUpdateInput, AchatUncheckedUpdateInput>
  }

  /**
   * Achat delete
   */
  export type AchatDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Achat
     */
    select?: AchatSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Achat
     */
    omit?: AchatOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AchatInclude<ExtArgs> | null
    /**
     * Filter which Achat to delete.
     */
    where: AchatWhereUniqueInput
  }

  /**
   * Achat deleteMany
   */
  export type AchatDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Achats to delete
     */
    where?: AchatWhereInput
    /**
     * Limit how many Achats to delete.
     */
    limit?: number
  }

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


  /**
   * Model Tag
   */

  export type AggregateTag = {
    _count: TagCountAggregateOutputType | null
    _avg: TagAvgAggregateOutputType | null
    _sum: TagSumAggregateOutputType | null
    _min: TagMinAggregateOutputType | null
    _max: TagMaxAggregateOutputType | null
  }

  export type TagAvgAggregateOutputType = {
    ta_id: number | null
  }

  export type TagSumAggregateOutputType = {
    ta_id: number | null
  }

  export type TagMinAggregateOutputType = {
    ta_id: number | null
    ta_titre: string | null
  }

  export type TagMaxAggregateOutputType = {
    ta_id: number | null
    ta_titre: string | null
  }

  export type TagCountAggregateOutputType = {
    ta_id: number
    ta_titre: number
    _all: number
  }


  export type TagAvgAggregateInputType = {
    ta_id?: true
  }

  export type TagSumAggregateInputType = {
    ta_id?: true
  }

  export type TagMinAggregateInputType = {
    ta_id?: true
    ta_titre?: true
  }

  export type TagMaxAggregateInputType = {
    ta_id?: true
    ta_titre?: true
  }

  export type TagCountAggregateInputType = {
    ta_id?: true
    ta_titre?: true
    _all?: true
  }

  export type TagAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Tag to aggregate.
     */
    where?: TagWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Tags to fetch.
     */
    orderBy?: TagOrderByWithRelationInput | TagOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: TagWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Tags 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` Tags.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned Tags
    **/
    _count?: true | TagCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: TagAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: TagSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: TagMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: TagMaxAggregateInputType
  }

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




  export type TagGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: TagWhereInput
    orderBy?: TagOrderByWithAggregationInput | TagOrderByWithAggregationInput[]
    by: TagScalarFieldEnum[] | TagScalarFieldEnum
    having?: TagScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: TagCountAggregateInputType | true
    _avg?: TagAvgAggregateInputType
    _sum?: TagSumAggregateInputType
    _min?: TagMinAggregateInputType
    _max?: TagMaxAggregateInputType
  }

  export type TagGroupByOutputType = {
    ta_id: number
    ta_titre: string | null
    _count: TagCountAggregateOutputType | null
    _avg: TagAvgAggregateOutputType | null
    _sum: TagSumAggregateOutputType | null
    _min: TagMinAggregateOutputType | null
    _max: TagMaxAggregateOutputType | null
  }

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


  export type TagSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    ta_id?: boolean
    ta_titre?: boolean
    vi_tv?: boolean | Tag$vi_tvArgs<ExtArgs>
    _count?: boolean | TagCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["tag"]>



  export type TagSelectScalar = {
    ta_id?: boolean
    ta_titre?: boolean
  }

  export type TagOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"ta_id" | "ta_titre", ExtArgs["result"]["tag"]>
  export type TagInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    vi_tv?: boolean | Tag$vi_tvArgs<ExtArgs>
    _count?: boolean | TagCountOutputTypeDefaultArgs<ExtArgs>
  }

  export type $TagPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Tag"
    objects: {
      vi_tv: Prisma.$TagVideoPayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      ta_id: number
      ta_titre: string | null
    }, ExtArgs["result"]["tag"]>
    composites: {}
  }

  type TagGetPayload<S extends boolean | null | undefined | TagDefaultArgs> = $Result.GetResult<Prisma.$TagPayload, S>

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

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

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

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

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

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

    /**
     * Create a Tag.
     * @param {TagCreateArgs} args - Arguments to create a Tag.
     * @example
     * // Create one Tag
     * const Tag = await prisma.tag.create({
     *   data: {
     *     // ... data to create a Tag
     *   }
     * })
     * 
     */
    create<T extends TagCreateArgs>(args: SelectSubset<T, TagCreateArgs<ExtArgs>>): Prisma__TagClient<$Result.GetResult<Prisma.$TagPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

    /**
     * Delete a Tag.
     * @param {TagDeleteArgs} args - Arguments to delete one Tag.
     * @example
     * // Delete one Tag
     * const Tag = await prisma.tag.delete({
     *   where: {
     *     // ... filter to delete one Tag
     *   }
     * })
     * 
     */
    delete<T extends TagDeleteArgs>(args: SelectSubset<T, TagDeleteArgs<ExtArgs>>): Prisma__TagClient<$Result.GetResult<Prisma.$TagPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

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

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for Tag.
   * 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__TagClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    vi_tv<T extends Tag$vi_tvArgs<ExtArgs> = {}>(args?: Subset<T, Tag$vi_tvArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$TagVideoPayload<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 Tag model
   */
  interface TagFieldRefs {
    readonly ta_id: FieldRef<"Tag", 'Int'>
    readonly ta_titre: FieldRef<"Tag", 'String'>
  }
    

  // Custom InputTypes
  /**
   * Tag findUnique
   */
  export type TagFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Tag
     */
    select?: TagSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Tag
     */
    omit?: TagOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TagInclude<ExtArgs> | null
    /**
     * Filter, which Tag to fetch.
     */
    where: TagWhereUniqueInput
  }

  /**
   * Tag findUniqueOrThrow
   */
  export type TagFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Tag
     */
    select?: TagSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Tag
     */
    omit?: TagOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TagInclude<ExtArgs> | null
    /**
     * Filter, which Tag to fetch.
     */
    where: TagWhereUniqueInput
  }

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

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

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

  /**
   * Tag create
   */
  export type TagCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Tag
     */
    select?: TagSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Tag
     */
    omit?: TagOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TagInclude<ExtArgs> | null
    /**
     * The data needed to create a Tag.
     */
    data?: XOR<TagCreateInput, TagUncheckedCreateInput>
  }

  /**
   * Tag createMany
   */
  export type TagCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many Tags.
     */
    data: TagCreateManyInput | TagCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * Tag update
   */
  export type TagUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Tag
     */
    select?: TagSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Tag
     */
    omit?: TagOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TagInclude<ExtArgs> | null
    /**
     * The data needed to update a Tag.
     */
    data: XOR<TagUpdateInput, TagUncheckedUpdateInput>
    /**
     * Choose, which Tag to update.
     */
    where: TagWhereUniqueInput
  }

  /**
   * Tag updateMany
   */
  export type TagUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Tags.
     */
    data: XOR<TagUpdateManyMutationInput, TagUncheckedUpdateManyInput>
    /**
     * Filter which Tags to update
     */
    where?: TagWhereInput
    /**
     * Limit how many Tags to update.
     */
    limit?: number
  }

  /**
   * Tag upsert
   */
  export type TagUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Tag
     */
    select?: TagSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Tag
     */
    omit?: TagOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TagInclude<ExtArgs> | null
    /**
     * The filter to search for the Tag to update in case it exists.
     */
    where: TagWhereUniqueInput
    /**
     * In case the Tag found by the `where` argument doesn't exist, create a new Tag with this data.
     */
    create: XOR<TagCreateInput, TagUncheckedCreateInput>
    /**
     * In case the Tag was found with the provided `where` argument, update it with this data.
     */
    update: XOR<TagUpdateInput, TagUncheckedUpdateInput>
  }

  /**
   * Tag delete
   */
  export type TagDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Tag
     */
    select?: TagSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Tag
     */
    omit?: TagOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TagInclude<ExtArgs> | null
    /**
     * Filter which Tag to delete.
     */
    where: TagWhereUniqueInput
  }

  /**
   * Tag deleteMany
   */
  export type TagDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Tags to delete
     */
    where?: TagWhereInput
    /**
     * Limit how many Tags to delete.
     */
    limit?: number
  }

  /**
   * Tag.vi_tv
   */
  export type Tag$vi_tvArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TagVideo
     */
    select?: TagVideoSelect<ExtArgs> | null
    /**
     * Omit specific fields from the TagVideo
     */
    omit?: TagVideoOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TagVideoInclude<ExtArgs> | null
    where?: TagVideoWhereInput
    orderBy?: TagVideoOrderByWithRelationInput | TagVideoOrderByWithRelationInput[]
    cursor?: TagVideoWhereUniqueInput
    take?: number
    skip?: number
    distinct?: TagVideoScalarFieldEnum | TagVideoScalarFieldEnum[]
  }

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


  /**
   * Model TagVideo
   */

  export type AggregateTagVideo = {
    _count: TagVideoCountAggregateOutputType | null
    _avg: TagVideoAvgAggregateOutputType | null
    _sum: TagVideoSumAggregateOutputType | null
    _min: TagVideoMinAggregateOutputType | null
    _max: TagVideoMaxAggregateOutputType | null
  }

  export type TagVideoAvgAggregateOutputType = {
    tv_tag_id: number | null
    tv_video_id: number | null
  }

  export type TagVideoSumAggregateOutputType = {
    tv_tag_id: number | null
    tv_video_id: number | null
  }

  export type TagVideoMinAggregateOutputType = {
    tv_tag_id: number | null
    tv_video_id: number | null
  }

  export type TagVideoMaxAggregateOutputType = {
    tv_tag_id: number | null
    tv_video_id: number | null
  }

  export type TagVideoCountAggregateOutputType = {
    tv_tag_id: number
    tv_video_id: number
    _all: number
  }


  export type TagVideoAvgAggregateInputType = {
    tv_tag_id?: true
    tv_video_id?: true
  }

  export type TagVideoSumAggregateInputType = {
    tv_tag_id?: true
    tv_video_id?: true
  }

  export type TagVideoMinAggregateInputType = {
    tv_tag_id?: true
    tv_video_id?: true
  }

  export type TagVideoMaxAggregateInputType = {
    tv_tag_id?: true
    tv_video_id?: true
  }

  export type TagVideoCountAggregateInputType = {
    tv_tag_id?: true
    tv_video_id?: true
    _all?: true
  }

  export type TagVideoAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which TagVideo to aggregate.
     */
    where?: TagVideoWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of TagVideos to fetch.
     */
    orderBy?: TagVideoOrderByWithRelationInput | TagVideoOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: TagVideoWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` TagVideos 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` TagVideos.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned TagVideos
    **/
    _count?: true | TagVideoCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: TagVideoAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: TagVideoSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: TagVideoMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: TagVideoMaxAggregateInputType
  }

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




  export type TagVideoGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: TagVideoWhereInput
    orderBy?: TagVideoOrderByWithAggregationInput | TagVideoOrderByWithAggregationInput[]
    by: TagVideoScalarFieldEnum[] | TagVideoScalarFieldEnum
    having?: TagVideoScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: TagVideoCountAggregateInputType | true
    _avg?: TagVideoAvgAggregateInputType
    _sum?: TagVideoSumAggregateInputType
    _min?: TagVideoMinAggregateInputType
    _max?: TagVideoMaxAggregateInputType
  }

  export type TagVideoGroupByOutputType = {
    tv_tag_id: number
    tv_video_id: number
    _count: TagVideoCountAggregateOutputType | null
    _avg: TagVideoAvgAggregateOutputType | null
    _sum: TagVideoSumAggregateOutputType | null
    _min: TagVideoMinAggregateOutputType | null
    _max: TagVideoMaxAggregateOutputType | null
  }

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


  export type TagVideoSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    tv_tag_id?: boolean
    tv_video_id?: boolean
    tag?: boolean | TagDefaultArgs<ExtArgs>
    video?: boolean | VideoDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["tagVideo"]>



  export type TagVideoSelectScalar = {
    tv_tag_id?: boolean
    tv_video_id?: boolean
  }

  export type TagVideoOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"tv_tag_id" | "tv_video_id", ExtArgs["result"]["tagVideo"]>
  export type TagVideoInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    tag?: boolean | TagDefaultArgs<ExtArgs>
    video?: boolean | VideoDefaultArgs<ExtArgs>
  }

  export type $TagVideoPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "TagVideo"
    objects: {
      tag: Prisma.$TagPayload<ExtArgs>
      video: Prisma.$VideoPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      tv_tag_id: number
      tv_video_id: number
    }, ExtArgs["result"]["tagVideo"]>
    composites: {}
  }

  type TagVideoGetPayload<S extends boolean | null | undefined | TagVideoDefaultArgs> = $Result.GetResult<Prisma.$TagVideoPayload, S>

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

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

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

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

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

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

    /**
     * Create a TagVideo.
     * @param {TagVideoCreateArgs} args - Arguments to create a TagVideo.
     * @example
     * // Create one TagVideo
     * const TagVideo = await prisma.tagVideo.create({
     *   data: {
     *     // ... data to create a TagVideo
     *   }
     * })
     * 
     */
    create<T extends TagVideoCreateArgs>(args: SelectSubset<T, TagVideoCreateArgs<ExtArgs>>): Prisma__TagVideoClient<$Result.GetResult<Prisma.$TagVideoPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

    /**
     * Delete a TagVideo.
     * @param {TagVideoDeleteArgs} args - Arguments to delete one TagVideo.
     * @example
     * // Delete one TagVideo
     * const TagVideo = await prisma.tagVideo.delete({
     *   where: {
     *     // ... filter to delete one TagVideo
     *   }
     * })
     * 
     */
    delete<T extends TagVideoDeleteArgs>(args: SelectSubset<T, TagVideoDeleteArgs<ExtArgs>>): Prisma__TagVideoClient<$Result.GetResult<Prisma.$TagVideoPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

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

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for TagVideo.
   * 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__TagVideoClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    tag<T extends TagDefaultArgs<ExtArgs> = {}>(args?: Subset<T, TagDefaultArgs<ExtArgs>>): Prisma__TagClient<$Result.GetResult<Prisma.$TagPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
    video<T extends VideoDefaultArgs<ExtArgs> = {}>(args?: Subset<T, VideoDefaultArgs<ExtArgs>>): Prisma__VideoClient<$Result.GetResult<Prisma.$VideoPayload<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 TagVideo model
   */
  interface TagVideoFieldRefs {
    readonly tv_tag_id: FieldRef<"TagVideo", 'Int'>
    readonly tv_video_id: FieldRef<"TagVideo", 'Int'>
  }
    

  // Custom InputTypes
  /**
   * TagVideo findUnique
   */
  export type TagVideoFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TagVideo
     */
    select?: TagVideoSelect<ExtArgs> | null
    /**
     * Omit specific fields from the TagVideo
     */
    omit?: TagVideoOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TagVideoInclude<ExtArgs> | null
    /**
     * Filter, which TagVideo to fetch.
     */
    where: TagVideoWhereUniqueInput
  }

  /**
   * TagVideo findUniqueOrThrow
   */
  export type TagVideoFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TagVideo
     */
    select?: TagVideoSelect<ExtArgs> | null
    /**
     * Omit specific fields from the TagVideo
     */
    omit?: TagVideoOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TagVideoInclude<ExtArgs> | null
    /**
     * Filter, which TagVideo to fetch.
     */
    where: TagVideoWhereUniqueInput
  }

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

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

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

  /**
   * TagVideo create
   */
  export type TagVideoCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TagVideo
     */
    select?: TagVideoSelect<ExtArgs> | null
    /**
     * Omit specific fields from the TagVideo
     */
    omit?: TagVideoOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TagVideoInclude<ExtArgs> | null
    /**
     * The data needed to create a TagVideo.
     */
    data: XOR<TagVideoCreateInput, TagVideoUncheckedCreateInput>
  }

  /**
   * TagVideo createMany
   */
  export type TagVideoCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many TagVideos.
     */
    data: TagVideoCreateManyInput | TagVideoCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * TagVideo update
   */
  export type TagVideoUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TagVideo
     */
    select?: TagVideoSelect<ExtArgs> | null
    /**
     * Omit specific fields from the TagVideo
     */
    omit?: TagVideoOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TagVideoInclude<ExtArgs> | null
    /**
     * The data needed to update a TagVideo.
     */
    data: XOR<TagVideoUpdateInput, TagVideoUncheckedUpdateInput>
    /**
     * Choose, which TagVideo to update.
     */
    where: TagVideoWhereUniqueInput
  }

  /**
   * TagVideo updateMany
   */
  export type TagVideoUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update TagVideos.
     */
    data: XOR<TagVideoUpdateManyMutationInput, TagVideoUncheckedUpdateManyInput>
    /**
     * Filter which TagVideos to update
     */
    where?: TagVideoWhereInput
    /**
     * Limit how many TagVideos to update.
     */
    limit?: number
  }

  /**
   * TagVideo upsert
   */
  export type TagVideoUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TagVideo
     */
    select?: TagVideoSelect<ExtArgs> | null
    /**
     * Omit specific fields from the TagVideo
     */
    omit?: TagVideoOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TagVideoInclude<ExtArgs> | null
    /**
     * The filter to search for the TagVideo to update in case it exists.
     */
    where: TagVideoWhereUniqueInput
    /**
     * In case the TagVideo found by the `where` argument doesn't exist, create a new TagVideo with this data.
     */
    create: XOR<TagVideoCreateInput, TagVideoUncheckedCreateInput>
    /**
     * In case the TagVideo was found with the provided `where` argument, update it with this data.
     */
    update: XOR<TagVideoUpdateInput, TagVideoUncheckedUpdateInput>
  }

  /**
   * TagVideo delete
   */
  export type TagVideoDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TagVideo
     */
    select?: TagVideoSelect<ExtArgs> | null
    /**
     * Omit specific fields from the TagVideo
     */
    omit?: TagVideoOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TagVideoInclude<ExtArgs> | null
    /**
     * Filter which TagVideo to delete.
     */
    where: TagVideoWhereUniqueInput
  }

  /**
   * TagVideo deleteMany
   */
  export type TagVideoDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which TagVideos to delete
     */
    where?: TagVideoWhereInput
    /**
     * Limit how many TagVideos to delete.
     */
    limit?: number
  }

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


  /**
   * Enums
   */

  export const TransactionIsolationLevel: {
    ReadUncommitted: 'ReadUncommitted',
    ReadCommitted: 'ReadCommitted',
    RepeatableRead: 'RepeatableRead',
    Serializable: 'Serializable'
  };

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


  export const UtilisateurScalarFieldEnum: {
    ut_id: 'ut_id',
    ut_nom: 'ut_nom',
    ut_prenom: 'ut_prenom',
    ut_mail: 'ut_mail',
    ut_type_cliente: 'ut_type_cliente',
    ut_age: 'ut_age',
    ut_nb_rdv: 'ut_nb_rdv',
    ut_nb_rdv_honores: 'ut_nb_rdv_honores',
    ut_prix_moyen: 'ut_prix_moyen',
    ut_pdp: 'ut_pdp',
    ut_panier: 'ut_panier',
    ut_mdp: 'ut_mdp',
    ut_telephone: 'ut_telephone',
    ut_date_inscription: 'ut_date_inscription',
    ut_derniere_connexion: 'ut_derniere_connexion'
  };

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


  export const FormationScalarFieldEnum: {
    fo_id: 'fo_id',
    fo_titre: 'fo_titre',
    fo_description: 'fo_description',
    fo_prix: 'fo_prix',
    fo_miniature: 'fo_miniature',
    fo_teaser: 'fo_teaser',
    fo_date_publication: 'fo_date_publication'
  };

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


  export const VideoScalarFieldEnum: {
    vi_fo_id: 'vi_fo_id',
    vi_id: 'vi_id',
    vi_titre: 'vi_titre',
    vi_description: 'vi_description',
    vi_etape: 'vi_etape',
    vi_url: 'vi_url'
  };

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


  export const CommandeScalarFieldEnum: {
    co_id: 'co_id',
    co_utilisateur: 'co_utilisateur',
    co_date_creation: 'co_date_creation',
    co_date_update: 'co_date_update',
    co_status: 'co_status'
  };

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


  export const CommandeFormationScalarFieldEnum: {
    cof_id: 'cof_id',
    cof_formation: 'cof_formation'
  };

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


  export const AchatScalarFieldEnum: {
    ac_id: 'ac_id',
    ac_utilisateur: 'ac_utilisateur',
    ac_formation: 'ac_formation',
    ac_type: 'ac_type',
    ac_date_achat: 'ac_date_achat',
    ac_date_fin: 'ac_date_fin'
  };

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


  export const TagScalarFieldEnum: {
    ta_id: 'ta_id',
    ta_titre: 'ta_titre'
  };

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


  export const TagVideoScalarFieldEnum: {
    tv_tag_id: 'tv_tag_id',
    tv_video_id: 'tv_video_id'
  };

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


  export const SortOrder: {
    asc: 'asc',
    desc: 'desc'
  };

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


  export const NullsOrder: {
    first: 'first',
    last: 'last'
  };

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


  export const UtilisateurOrderByRelevanceFieldEnum: {
    ut_nom: 'ut_nom',
    ut_prenom: 'ut_prenom',
    ut_mail: 'ut_mail'
  };

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


  export const FormationOrderByRelevanceFieldEnum: {
    fo_titre: 'fo_titre',
    fo_description: 'fo_description',
    fo_prix: 'fo_prix',
    fo_teaser: 'fo_teaser'
  };

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


  export const VideoOrderByRelevanceFieldEnum: {
    vi_titre: 'vi_titre',
    vi_description: 'vi_description',
    vi_url: 'vi_url'
  };

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


  export const CommandeOrderByRelevanceFieldEnum: {
    co_status: 'co_status'
  };

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


  export const AchatOrderByRelevanceFieldEnum: {
    ac_type: 'ac_type'
  };

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


  export const TagOrderByRelevanceFieldEnum: {
    ta_titre: 'ta_titre'
  };

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


  /**
   * Field references
   */


  /**
   * Reference to a field of type 'Int'
   */
  export type IntFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Int'>
    


  /**
   * Reference to a field of type 'String'
   */
  export type StringFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'String'>
    


  /**
   * Reference to a field of type 'DateTime'
   */
  export type DateTimeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'DateTime'>
    


  /**
   * Reference to a field of type 'Bytes'
   */
  export type BytesFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Bytes'>
    


  /**
   * Reference to a field of type 'Float'
   */
  export type FloatFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Float'>
    
  /**
   * Deep Input Types
   */


  export type UtilisateurWhereInput = {
    AND?: UtilisateurWhereInput | UtilisateurWhereInput[]
    OR?: UtilisateurWhereInput[]
    NOT?: UtilisateurWhereInput | UtilisateurWhereInput[]
    ut_id?: IntFilter<"Utilisateur"> | number
    ut_nom?: StringNullableFilter<"Utilisateur"> | string | null
    ut_prenom?: StringNullableFilter<"Utilisateur"> | string | null
    ut_mail?: StringNullableFilter<"Utilisateur"> | string | null
    ut_type_cliente?: IntNullableFilter<"Utilisateur"> | number | null
    ut_age?: DateTimeNullableFilter<"Utilisateur"> | Date | string | null
    ut_nb_rdv?: IntNullableFilter<"Utilisateur"> | number | null
    ut_nb_rdv_honores?: IntNullableFilter<"Utilisateur"> | number | null
    ut_prix_moyen?: IntNullableFilter<"Utilisateur"> | number | null
    ut_pdp?: IntNullableFilter<"Utilisateur"> | number | null
    ut_panier?: IntNullableFilter<"Utilisateur"> | number | null
    ut_mdp?: IntNullableFilter<"Utilisateur"> | number | null
    ut_telephone?: IntNullableFilter<"Utilisateur"> | number | null
    ut_date_inscription?: DateTimeFilter<"Utilisateur"> | Date | string
    ut_derniere_connexion?: DateTimeNullableFilter<"Utilisateur"> | Date | string | null
    commande?: CommandeListRelationFilter
    achat?: AchatListRelationFilter
  }

  export type UtilisateurOrderByWithRelationInput = {
    ut_id?: SortOrder
    ut_nom?: SortOrderInput | SortOrder
    ut_prenom?: SortOrderInput | SortOrder
    ut_mail?: SortOrderInput | SortOrder
    ut_type_cliente?: SortOrderInput | SortOrder
    ut_age?: SortOrderInput | SortOrder
    ut_nb_rdv?: SortOrderInput | SortOrder
    ut_nb_rdv_honores?: SortOrderInput | SortOrder
    ut_prix_moyen?: SortOrderInput | SortOrder
    ut_pdp?: SortOrderInput | SortOrder
    ut_panier?: SortOrderInput | SortOrder
    ut_mdp?: SortOrderInput | SortOrder
    ut_telephone?: SortOrderInput | SortOrder
    ut_date_inscription?: SortOrder
    ut_derniere_connexion?: SortOrderInput | SortOrder
    commande?: CommandeOrderByRelationAggregateInput
    achat?: AchatOrderByRelationAggregateInput
    _relevance?: UtilisateurOrderByRelevanceInput
  }

  export type UtilisateurWhereUniqueInput = Prisma.AtLeast<{
    ut_id?: number
    AND?: UtilisateurWhereInput | UtilisateurWhereInput[]
    OR?: UtilisateurWhereInput[]
    NOT?: UtilisateurWhereInput | UtilisateurWhereInput[]
    ut_nom?: StringNullableFilter<"Utilisateur"> | string | null
    ut_prenom?: StringNullableFilter<"Utilisateur"> | string | null
    ut_mail?: StringNullableFilter<"Utilisateur"> | string | null
    ut_type_cliente?: IntNullableFilter<"Utilisateur"> | number | null
    ut_age?: DateTimeNullableFilter<"Utilisateur"> | Date | string | null
    ut_nb_rdv?: IntNullableFilter<"Utilisateur"> | number | null
    ut_nb_rdv_honores?: IntNullableFilter<"Utilisateur"> | number | null
    ut_prix_moyen?: IntNullableFilter<"Utilisateur"> | number | null
    ut_pdp?: IntNullableFilter<"Utilisateur"> | number | null
    ut_panier?: IntNullableFilter<"Utilisateur"> | number | null
    ut_mdp?: IntNullableFilter<"Utilisateur"> | number | null
    ut_telephone?: IntNullableFilter<"Utilisateur"> | number | null
    ut_date_inscription?: DateTimeFilter<"Utilisateur"> | Date | string
    ut_derniere_connexion?: DateTimeNullableFilter<"Utilisateur"> | Date | string | null
    commande?: CommandeListRelationFilter
    achat?: AchatListRelationFilter
  }, "ut_id">

  export type UtilisateurOrderByWithAggregationInput = {
    ut_id?: SortOrder
    ut_nom?: SortOrderInput | SortOrder
    ut_prenom?: SortOrderInput | SortOrder
    ut_mail?: SortOrderInput | SortOrder
    ut_type_cliente?: SortOrderInput | SortOrder
    ut_age?: SortOrderInput | SortOrder
    ut_nb_rdv?: SortOrderInput | SortOrder
    ut_nb_rdv_honores?: SortOrderInput | SortOrder
    ut_prix_moyen?: SortOrderInput | SortOrder
    ut_pdp?: SortOrderInput | SortOrder
    ut_panier?: SortOrderInput | SortOrder
    ut_mdp?: SortOrderInput | SortOrder
    ut_telephone?: SortOrderInput | SortOrder
    ut_date_inscription?: SortOrder
    ut_derniere_connexion?: SortOrderInput | SortOrder
    _count?: UtilisateurCountOrderByAggregateInput
    _avg?: UtilisateurAvgOrderByAggregateInput
    _max?: UtilisateurMaxOrderByAggregateInput
    _min?: UtilisateurMinOrderByAggregateInput
    _sum?: UtilisateurSumOrderByAggregateInput
  }

  export type UtilisateurScalarWhereWithAggregatesInput = {
    AND?: UtilisateurScalarWhereWithAggregatesInput | UtilisateurScalarWhereWithAggregatesInput[]
    OR?: UtilisateurScalarWhereWithAggregatesInput[]
    NOT?: UtilisateurScalarWhereWithAggregatesInput | UtilisateurScalarWhereWithAggregatesInput[]
    ut_id?: IntWithAggregatesFilter<"Utilisateur"> | number
    ut_nom?: StringNullableWithAggregatesFilter<"Utilisateur"> | string | null
    ut_prenom?: StringNullableWithAggregatesFilter<"Utilisateur"> | string | null
    ut_mail?: StringNullableWithAggregatesFilter<"Utilisateur"> | string | null
    ut_type_cliente?: IntNullableWithAggregatesFilter<"Utilisateur"> | number | null
    ut_age?: DateTimeNullableWithAggregatesFilter<"Utilisateur"> | Date | string | null
    ut_nb_rdv?: IntNullableWithAggregatesFilter<"Utilisateur"> | number | null
    ut_nb_rdv_honores?: IntNullableWithAggregatesFilter<"Utilisateur"> | number | null
    ut_prix_moyen?: IntNullableWithAggregatesFilter<"Utilisateur"> | number | null
    ut_pdp?: IntNullableWithAggregatesFilter<"Utilisateur"> | number | null
    ut_panier?: IntNullableWithAggregatesFilter<"Utilisateur"> | number | null
    ut_mdp?: IntNullableWithAggregatesFilter<"Utilisateur"> | number | null
    ut_telephone?: IntNullableWithAggregatesFilter<"Utilisateur"> | number | null
    ut_date_inscription?: DateTimeWithAggregatesFilter<"Utilisateur"> | Date | string
    ut_derniere_connexion?: DateTimeNullableWithAggregatesFilter<"Utilisateur"> | Date | string | null
  }

  export type FormationWhereInput = {
    AND?: FormationWhereInput | FormationWhereInput[]
    OR?: FormationWhereInput[]
    NOT?: FormationWhereInput | FormationWhereInput[]
    fo_id?: IntFilter<"Formation"> | number
    fo_titre?: StringNullableFilter<"Formation"> | string | null
    fo_description?: StringNullableFilter<"Formation"> | string | null
    fo_prix?: StringNullableFilter<"Formation"> | string | null
    fo_miniature?: BytesNullableFilter<"Formation"> | Uint8Array | null
    fo_teaser?: StringNullableFilter<"Formation"> | string | null
    fo_date_publication?: DateTimeFilter<"Formation"> | Date | string
    fo_video?: VideoListRelationFilter
    commandeFormation?: CommandeFormationListRelationFilter
    achat?: AchatListRelationFilter
  }

  export type FormationOrderByWithRelationInput = {
    fo_id?: SortOrder
    fo_titre?: SortOrderInput | SortOrder
    fo_description?: SortOrderInput | SortOrder
    fo_prix?: SortOrderInput | SortOrder
    fo_miniature?: SortOrderInput | SortOrder
    fo_teaser?: SortOrderInput | SortOrder
    fo_date_publication?: SortOrder
    fo_video?: VideoOrderByRelationAggregateInput
    commandeFormation?: CommandeFormationOrderByRelationAggregateInput
    achat?: AchatOrderByRelationAggregateInput
    _relevance?: FormationOrderByRelevanceInput
  }

  export type FormationWhereUniqueInput = Prisma.AtLeast<{
    fo_id?: number
    AND?: FormationWhereInput | FormationWhereInput[]
    OR?: FormationWhereInput[]
    NOT?: FormationWhereInput | FormationWhereInput[]
    fo_titre?: StringNullableFilter<"Formation"> | string | null
    fo_description?: StringNullableFilter<"Formation"> | string | null
    fo_prix?: StringNullableFilter<"Formation"> | string | null
    fo_miniature?: BytesNullableFilter<"Formation"> | Uint8Array | null
    fo_teaser?: StringNullableFilter<"Formation"> | string | null
    fo_date_publication?: DateTimeFilter<"Formation"> | Date | string
    fo_video?: VideoListRelationFilter
    commandeFormation?: CommandeFormationListRelationFilter
    achat?: AchatListRelationFilter
  }, "fo_id">

  export type FormationOrderByWithAggregationInput = {
    fo_id?: SortOrder
    fo_titre?: SortOrderInput | SortOrder
    fo_description?: SortOrderInput | SortOrder
    fo_prix?: SortOrderInput | SortOrder
    fo_miniature?: SortOrderInput | SortOrder
    fo_teaser?: SortOrderInput | SortOrder
    fo_date_publication?: SortOrder
    _count?: FormationCountOrderByAggregateInput
    _avg?: FormationAvgOrderByAggregateInput
    _max?: FormationMaxOrderByAggregateInput
    _min?: FormationMinOrderByAggregateInput
    _sum?: FormationSumOrderByAggregateInput
  }

  export type FormationScalarWhereWithAggregatesInput = {
    AND?: FormationScalarWhereWithAggregatesInput | FormationScalarWhereWithAggregatesInput[]
    OR?: FormationScalarWhereWithAggregatesInput[]
    NOT?: FormationScalarWhereWithAggregatesInput | FormationScalarWhereWithAggregatesInput[]
    fo_id?: IntWithAggregatesFilter<"Formation"> | number
    fo_titre?: StringNullableWithAggregatesFilter<"Formation"> | string | null
    fo_description?: StringNullableWithAggregatesFilter<"Formation"> | string | null
    fo_prix?: StringNullableWithAggregatesFilter<"Formation"> | string | null
    fo_miniature?: BytesNullableWithAggregatesFilter<"Formation"> | Uint8Array | null
    fo_teaser?: StringNullableWithAggregatesFilter<"Formation"> | string | null
    fo_date_publication?: DateTimeWithAggregatesFilter<"Formation"> | Date | string
  }

  export type VideoWhereInput = {
    AND?: VideoWhereInput | VideoWhereInput[]
    OR?: VideoWhereInput[]
    NOT?: VideoWhereInput | VideoWhereInput[]
    vi_fo_id?: IntFilter<"Video"> | number
    vi_id?: IntFilter<"Video"> | number
    vi_titre?: StringNullableFilter<"Video"> | string | null
    vi_description?: StringNullableFilter<"Video"> | string | null
    vi_etape?: IntNullableFilter<"Video"> | number | null
    vi_url?: StringNullableFilter<"Video"> | string | null
    formation?: XOR<FormationScalarRelationFilter, FormationWhereInput>
    vi_tv?: TagVideoListRelationFilter
  }

  export type VideoOrderByWithRelationInput = {
    vi_fo_id?: SortOrder
    vi_id?: SortOrder
    vi_titre?: SortOrderInput | SortOrder
    vi_description?: SortOrderInput | SortOrder
    vi_etape?: SortOrderInput | SortOrder
    vi_url?: SortOrderInput | SortOrder
    formation?: FormationOrderByWithRelationInput
    vi_tv?: TagVideoOrderByRelationAggregateInput
    _relevance?: VideoOrderByRelevanceInput
  }

  export type VideoWhereUniqueInput = Prisma.AtLeast<{
    vi_id?: number
    AND?: VideoWhereInput | VideoWhereInput[]
    OR?: VideoWhereInput[]
    NOT?: VideoWhereInput | VideoWhereInput[]
    vi_fo_id?: IntFilter<"Video"> | number
    vi_titre?: StringNullableFilter<"Video"> | string | null
    vi_description?: StringNullableFilter<"Video"> | string | null
    vi_etape?: IntNullableFilter<"Video"> | number | null
    vi_url?: StringNullableFilter<"Video"> | string | null
    formation?: XOR<FormationScalarRelationFilter, FormationWhereInput>
    vi_tv?: TagVideoListRelationFilter
  }, "vi_id">

  export type VideoOrderByWithAggregationInput = {
    vi_fo_id?: SortOrder
    vi_id?: SortOrder
    vi_titre?: SortOrderInput | SortOrder
    vi_description?: SortOrderInput | SortOrder
    vi_etape?: SortOrderInput | SortOrder
    vi_url?: SortOrderInput | SortOrder
    _count?: VideoCountOrderByAggregateInput
    _avg?: VideoAvgOrderByAggregateInput
    _max?: VideoMaxOrderByAggregateInput
    _min?: VideoMinOrderByAggregateInput
    _sum?: VideoSumOrderByAggregateInput
  }

  export type VideoScalarWhereWithAggregatesInput = {
    AND?: VideoScalarWhereWithAggregatesInput | VideoScalarWhereWithAggregatesInput[]
    OR?: VideoScalarWhereWithAggregatesInput[]
    NOT?: VideoScalarWhereWithAggregatesInput | VideoScalarWhereWithAggregatesInput[]
    vi_fo_id?: IntWithAggregatesFilter<"Video"> | number
    vi_id?: IntWithAggregatesFilter<"Video"> | number
    vi_titre?: StringNullableWithAggregatesFilter<"Video"> | string | null
    vi_description?: StringNullableWithAggregatesFilter<"Video"> | string | null
    vi_etape?: IntNullableWithAggregatesFilter<"Video"> | number | null
    vi_url?: StringNullableWithAggregatesFilter<"Video"> | string | null
  }

  export type CommandeWhereInput = {
    AND?: CommandeWhereInput | CommandeWhereInput[]
    OR?: CommandeWhereInput[]
    NOT?: CommandeWhereInput | CommandeWhereInput[]
    co_id?: IntFilter<"Commande"> | number
    co_utilisateur?: IntFilter<"Commande"> | number
    co_date_creation?: DateTimeFilter<"Commande"> | Date | string
    co_date_update?: DateTimeNullableFilter<"Commande"> | Date | string | null
    co_status?: StringFilter<"Commande"> | string
    utilisateur?: XOR<UtilisateurScalarRelationFilter, UtilisateurWhereInput>
  }

  export type CommandeOrderByWithRelationInput = {
    co_id?: SortOrder
    co_utilisateur?: SortOrder
    co_date_creation?: SortOrder
    co_date_update?: SortOrderInput | SortOrder
    co_status?: SortOrder
    utilisateur?: UtilisateurOrderByWithRelationInput
    _relevance?: CommandeOrderByRelevanceInput
  }

  export type CommandeWhereUniqueInput = Prisma.AtLeast<{
    co_id?: number
    AND?: CommandeWhereInput | CommandeWhereInput[]
    OR?: CommandeWhereInput[]
    NOT?: CommandeWhereInput | CommandeWhereInput[]
    co_utilisateur?: IntFilter<"Commande"> | number
    co_date_creation?: DateTimeFilter<"Commande"> | Date | string
    co_date_update?: DateTimeNullableFilter<"Commande"> | Date | string | null
    co_status?: StringFilter<"Commande"> | string
    utilisateur?: XOR<UtilisateurScalarRelationFilter, UtilisateurWhereInput>
  }, "co_id">

  export type CommandeOrderByWithAggregationInput = {
    co_id?: SortOrder
    co_utilisateur?: SortOrder
    co_date_creation?: SortOrder
    co_date_update?: SortOrderInput | SortOrder
    co_status?: SortOrder
    _count?: CommandeCountOrderByAggregateInput
    _avg?: CommandeAvgOrderByAggregateInput
    _max?: CommandeMaxOrderByAggregateInput
    _min?: CommandeMinOrderByAggregateInput
    _sum?: CommandeSumOrderByAggregateInput
  }

  export type CommandeScalarWhereWithAggregatesInput = {
    AND?: CommandeScalarWhereWithAggregatesInput | CommandeScalarWhereWithAggregatesInput[]
    OR?: CommandeScalarWhereWithAggregatesInput[]
    NOT?: CommandeScalarWhereWithAggregatesInput | CommandeScalarWhereWithAggregatesInput[]
    co_id?: IntWithAggregatesFilter<"Commande"> | number
    co_utilisateur?: IntWithAggregatesFilter<"Commande"> | number
    co_date_creation?: DateTimeWithAggregatesFilter<"Commande"> | Date | string
    co_date_update?: DateTimeNullableWithAggregatesFilter<"Commande"> | Date | string | null
    co_status?: StringWithAggregatesFilter<"Commande"> | string
  }

  export type CommandeFormationWhereInput = {
    AND?: CommandeFormationWhereInput | CommandeFormationWhereInput[]
    OR?: CommandeFormationWhereInput[]
    NOT?: CommandeFormationWhereInput | CommandeFormationWhereInput[]
    cof_id?: IntFilter<"CommandeFormation"> | number
    cof_formation?: IntFilter<"CommandeFormation"> | number
    formation?: XOR<FormationScalarRelationFilter, FormationWhereInput>
  }

  export type CommandeFormationOrderByWithRelationInput = {
    cof_id?: SortOrder
    cof_formation?: SortOrder
    formation?: FormationOrderByWithRelationInput
  }

  export type CommandeFormationWhereUniqueInput = Prisma.AtLeast<{
    cof_id?: number
    AND?: CommandeFormationWhereInput | CommandeFormationWhereInput[]
    OR?: CommandeFormationWhereInput[]
    NOT?: CommandeFormationWhereInput | CommandeFormationWhereInput[]
    cof_formation?: IntFilter<"CommandeFormation"> | number
    formation?: XOR<FormationScalarRelationFilter, FormationWhereInput>
  }, "cof_id">

  export type CommandeFormationOrderByWithAggregationInput = {
    cof_id?: SortOrder
    cof_formation?: SortOrder
    _count?: CommandeFormationCountOrderByAggregateInput
    _avg?: CommandeFormationAvgOrderByAggregateInput
    _max?: CommandeFormationMaxOrderByAggregateInput
    _min?: CommandeFormationMinOrderByAggregateInput
    _sum?: CommandeFormationSumOrderByAggregateInput
  }

  export type CommandeFormationScalarWhereWithAggregatesInput = {
    AND?: CommandeFormationScalarWhereWithAggregatesInput | CommandeFormationScalarWhereWithAggregatesInput[]
    OR?: CommandeFormationScalarWhereWithAggregatesInput[]
    NOT?: CommandeFormationScalarWhereWithAggregatesInput | CommandeFormationScalarWhereWithAggregatesInput[]
    cof_id?: IntWithAggregatesFilter<"CommandeFormation"> | number
    cof_formation?: IntWithAggregatesFilter<"CommandeFormation"> | number
  }

  export type AchatWhereInput = {
    AND?: AchatWhereInput | AchatWhereInput[]
    OR?: AchatWhereInput[]
    NOT?: AchatWhereInput | AchatWhereInput[]
    ac_id?: IntFilter<"Achat"> | number
    ac_utilisateur?: IntFilter<"Achat"> | number
    ac_formation?: IntFilter<"Achat"> | number
    ac_type?: StringNullableFilter<"Achat"> | string | null
    ac_date_achat?: DateTimeNullableFilter<"Achat"> | Date | string | null
    ac_date_fin?: DateTimeNullableFilter<"Achat"> | Date | string | null
    utilisateur?: XOR<UtilisateurScalarRelationFilter, UtilisateurWhereInput>
    formation?: XOR<FormationScalarRelationFilter, FormationWhereInput>
  }

  export type AchatOrderByWithRelationInput = {
    ac_id?: SortOrder
    ac_utilisateur?: SortOrder
    ac_formation?: SortOrder
    ac_type?: SortOrderInput | SortOrder
    ac_date_achat?: SortOrderInput | SortOrder
    ac_date_fin?: SortOrderInput | SortOrder
    utilisateur?: UtilisateurOrderByWithRelationInput
    formation?: FormationOrderByWithRelationInput
    _relevance?: AchatOrderByRelevanceInput
  }

  export type AchatWhereUniqueInput = Prisma.AtLeast<{
    ac_id?: number
    AND?: AchatWhereInput | AchatWhereInput[]
    OR?: AchatWhereInput[]
    NOT?: AchatWhereInput | AchatWhereInput[]
    ac_utilisateur?: IntFilter<"Achat"> | number
    ac_formation?: IntFilter<"Achat"> | number
    ac_type?: StringNullableFilter<"Achat"> | string | null
    ac_date_achat?: DateTimeNullableFilter<"Achat"> | Date | string | null
    ac_date_fin?: DateTimeNullableFilter<"Achat"> | Date | string | null
    utilisateur?: XOR<UtilisateurScalarRelationFilter, UtilisateurWhereInput>
    formation?: XOR<FormationScalarRelationFilter, FormationWhereInput>
  }, "ac_id">

  export type AchatOrderByWithAggregationInput = {
    ac_id?: SortOrder
    ac_utilisateur?: SortOrder
    ac_formation?: SortOrder
    ac_type?: SortOrderInput | SortOrder
    ac_date_achat?: SortOrderInput | SortOrder
    ac_date_fin?: SortOrderInput | SortOrder
    _count?: AchatCountOrderByAggregateInput
    _avg?: AchatAvgOrderByAggregateInput
    _max?: AchatMaxOrderByAggregateInput
    _min?: AchatMinOrderByAggregateInput
    _sum?: AchatSumOrderByAggregateInput
  }

  export type AchatScalarWhereWithAggregatesInput = {
    AND?: AchatScalarWhereWithAggregatesInput | AchatScalarWhereWithAggregatesInput[]
    OR?: AchatScalarWhereWithAggregatesInput[]
    NOT?: AchatScalarWhereWithAggregatesInput | AchatScalarWhereWithAggregatesInput[]
    ac_id?: IntWithAggregatesFilter<"Achat"> | number
    ac_utilisateur?: IntWithAggregatesFilter<"Achat"> | number
    ac_formation?: IntWithAggregatesFilter<"Achat"> | number
    ac_type?: StringNullableWithAggregatesFilter<"Achat"> | string | null
    ac_date_achat?: DateTimeNullableWithAggregatesFilter<"Achat"> | Date | string | null
    ac_date_fin?: DateTimeNullableWithAggregatesFilter<"Achat"> | Date | string | null
  }

  export type TagWhereInput = {
    AND?: TagWhereInput | TagWhereInput[]
    OR?: TagWhereInput[]
    NOT?: TagWhereInput | TagWhereInput[]
    ta_id?: IntFilter<"Tag"> | number
    ta_titre?: StringNullableFilter<"Tag"> | string | null
    vi_tv?: TagVideoListRelationFilter
  }

  export type TagOrderByWithRelationInput = {
    ta_id?: SortOrder
    ta_titre?: SortOrderInput | SortOrder
    vi_tv?: TagVideoOrderByRelationAggregateInput
    _relevance?: TagOrderByRelevanceInput
  }

  export type TagWhereUniqueInput = Prisma.AtLeast<{
    ta_id?: number
    AND?: TagWhereInput | TagWhereInput[]
    OR?: TagWhereInput[]
    NOT?: TagWhereInput | TagWhereInput[]
    ta_titre?: StringNullableFilter<"Tag"> | string | null
    vi_tv?: TagVideoListRelationFilter
  }, "ta_id">

  export type TagOrderByWithAggregationInput = {
    ta_id?: SortOrder
    ta_titre?: SortOrderInput | SortOrder
    _count?: TagCountOrderByAggregateInput
    _avg?: TagAvgOrderByAggregateInput
    _max?: TagMaxOrderByAggregateInput
    _min?: TagMinOrderByAggregateInput
    _sum?: TagSumOrderByAggregateInput
  }

  export type TagScalarWhereWithAggregatesInput = {
    AND?: TagScalarWhereWithAggregatesInput | TagScalarWhereWithAggregatesInput[]
    OR?: TagScalarWhereWithAggregatesInput[]
    NOT?: TagScalarWhereWithAggregatesInput | TagScalarWhereWithAggregatesInput[]
    ta_id?: IntWithAggregatesFilter<"Tag"> | number
    ta_titre?: StringNullableWithAggregatesFilter<"Tag"> | string | null
  }

  export type TagVideoWhereInput = {
    AND?: TagVideoWhereInput | TagVideoWhereInput[]
    OR?: TagVideoWhereInput[]
    NOT?: TagVideoWhereInput | TagVideoWhereInput[]
    tv_tag_id?: IntFilter<"TagVideo"> | number
    tv_video_id?: IntFilter<"TagVideo"> | number
    tag?: XOR<TagScalarRelationFilter, TagWhereInput>
    video?: XOR<VideoScalarRelationFilter, VideoWhereInput>
  }

  export type TagVideoOrderByWithRelationInput = {
    tv_tag_id?: SortOrder
    tv_video_id?: SortOrder
    tag?: TagOrderByWithRelationInput
    video?: VideoOrderByWithRelationInput
  }

  export type TagVideoWhereUniqueInput = Prisma.AtLeast<{
    tv_tag_id_tv_video_id?: TagVideoTv_tag_idTv_video_idCompoundUniqueInput
    AND?: TagVideoWhereInput | TagVideoWhereInput[]
    OR?: TagVideoWhereInput[]
    NOT?: TagVideoWhereInput | TagVideoWhereInput[]
    tv_tag_id?: IntFilter<"TagVideo"> | number
    tv_video_id?: IntFilter<"TagVideo"> | number
    tag?: XOR<TagScalarRelationFilter, TagWhereInput>
    video?: XOR<VideoScalarRelationFilter, VideoWhereInput>
  }, "tv_tag_id_tv_video_id">

  export type TagVideoOrderByWithAggregationInput = {
    tv_tag_id?: SortOrder
    tv_video_id?: SortOrder
    _count?: TagVideoCountOrderByAggregateInput
    _avg?: TagVideoAvgOrderByAggregateInput
    _max?: TagVideoMaxOrderByAggregateInput
    _min?: TagVideoMinOrderByAggregateInput
    _sum?: TagVideoSumOrderByAggregateInput
  }

  export type TagVideoScalarWhereWithAggregatesInput = {
    AND?: TagVideoScalarWhereWithAggregatesInput | TagVideoScalarWhereWithAggregatesInput[]
    OR?: TagVideoScalarWhereWithAggregatesInput[]
    NOT?: TagVideoScalarWhereWithAggregatesInput | TagVideoScalarWhereWithAggregatesInput[]
    tv_tag_id?: IntWithAggregatesFilter<"TagVideo"> | number
    tv_video_id?: IntWithAggregatesFilter<"TagVideo"> | number
  }

  export type UtilisateurCreateInput = {
    ut_nom?: string | null
    ut_prenom?: string | null
    ut_mail?: string | null
    ut_type_cliente?: number | null
    ut_age?: Date | string | null
    ut_nb_rdv?: number | null
    ut_nb_rdv_honores?: number | null
    ut_prix_moyen?: number | null
    ut_pdp?: number | null
    ut_panier?: number | null
    ut_mdp?: number | null
    ut_telephone?: number | null
    ut_date_inscription?: Date | string
    ut_derniere_connexion?: Date | string | null
    commande?: CommandeCreateNestedManyWithoutUtilisateurInput
    achat?: AchatCreateNestedManyWithoutUtilisateurInput
  }

  export type UtilisateurUncheckedCreateInput = {
    ut_id?: number
    ut_nom?: string | null
    ut_prenom?: string | null
    ut_mail?: string | null
    ut_type_cliente?: number | null
    ut_age?: Date | string | null
    ut_nb_rdv?: number | null
    ut_nb_rdv_honores?: number | null
    ut_prix_moyen?: number | null
    ut_pdp?: number | null
    ut_panier?: number | null
    ut_mdp?: number | null
    ut_telephone?: number | null
    ut_date_inscription?: Date | string
    ut_derniere_connexion?: Date | string | null
    commande?: CommandeUncheckedCreateNestedManyWithoutUtilisateurInput
    achat?: AchatUncheckedCreateNestedManyWithoutUtilisateurInput
  }

  export type UtilisateurUpdateInput = {
    ut_nom?: NullableStringFieldUpdateOperationsInput | string | null
    ut_prenom?: NullableStringFieldUpdateOperationsInput | string | null
    ut_mail?: NullableStringFieldUpdateOperationsInput | string | null
    ut_type_cliente?: NullableIntFieldUpdateOperationsInput | number | null
    ut_age?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    ut_nb_rdv?: NullableIntFieldUpdateOperationsInput | number | null
    ut_nb_rdv_honores?: NullableIntFieldUpdateOperationsInput | number | null
    ut_prix_moyen?: NullableIntFieldUpdateOperationsInput | number | null
    ut_pdp?: NullableIntFieldUpdateOperationsInput | number | null
    ut_panier?: NullableIntFieldUpdateOperationsInput | number | null
    ut_mdp?: NullableIntFieldUpdateOperationsInput | number | null
    ut_telephone?: NullableIntFieldUpdateOperationsInput | number | null
    ut_date_inscription?: DateTimeFieldUpdateOperationsInput | Date | string
    ut_derniere_connexion?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    commande?: CommandeUpdateManyWithoutUtilisateurNestedInput
    achat?: AchatUpdateManyWithoutUtilisateurNestedInput
  }

  export type UtilisateurUncheckedUpdateInput = {
    ut_id?: IntFieldUpdateOperationsInput | number
    ut_nom?: NullableStringFieldUpdateOperationsInput | string | null
    ut_prenom?: NullableStringFieldUpdateOperationsInput | string | null
    ut_mail?: NullableStringFieldUpdateOperationsInput | string | null
    ut_type_cliente?: NullableIntFieldUpdateOperationsInput | number | null
    ut_age?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    ut_nb_rdv?: NullableIntFieldUpdateOperationsInput | number | null
    ut_nb_rdv_honores?: NullableIntFieldUpdateOperationsInput | number | null
    ut_prix_moyen?: NullableIntFieldUpdateOperationsInput | number | null
    ut_pdp?: NullableIntFieldUpdateOperationsInput | number | null
    ut_panier?: NullableIntFieldUpdateOperationsInput | number | null
    ut_mdp?: NullableIntFieldUpdateOperationsInput | number | null
    ut_telephone?: NullableIntFieldUpdateOperationsInput | number | null
    ut_date_inscription?: DateTimeFieldUpdateOperationsInput | Date | string
    ut_derniere_connexion?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    commande?: CommandeUncheckedUpdateManyWithoutUtilisateurNestedInput
    achat?: AchatUncheckedUpdateManyWithoutUtilisateurNestedInput
  }

  export type UtilisateurCreateManyInput = {
    ut_id?: number
    ut_nom?: string | null
    ut_prenom?: string | null
    ut_mail?: string | null
    ut_type_cliente?: number | null
    ut_age?: Date | string | null
    ut_nb_rdv?: number | null
    ut_nb_rdv_honores?: number | null
    ut_prix_moyen?: number | null
    ut_pdp?: number | null
    ut_panier?: number | null
    ut_mdp?: number | null
    ut_telephone?: number | null
    ut_date_inscription?: Date | string
    ut_derniere_connexion?: Date | string | null
  }

  export type UtilisateurUpdateManyMutationInput = {
    ut_nom?: NullableStringFieldUpdateOperationsInput | string | null
    ut_prenom?: NullableStringFieldUpdateOperationsInput | string | null
    ut_mail?: NullableStringFieldUpdateOperationsInput | string | null
    ut_type_cliente?: NullableIntFieldUpdateOperationsInput | number | null
    ut_age?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    ut_nb_rdv?: NullableIntFieldUpdateOperationsInput | number | null
    ut_nb_rdv_honores?: NullableIntFieldUpdateOperationsInput | number | null
    ut_prix_moyen?: NullableIntFieldUpdateOperationsInput | number | null
    ut_pdp?: NullableIntFieldUpdateOperationsInput | number | null
    ut_panier?: NullableIntFieldUpdateOperationsInput | number | null
    ut_mdp?: NullableIntFieldUpdateOperationsInput | number | null
    ut_telephone?: NullableIntFieldUpdateOperationsInput | number | null
    ut_date_inscription?: DateTimeFieldUpdateOperationsInput | Date | string
    ut_derniere_connexion?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type UtilisateurUncheckedUpdateManyInput = {
    ut_id?: IntFieldUpdateOperationsInput | number
    ut_nom?: NullableStringFieldUpdateOperationsInput | string | null
    ut_prenom?: NullableStringFieldUpdateOperationsInput | string | null
    ut_mail?: NullableStringFieldUpdateOperationsInput | string | null
    ut_type_cliente?: NullableIntFieldUpdateOperationsInput | number | null
    ut_age?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    ut_nb_rdv?: NullableIntFieldUpdateOperationsInput | number | null
    ut_nb_rdv_honores?: NullableIntFieldUpdateOperationsInput | number | null
    ut_prix_moyen?: NullableIntFieldUpdateOperationsInput | number | null
    ut_pdp?: NullableIntFieldUpdateOperationsInput | number | null
    ut_panier?: NullableIntFieldUpdateOperationsInput | number | null
    ut_mdp?: NullableIntFieldUpdateOperationsInput | number | null
    ut_telephone?: NullableIntFieldUpdateOperationsInput | number | null
    ut_date_inscription?: DateTimeFieldUpdateOperationsInput | Date | string
    ut_derniere_connexion?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type FormationCreateInput = {
    fo_titre?: string | null
    fo_description?: string | null
    fo_prix?: string | null
    fo_miniature?: Uint8Array | null
    fo_teaser?: string | null
    fo_date_publication?: Date | string
    fo_video?: VideoCreateNestedManyWithoutFormationInput
    commandeFormation?: CommandeFormationCreateNestedManyWithoutFormationInput
    achat?: AchatCreateNestedManyWithoutFormationInput
  }

  export type FormationUncheckedCreateInput = {
    fo_id?: number
    fo_titre?: string | null
    fo_description?: string | null
    fo_prix?: string | null
    fo_miniature?: Uint8Array | null
    fo_teaser?: string | null
    fo_date_publication?: Date | string
    fo_video?: VideoUncheckedCreateNestedManyWithoutFormationInput
    commandeFormation?: CommandeFormationUncheckedCreateNestedManyWithoutFormationInput
    achat?: AchatUncheckedCreateNestedManyWithoutFormationInput
  }

  export type FormationUpdateInput = {
    fo_titre?: NullableStringFieldUpdateOperationsInput | string | null
    fo_description?: NullableStringFieldUpdateOperationsInput | string | null
    fo_prix?: NullableStringFieldUpdateOperationsInput | string | null
    fo_miniature?: NullableBytesFieldUpdateOperationsInput | Uint8Array | null
    fo_teaser?: NullableStringFieldUpdateOperationsInput | string | null
    fo_date_publication?: DateTimeFieldUpdateOperationsInput | Date | string
    fo_video?: VideoUpdateManyWithoutFormationNestedInput
    commandeFormation?: CommandeFormationUpdateManyWithoutFormationNestedInput
    achat?: AchatUpdateManyWithoutFormationNestedInput
  }

  export type FormationUncheckedUpdateInput = {
    fo_id?: IntFieldUpdateOperationsInput | number
    fo_titre?: NullableStringFieldUpdateOperationsInput | string | null
    fo_description?: NullableStringFieldUpdateOperationsInput | string | null
    fo_prix?: NullableStringFieldUpdateOperationsInput | string | null
    fo_miniature?: NullableBytesFieldUpdateOperationsInput | Uint8Array | null
    fo_teaser?: NullableStringFieldUpdateOperationsInput | string | null
    fo_date_publication?: DateTimeFieldUpdateOperationsInput | Date | string
    fo_video?: VideoUncheckedUpdateManyWithoutFormationNestedInput
    commandeFormation?: CommandeFormationUncheckedUpdateManyWithoutFormationNestedInput
    achat?: AchatUncheckedUpdateManyWithoutFormationNestedInput
  }

  export type FormationCreateManyInput = {
    fo_id?: number
    fo_titre?: string | null
    fo_description?: string | null
    fo_prix?: string | null
    fo_miniature?: Uint8Array | null
    fo_teaser?: string | null
    fo_date_publication?: Date | string
  }

  export type FormationUpdateManyMutationInput = {
    fo_titre?: NullableStringFieldUpdateOperationsInput | string | null
    fo_description?: NullableStringFieldUpdateOperationsInput | string | null
    fo_prix?: NullableStringFieldUpdateOperationsInput | string | null
    fo_miniature?: NullableBytesFieldUpdateOperationsInput | Uint8Array | null
    fo_teaser?: NullableStringFieldUpdateOperationsInput | string | null
    fo_date_publication?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type FormationUncheckedUpdateManyInput = {
    fo_id?: IntFieldUpdateOperationsInput | number
    fo_titre?: NullableStringFieldUpdateOperationsInput | string | null
    fo_description?: NullableStringFieldUpdateOperationsInput | string | null
    fo_prix?: NullableStringFieldUpdateOperationsInput | string | null
    fo_miniature?: NullableBytesFieldUpdateOperationsInput | Uint8Array | null
    fo_teaser?: NullableStringFieldUpdateOperationsInput | string | null
    fo_date_publication?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type VideoCreateInput = {
    vi_titre?: string | null
    vi_description?: string | null
    vi_etape?: number | null
    vi_url?: string | null
    formation: FormationCreateNestedOneWithoutFo_videoInput
    vi_tv?: TagVideoCreateNestedManyWithoutVideoInput
  }

  export type VideoUncheckedCreateInput = {
    vi_fo_id: number
    vi_id?: number
    vi_titre?: string | null
    vi_description?: string | null
    vi_etape?: number | null
    vi_url?: string | null
    vi_tv?: TagVideoUncheckedCreateNestedManyWithoutVideoInput
  }

  export type VideoUpdateInput = {
    vi_titre?: NullableStringFieldUpdateOperationsInput | string | null
    vi_description?: NullableStringFieldUpdateOperationsInput | string | null
    vi_etape?: NullableIntFieldUpdateOperationsInput | number | null
    vi_url?: NullableStringFieldUpdateOperationsInput | string | null
    formation?: FormationUpdateOneRequiredWithoutFo_videoNestedInput
    vi_tv?: TagVideoUpdateManyWithoutVideoNestedInput
  }

  export type VideoUncheckedUpdateInput = {
    vi_fo_id?: IntFieldUpdateOperationsInput | number
    vi_id?: IntFieldUpdateOperationsInput | number
    vi_titre?: NullableStringFieldUpdateOperationsInput | string | null
    vi_description?: NullableStringFieldUpdateOperationsInput | string | null
    vi_etape?: NullableIntFieldUpdateOperationsInput | number | null
    vi_url?: NullableStringFieldUpdateOperationsInput | string | null
    vi_tv?: TagVideoUncheckedUpdateManyWithoutVideoNestedInput
  }

  export type VideoCreateManyInput = {
    vi_fo_id: number
    vi_id?: number
    vi_titre?: string | null
    vi_description?: string | null
    vi_etape?: number | null
    vi_url?: string | null
  }

  export type VideoUpdateManyMutationInput = {
    vi_titre?: NullableStringFieldUpdateOperationsInput | string | null
    vi_description?: NullableStringFieldUpdateOperationsInput | string | null
    vi_etape?: NullableIntFieldUpdateOperationsInput | number | null
    vi_url?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type VideoUncheckedUpdateManyInput = {
    vi_fo_id?: IntFieldUpdateOperationsInput | number
    vi_id?: IntFieldUpdateOperationsInput | number
    vi_titre?: NullableStringFieldUpdateOperationsInput | string | null
    vi_description?: NullableStringFieldUpdateOperationsInput | string | null
    vi_etape?: NullableIntFieldUpdateOperationsInput | number | null
    vi_url?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type CommandeCreateInput = {
    co_date_creation?: Date | string
    co_date_update?: Date | string | null
    co_status?: string
    utilisateur: UtilisateurCreateNestedOneWithoutCommandeInput
  }

  export type CommandeUncheckedCreateInput = {
    co_id?: number
    co_utilisateur: number
    co_date_creation?: Date | string
    co_date_update?: Date | string | null
    co_status?: string
  }

  export type CommandeUpdateInput = {
    co_date_creation?: DateTimeFieldUpdateOperationsInput | Date | string
    co_date_update?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    co_status?: StringFieldUpdateOperationsInput | string
    utilisateur?: UtilisateurUpdateOneRequiredWithoutCommandeNestedInput
  }

  export type CommandeUncheckedUpdateInput = {
    co_id?: IntFieldUpdateOperationsInput | number
    co_utilisateur?: IntFieldUpdateOperationsInput | number
    co_date_creation?: DateTimeFieldUpdateOperationsInput | Date | string
    co_date_update?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    co_status?: StringFieldUpdateOperationsInput | string
  }

  export type CommandeCreateManyInput = {
    co_id?: number
    co_utilisateur: number
    co_date_creation?: Date | string
    co_date_update?: Date | string | null
    co_status?: string
  }

  export type CommandeUpdateManyMutationInput = {
    co_date_creation?: DateTimeFieldUpdateOperationsInput | Date | string
    co_date_update?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    co_status?: StringFieldUpdateOperationsInput | string
  }

  export type CommandeUncheckedUpdateManyInput = {
    co_id?: IntFieldUpdateOperationsInput | number
    co_utilisateur?: IntFieldUpdateOperationsInput | number
    co_date_creation?: DateTimeFieldUpdateOperationsInput | Date | string
    co_date_update?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    co_status?: StringFieldUpdateOperationsInput | string
  }

  export type CommandeFormationCreateInput = {
    formation: FormationCreateNestedOneWithoutCommandeFormationInput
  }

  export type CommandeFormationUncheckedCreateInput = {
    cof_id?: number
    cof_formation: number
  }

  export type CommandeFormationUpdateInput = {
    formation?: FormationUpdateOneRequiredWithoutCommandeFormationNestedInput
  }

  export type CommandeFormationUncheckedUpdateInput = {
    cof_id?: IntFieldUpdateOperationsInput | number
    cof_formation?: IntFieldUpdateOperationsInput | number
  }

  export type CommandeFormationCreateManyInput = {
    cof_id?: number
    cof_formation: number
  }

  export type CommandeFormationUpdateManyMutationInput = {

  }

  export type CommandeFormationUncheckedUpdateManyInput = {
    cof_id?: IntFieldUpdateOperationsInput | number
    cof_formation?: IntFieldUpdateOperationsInput | number
  }

  export type AchatCreateInput = {
    ac_type?: string | null
    ac_date_achat?: Date | string | null
    ac_date_fin?: Date | string | null
    utilisateur: UtilisateurCreateNestedOneWithoutAchatInput
    formation: FormationCreateNestedOneWithoutAchatInput
  }

  export type AchatUncheckedCreateInput = {
    ac_id?: number
    ac_utilisateur: number
    ac_formation: number
    ac_type?: string | null
    ac_date_achat?: Date | string | null
    ac_date_fin?: Date | string | null
  }

  export type AchatUpdateInput = {
    ac_type?: NullableStringFieldUpdateOperationsInput | string | null
    ac_date_achat?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    ac_date_fin?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    utilisateur?: UtilisateurUpdateOneRequiredWithoutAchatNestedInput
    formation?: FormationUpdateOneRequiredWithoutAchatNestedInput
  }

  export type AchatUncheckedUpdateInput = {
    ac_id?: IntFieldUpdateOperationsInput | number
    ac_utilisateur?: IntFieldUpdateOperationsInput | number
    ac_formation?: IntFieldUpdateOperationsInput | number
    ac_type?: NullableStringFieldUpdateOperationsInput | string | null
    ac_date_achat?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    ac_date_fin?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type AchatCreateManyInput = {
    ac_id?: number
    ac_utilisateur: number
    ac_formation: number
    ac_type?: string | null
    ac_date_achat?: Date | string | null
    ac_date_fin?: Date | string | null
  }

  export type AchatUpdateManyMutationInput = {
    ac_type?: NullableStringFieldUpdateOperationsInput | string | null
    ac_date_achat?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    ac_date_fin?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type AchatUncheckedUpdateManyInput = {
    ac_id?: IntFieldUpdateOperationsInput | number
    ac_utilisateur?: IntFieldUpdateOperationsInput | number
    ac_formation?: IntFieldUpdateOperationsInput | number
    ac_type?: NullableStringFieldUpdateOperationsInput | string | null
    ac_date_achat?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    ac_date_fin?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type TagCreateInput = {
    ta_titre?: string | null
    vi_tv?: TagVideoCreateNestedManyWithoutTagInput
  }

  export type TagUncheckedCreateInput = {
    ta_id?: number
    ta_titre?: string | null
    vi_tv?: TagVideoUncheckedCreateNestedManyWithoutTagInput
  }

  export type TagUpdateInput = {
    ta_titre?: NullableStringFieldUpdateOperationsInput | string | null
    vi_tv?: TagVideoUpdateManyWithoutTagNestedInput
  }

  export type TagUncheckedUpdateInput = {
    ta_id?: IntFieldUpdateOperationsInput | number
    ta_titre?: NullableStringFieldUpdateOperationsInput | string | null
    vi_tv?: TagVideoUncheckedUpdateManyWithoutTagNestedInput
  }

  export type TagCreateManyInput = {
    ta_id?: number
    ta_titre?: string | null
  }

  export type TagUpdateManyMutationInput = {
    ta_titre?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type TagUncheckedUpdateManyInput = {
    ta_id?: IntFieldUpdateOperationsInput | number
    ta_titre?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type TagVideoCreateInput = {
    tag: TagCreateNestedOneWithoutVi_tvInput
    video: VideoCreateNestedOneWithoutVi_tvInput
  }

  export type TagVideoUncheckedCreateInput = {
    tv_tag_id: number
    tv_video_id: number
  }

  export type TagVideoUpdateInput = {
    tag?: TagUpdateOneRequiredWithoutVi_tvNestedInput
    video?: VideoUpdateOneRequiredWithoutVi_tvNestedInput
  }

  export type TagVideoUncheckedUpdateInput = {
    tv_tag_id?: IntFieldUpdateOperationsInput | number
    tv_video_id?: IntFieldUpdateOperationsInput | number
  }

  export type TagVideoCreateManyInput = {
    tv_tag_id: number
    tv_video_id: number
  }

  export type TagVideoUpdateManyMutationInput = {

  }

  export type TagVideoUncheckedUpdateManyInput = {
    tv_tag_id?: IntFieldUpdateOperationsInput | number
    tv_video_id?: IntFieldUpdateOperationsInput | number
  }

  export type IntFilter<$PrismaModel = never> = {
    equals?: number | IntFieldRefInput<$PrismaModel>
    in?: number[]
    notIn?: number[]
    lt?: number | IntFieldRefInput<$PrismaModel>
    lte?: number | IntFieldRefInput<$PrismaModel>
    gt?: number | IntFieldRefInput<$PrismaModel>
    gte?: number | IntFieldRefInput<$PrismaModel>
    not?: NestedIntFilter<$PrismaModel> | number
  }

  export type StringNullableFilter<$PrismaModel = never> = {
    equals?: string | StringFieldRefInput<$PrismaModel> | null
    in?: string[] | null
    notIn?: string[] | 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>
    search?: string
    not?: NestedStringNullableFilter<$PrismaModel> | string | null
  }

  export type IntNullableFilter<$PrismaModel = never> = {
    equals?: number | IntFieldRefInput<$PrismaModel> | null
    in?: number[] | null
    notIn?: number[] | null
    lt?: number | IntFieldRefInput<$PrismaModel>
    lte?: number | IntFieldRefInput<$PrismaModel>
    gt?: number | IntFieldRefInput<$PrismaModel>
    gte?: number | IntFieldRefInput<$PrismaModel>
    not?: NestedIntNullableFilter<$PrismaModel> | number | null
  }

  export type DateTimeNullableFilter<$PrismaModel = never> = {
    equals?: Date | string | DateTimeFieldRefInput<$PrismaModel> | null
    in?: Date[] | string[] | null
    notIn?: Date[] | string[] | 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 DateTimeFilter<$PrismaModel = never> = {
    equals?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    in?: Date[] | string[]
    notIn?: Date[] | string[]
    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 CommandeListRelationFilter = {
    every?: CommandeWhereInput
    some?: CommandeWhereInput
    none?: CommandeWhereInput
  }

  export type AchatListRelationFilter = {
    every?: AchatWhereInput
    some?: AchatWhereInput
    none?: AchatWhereInput
  }

  export type SortOrderInput = {
    sort: SortOrder
    nulls?: NullsOrder
  }

  export type CommandeOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type AchatOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type UtilisateurOrderByRelevanceInput = {
    fields: UtilisateurOrderByRelevanceFieldEnum | UtilisateurOrderByRelevanceFieldEnum[]
    sort: SortOrder
    search: string
  }

  export type UtilisateurCountOrderByAggregateInput = {
    ut_id?: SortOrder
    ut_nom?: SortOrder
    ut_prenom?: SortOrder
    ut_mail?: SortOrder
    ut_type_cliente?: SortOrder
    ut_age?: SortOrder
    ut_nb_rdv?: SortOrder
    ut_nb_rdv_honores?: SortOrder
    ut_prix_moyen?: SortOrder
    ut_pdp?: SortOrder
    ut_panier?: SortOrder
    ut_mdp?: SortOrder
    ut_telephone?: SortOrder
    ut_date_inscription?: SortOrder
    ut_derniere_connexion?: SortOrder
  }

  export type UtilisateurAvgOrderByAggregateInput = {
    ut_id?: SortOrder
    ut_type_cliente?: SortOrder
    ut_nb_rdv?: SortOrder
    ut_nb_rdv_honores?: SortOrder
    ut_prix_moyen?: SortOrder
    ut_pdp?: SortOrder
    ut_panier?: SortOrder
    ut_mdp?: SortOrder
    ut_telephone?: SortOrder
  }

  export type UtilisateurMaxOrderByAggregateInput = {
    ut_id?: SortOrder
    ut_nom?: SortOrder
    ut_prenom?: SortOrder
    ut_mail?: SortOrder
    ut_type_cliente?: SortOrder
    ut_age?: SortOrder
    ut_nb_rdv?: SortOrder
    ut_nb_rdv_honores?: SortOrder
    ut_prix_moyen?: SortOrder
    ut_pdp?: SortOrder
    ut_panier?: SortOrder
    ut_mdp?: SortOrder
    ut_telephone?: SortOrder
    ut_date_inscription?: SortOrder
    ut_derniere_connexion?: SortOrder
  }

  export type UtilisateurMinOrderByAggregateInput = {
    ut_id?: SortOrder
    ut_nom?: SortOrder
    ut_prenom?: SortOrder
    ut_mail?: SortOrder
    ut_type_cliente?: SortOrder
    ut_age?: SortOrder
    ut_nb_rdv?: SortOrder
    ut_nb_rdv_honores?: SortOrder
    ut_prix_moyen?: SortOrder
    ut_pdp?: SortOrder
    ut_panier?: SortOrder
    ut_mdp?: SortOrder
    ut_telephone?: SortOrder
    ut_date_inscription?: SortOrder
    ut_derniere_connexion?: SortOrder
  }

  export type UtilisateurSumOrderByAggregateInput = {
    ut_id?: SortOrder
    ut_type_cliente?: SortOrder
    ut_nb_rdv?: SortOrder
    ut_nb_rdv_honores?: SortOrder
    ut_prix_moyen?: SortOrder
    ut_pdp?: SortOrder
    ut_panier?: SortOrder
    ut_mdp?: SortOrder
    ut_telephone?: SortOrder
  }

  export type IntWithAggregatesFilter<$PrismaModel = never> = {
    equals?: number | IntFieldRefInput<$PrismaModel>
    in?: number[]
    notIn?: number[]
    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 StringNullableWithAggregatesFilter<$PrismaModel = never> = {
    equals?: string | StringFieldRefInput<$PrismaModel> | null
    in?: string[] | null
    notIn?: string[] | 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>
    search?: string
    not?: NestedStringNullableWithAggregatesFilter<$PrismaModel> | string | null
    _count?: NestedIntNullableFilter<$PrismaModel>
    _min?: NestedStringNullableFilter<$PrismaModel>
    _max?: NestedStringNullableFilter<$PrismaModel>
  }

  export type IntNullableWithAggregatesFilter<$PrismaModel = never> = {
    equals?: number | IntFieldRefInput<$PrismaModel> | null
    in?: number[] | null
    notIn?: number[] | 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 DateTimeNullableWithAggregatesFilter<$PrismaModel = never> = {
    equals?: Date | string | DateTimeFieldRefInput<$PrismaModel> | null
    in?: Date[] | string[] | null
    notIn?: Date[] | string[] | 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 DateTimeWithAggregatesFilter<$PrismaModel = never> = {
    equals?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    in?: Date[] | string[]
    notIn?: Date[] | string[]
    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 BytesNullableFilter<$PrismaModel = never> = {
    equals?: Uint8Array | BytesFieldRefInput<$PrismaModel> | null
    in?: Uint8Array[] | null
    notIn?: Uint8Array[] | null
    not?: NestedBytesNullableFilter<$PrismaModel> | Uint8Array | null
  }

  export type VideoListRelationFilter = {
    every?: VideoWhereInput
    some?: VideoWhereInput
    none?: VideoWhereInput
  }

  export type CommandeFormationListRelationFilter = {
    every?: CommandeFormationWhereInput
    some?: CommandeFormationWhereInput
    none?: CommandeFormationWhereInput
  }

  export type VideoOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type CommandeFormationOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type FormationOrderByRelevanceInput = {
    fields: FormationOrderByRelevanceFieldEnum | FormationOrderByRelevanceFieldEnum[]
    sort: SortOrder
    search: string
  }

  export type FormationCountOrderByAggregateInput = {
    fo_id?: SortOrder
    fo_titre?: SortOrder
    fo_description?: SortOrder
    fo_prix?: SortOrder
    fo_miniature?: SortOrder
    fo_teaser?: SortOrder
    fo_date_publication?: SortOrder
  }

  export type FormationAvgOrderByAggregateInput = {
    fo_id?: SortOrder
  }

  export type FormationMaxOrderByAggregateInput = {
    fo_id?: SortOrder
    fo_titre?: SortOrder
    fo_description?: SortOrder
    fo_prix?: SortOrder
    fo_miniature?: SortOrder
    fo_teaser?: SortOrder
    fo_date_publication?: SortOrder
  }

  export type FormationMinOrderByAggregateInput = {
    fo_id?: SortOrder
    fo_titre?: SortOrder
    fo_description?: SortOrder
    fo_prix?: SortOrder
    fo_miniature?: SortOrder
    fo_teaser?: SortOrder
    fo_date_publication?: SortOrder
  }

  export type FormationSumOrderByAggregateInput = {
    fo_id?: SortOrder
  }

  export type BytesNullableWithAggregatesFilter<$PrismaModel = never> = {
    equals?: Uint8Array | BytesFieldRefInput<$PrismaModel> | null
    in?: Uint8Array[] | null
    notIn?: Uint8Array[] | null
    not?: NestedBytesNullableWithAggregatesFilter<$PrismaModel> | Uint8Array | null
    _count?: NestedIntNullableFilter<$PrismaModel>
    _min?: NestedBytesNullableFilter<$PrismaModel>
    _max?: NestedBytesNullableFilter<$PrismaModel>
  }

  export type FormationScalarRelationFilter = {
    is?: FormationWhereInput
    isNot?: FormationWhereInput
  }

  export type TagVideoListRelationFilter = {
    every?: TagVideoWhereInput
    some?: TagVideoWhereInput
    none?: TagVideoWhereInput
  }

  export type TagVideoOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type VideoOrderByRelevanceInput = {
    fields: VideoOrderByRelevanceFieldEnum | VideoOrderByRelevanceFieldEnum[]
    sort: SortOrder
    search: string
  }

  export type VideoCountOrderByAggregateInput = {
    vi_fo_id?: SortOrder
    vi_id?: SortOrder
    vi_titre?: SortOrder
    vi_description?: SortOrder
    vi_etape?: SortOrder
    vi_url?: SortOrder
  }

  export type VideoAvgOrderByAggregateInput = {
    vi_fo_id?: SortOrder
    vi_id?: SortOrder
    vi_etape?: SortOrder
  }

  export type VideoMaxOrderByAggregateInput = {
    vi_fo_id?: SortOrder
    vi_id?: SortOrder
    vi_titre?: SortOrder
    vi_description?: SortOrder
    vi_etape?: SortOrder
    vi_url?: SortOrder
  }

  export type VideoMinOrderByAggregateInput = {
    vi_fo_id?: SortOrder
    vi_id?: SortOrder
    vi_titre?: SortOrder
    vi_description?: SortOrder
    vi_etape?: SortOrder
    vi_url?: SortOrder
  }

  export type VideoSumOrderByAggregateInput = {
    vi_fo_id?: SortOrder
    vi_id?: SortOrder
    vi_etape?: SortOrder
  }

  export type StringFilter<$PrismaModel = never> = {
    equals?: string | StringFieldRefInput<$PrismaModel>
    in?: string[]
    notIn?: string[]
    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>
    search?: string
    not?: NestedStringFilter<$PrismaModel> | string
  }

  export type UtilisateurScalarRelationFilter = {
    is?: UtilisateurWhereInput
    isNot?: UtilisateurWhereInput
  }

  export type CommandeOrderByRelevanceInput = {
    fields: CommandeOrderByRelevanceFieldEnum | CommandeOrderByRelevanceFieldEnum[]
    sort: SortOrder
    search: string
  }

  export type CommandeCountOrderByAggregateInput = {
    co_id?: SortOrder
    co_utilisateur?: SortOrder
    co_date_creation?: SortOrder
    co_date_update?: SortOrder
    co_status?: SortOrder
  }

  export type CommandeAvgOrderByAggregateInput = {
    co_id?: SortOrder
    co_utilisateur?: SortOrder
  }

  export type CommandeMaxOrderByAggregateInput = {
    co_id?: SortOrder
    co_utilisateur?: SortOrder
    co_date_creation?: SortOrder
    co_date_update?: SortOrder
    co_status?: SortOrder
  }

  export type CommandeMinOrderByAggregateInput = {
    co_id?: SortOrder
    co_utilisateur?: SortOrder
    co_date_creation?: SortOrder
    co_date_update?: SortOrder
    co_status?: SortOrder
  }

  export type CommandeSumOrderByAggregateInput = {
    co_id?: SortOrder
    co_utilisateur?: SortOrder
  }

  export type StringWithAggregatesFilter<$PrismaModel = never> = {
    equals?: string | StringFieldRefInput<$PrismaModel>
    in?: string[]
    notIn?: string[]
    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>
    search?: string
    not?: NestedStringWithAggregatesFilter<$PrismaModel> | string
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedStringFilter<$PrismaModel>
    _max?: NestedStringFilter<$PrismaModel>
  }

  export type CommandeFormationCountOrderByAggregateInput = {
    cof_id?: SortOrder
    cof_formation?: SortOrder
  }

  export type CommandeFormationAvgOrderByAggregateInput = {
    cof_id?: SortOrder
    cof_formation?: SortOrder
  }

  export type CommandeFormationMaxOrderByAggregateInput = {
    cof_id?: SortOrder
    cof_formation?: SortOrder
  }

  export type CommandeFormationMinOrderByAggregateInput = {
    cof_id?: SortOrder
    cof_formation?: SortOrder
  }

  export type CommandeFormationSumOrderByAggregateInput = {
    cof_id?: SortOrder
    cof_formation?: SortOrder
  }

  export type AchatOrderByRelevanceInput = {
    fields: AchatOrderByRelevanceFieldEnum | AchatOrderByRelevanceFieldEnum[]
    sort: SortOrder
    search: string
  }

  export type AchatCountOrderByAggregateInput = {
    ac_id?: SortOrder
    ac_utilisateur?: SortOrder
    ac_formation?: SortOrder
    ac_type?: SortOrder
    ac_date_achat?: SortOrder
    ac_date_fin?: SortOrder
  }

  export type AchatAvgOrderByAggregateInput = {
    ac_id?: SortOrder
    ac_utilisateur?: SortOrder
    ac_formation?: SortOrder
  }

  export type AchatMaxOrderByAggregateInput = {
    ac_id?: SortOrder
    ac_utilisateur?: SortOrder
    ac_formation?: SortOrder
    ac_type?: SortOrder
    ac_date_achat?: SortOrder
    ac_date_fin?: SortOrder
  }

  export type AchatMinOrderByAggregateInput = {
    ac_id?: SortOrder
    ac_utilisateur?: SortOrder
    ac_formation?: SortOrder
    ac_type?: SortOrder
    ac_date_achat?: SortOrder
    ac_date_fin?: SortOrder
  }

  export type AchatSumOrderByAggregateInput = {
    ac_id?: SortOrder
    ac_utilisateur?: SortOrder
    ac_formation?: SortOrder
  }

  export type TagOrderByRelevanceInput = {
    fields: TagOrderByRelevanceFieldEnum | TagOrderByRelevanceFieldEnum[]
    sort: SortOrder
    search: string
  }

  export type TagCountOrderByAggregateInput = {
    ta_id?: SortOrder
    ta_titre?: SortOrder
  }

  export type TagAvgOrderByAggregateInput = {
    ta_id?: SortOrder
  }

  export type TagMaxOrderByAggregateInput = {
    ta_id?: SortOrder
    ta_titre?: SortOrder
  }

  export type TagMinOrderByAggregateInput = {
    ta_id?: SortOrder
    ta_titre?: SortOrder
  }

  export type TagSumOrderByAggregateInput = {
    ta_id?: SortOrder
  }

  export type TagScalarRelationFilter = {
    is?: TagWhereInput
    isNot?: TagWhereInput
  }

  export type VideoScalarRelationFilter = {
    is?: VideoWhereInput
    isNot?: VideoWhereInput
  }

  export type TagVideoTv_tag_idTv_video_idCompoundUniqueInput = {
    tv_tag_id: number
    tv_video_id: number
  }

  export type TagVideoCountOrderByAggregateInput = {
    tv_tag_id?: SortOrder
    tv_video_id?: SortOrder
  }

  export type TagVideoAvgOrderByAggregateInput = {
    tv_tag_id?: SortOrder
    tv_video_id?: SortOrder
  }

  export type TagVideoMaxOrderByAggregateInput = {
    tv_tag_id?: SortOrder
    tv_video_id?: SortOrder
  }

  export type TagVideoMinOrderByAggregateInput = {
    tv_tag_id?: SortOrder
    tv_video_id?: SortOrder
  }

  export type TagVideoSumOrderByAggregateInput = {
    tv_tag_id?: SortOrder
    tv_video_id?: SortOrder
  }

  export type CommandeCreateNestedManyWithoutUtilisateurInput = {
    create?: XOR<CommandeCreateWithoutUtilisateurInput, CommandeUncheckedCreateWithoutUtilisateurInput> | CommandeCreateWithoutUtilisateurInput[] | CommandeUncheckedCreateWithoutUtilisateurInput[]
    connectOrCreate?: CommandeCreateOrConnectWithoutUtilisateurInput | CommandeCreateOrConnectWithoutUtilisateurInput[]
    createMany?: CommandeCreateManyUtilisateurInputEnvelope
    connect?: CommandeWhereUniqueInput | CommandeWhereUniqueInput[]
  }

  export type AchatCreateNestedManyWithoutUtilisateurInput = {
    create?: XOR<AchatCreateWithoutUtilisateurInput, AchatUncheckedCreateWithoutUtilisateurInput> | AchatCreateWithoutUtilisateurInput[] | AchatUncheckedCreateWithoutUtilisateurInput[]
    connectOrCreate?: AchatCreateOrConnectWithoutUtilisateurInput | AchatCreateOrConnectWithoutUtilisateurInput[]
    createMany?: AchatCreateManyUtilisateurInputEnvelope
    connect?: AchatWhereUniqueInput | AchatWhereUniqueInput[]
  }

  export type CommandeUncheckedCreateNestedManyWithoutUtilisateurInput = {
    create?: XOR<CommandeCreateWithoutUtilisateurInput, CommandeUncheckedCreateWithoutUtilisateurInput> | CommandeCreateWithoutUtilisateurInput[] | CommandeUncheckedCreateWithoutUtilisateurInput[]
    connectOrCreate?: CommandeCreateOrConnectWithoutUtilisateurInput | CommandeCreateOrConnectWithoutUtilisateurInput[]
    createMany?: CommandeCreateManyUtilisateurInputEnvelope
    connect?: CommandeWhereUniqueInput | CommandeWhereUniqueInput[]
  }

  export type AchatUncheckedCreateNestedManyWithoutUtilisateurInput = {
    create?: XOR<AchatCreateWithoutUtilisateurInput, AchatUncheckedCreateWithoutUtilisateurInput> | AchatCreateWithoutUtilisateurInput[] | AchatUncheckedCreateWithoutUtilisateurInput[]
    connectOrCreate?: AchatCreateOrConnectWithoutUtilisateurInput | AchatCreateOrConnectWithoutUtilisateurInput[]
    createMany?: AchatCreateManyUtilisateurInputEnvelope
    connect?: AchatWhereUniqueInput | AchatWhereUniqueInput[]
  }

  export type NullableStringFieldUpdateOperationsInput = {
    set?: string | null
  }

  export type NullableIntFieldUpdateOperationsInput = {
    set?: number | null
    increment?: number
    decrement?: number
    multiply?: number
    divide?: number
  }

  export type NullableDateTimeFieldUpdateOperationsInput = {
    set?: Date | string | null
  }

  export type DateTimeFieldUpdateOperationsInput = {
    set?: Date | string
  }

  export type CommandeUpdateManyWithoutUtilisateurNestedInput = {
    create?: XOR<CommandeCreateWithoutUtilisateurInput, CommandeUncheckedCreateWithoutUtilisateurInput> | CommandeCreateWithoutUtilisateurInput[] | CommandeUncheckedCreateWithoutUtilisateurInput[]
    connectOrCreate?: CommandeCreateOrConnectWithoutUtilisateurInput | CommandeCreateOrConnectWithoutUtilisateurInput[]
    upsert?: CommandeUpsertWithWhereUniqueWithoutUtilisateurInput | CommandeUpsertWithWhereUniqueWithoutUtilisateurInput[]
    createMany?: CommandeCreateManyUtilisateurInputEnvelope
    set?: CommandeWhereUniqueInput | CommandeWhereUniqueInput[]
    disconnect?: CommandeWhereUniqueInput | CommandeWhereUniqueInput[]
    delete?: CommandeWhereUniqueInput | CommandeWhereUniqueInput[]
    connect?: CommandeWhereUniqueInput | CommandeWhereUniqueInput[]
    update?: CommandeUpdateWithWhereUniqueWithoutUtilisateurInput | CommandeUpdateWithWhereUniqueWithoutUtilisateurInput[]
    updateMany?: CommandeUpdateManyWithWhereWithoutUtilisateurInput | CommandeUpdateManyWithWhereWithoutUtilisateurInput[]
    deleteMany?: CommandeScalarWhereInput | CommandeScalarWhereInput[]
  }

  export type AchatUpdateManyWithoutUtilisateurNestedInput = {
    create?: XOR<AchatCreateWithoutUtilisateurInput, AchatUncheckedCreateWithoutUtilisateurInput> | AchatCreateWithoutUtilisateurInput[] | AchatUncheckedCreateWithoutUtilisateurInput[]
    connectOrCreate?: AchatCreateOrConnectWithoutUtilisateurInput | AchatCreateOrConnectWithoutUtilisateurInput[]
    upsert?: AchatUpsertWithWhereUniqueWithoutUtilisateurInput | AchatUpsertWithWhereUniqueWithoutUtilisateurInput[]
    createMany?: AchatCreateManyUtilisateurInputEnvelope
    set?: AchatWhereUniqueInput | AchatWhereUniqueInput[]
    disconnect?: AchatWhereUniqueInput | AchatWhereUniqueInput[]
    delete?: AchatWhereUniqueInput | AchatWhereUniqueInput[]
    connect?: AchatWhereUniqueInput | AchatWhereUniqueInput[]
    update?: AchatUpdateWithWhereUniqueWithoutUtilisateurInput | AchatUpdateWithWhereUniqueWithoutUtilisateurInput[]
    updateMany?: AchatUpdateManyWithWhereWithoutUtilisateurInput | AchatUpdateManyWithWhereWithoutUtilisateurInput[]
    deleteMany?: AchatScalarWhereInput | AchatScalarWhereInput[]
  }

  export type IntFieldUpdateOperationsInput = {
    set?: number
    increment?: number
    decrement?: number
    multiply?: number
    divide?: number
  }

  export type CommandeUncheckedUpdateManyWithoutUtilisateurNestedInput = {
    create?: XOR<CommandeCreateWithoutUtilisateurInput, CommandeUncheckedCreateWithoutUtilisateurInput> | CommandeCreateWithoutUtilisateurInput[] | CommandeUncheckedCreateWithoutUtilisateurInput[]
    connectOrCreate?: CommandeCreateOrConnectWithoutUtilisateurInput | CommandeCreateOrConnectWithoutUtilisateurInput[]
    upsert?: CommandeUpsertWithWhereUniqueWithoutUtilisateurInput | CommandeUpsertWithWhereUniqueWithoutUtilisateurInput[]
    createMany?: CommandeCreateManyUtilisateurInputEnvelope
    set?: CommandeWhereUniqueInput | CommandeWhereUniqueInput[]
    disconnect?: CommandeWhereUniqueInput | CommandeWhereUniqueInput[]
    delete?: CommandeWhereUniqueInput | CommandeWhereUniqueInput[]
    connect?: CommandeWhereUniqueInput | CommandeWhereUniqueInput[]
    update?: CommandeUpdateWithWhereUniqueWithoutUtilisateurInput | CommandeUpdateWithWhereUniqueWithoutUtilisateurInput[]
    updateMany?: CommandeUpdateManyWithWhereWithoutUtilisateurInput | CommandeUpdateManyWithWhereWithoutUtilisateurInput[]
    deleteMany?: CommandeScalarWhereInput | CommandeScalarWhereInput[]
  }

  export type AchatUncheckedUpdateManyWithoutUtilisateurNestedInput = {
    create?: XOR<AchatCreateWithoutUtilisateurInput, AchatUncheckedCreateWithoutUtilisateurInput> | AchatCreateWithoutUtilisateurInput[] | AchatUncheckedCreateWithoutUtilisateurInput[]
    connectOrCreate?: AchatCreateOrConnectWithoutUtilisateurInput | AchatCreateOrConnectWithoutUtilisateurInput[]
    upsert?: AchatUpsertWithWhereUniqueWithoutUtilisateurInput | AchatUpsertWithWhereUniqueWithoutUtilisateurInput[]
    createMany?: AchatCreateManyUtilisateurInputEnvelope
    set?: AchatWhereUniqueInput | AchatWhereUniqueInput[]
    disconnect?: AchatWhereUniqueInput | AchatWhereUniqueInput[]
    delete?: AchatWhereUniqueInput | AchatWhereUniqueInput[]
    connect?: AchatWhereUniqueInput | AchatWhereUniqueInput[]
    update?: AchatUpdateWithWhereUniqueWithoutUtilisateurInput | AchatUpdateWithWhereUniqueWithoutUtilisateurInput[]
    updateMany?: AchatUpdateManyWithWhereWithoutUtilisateurInput | AchatUpdateManyWithWhereWithoutUtilisateurInput[]
    deleteMany?: AchatScalarWhereInput | AchatScalarWhereInput[]
  }

  export type VideoCreateNestedManyWithoutFormationInput = {
    create?: XOR<VideoCreateWithoutFormationInput, VideoUncheckedCreateWithoutFormationInput> | VideoCreateWithoutFormationInput[] | VideoUncheckedCreateWithoutFormationInput[]
    connectOrCreate?: VideoCreateOrConnectWithoutFormationInput | VideoCreateOrConnectWithoutFormationInput[]
    createMany?: VideoCreateManyFormationInputEnvelope
    connect?: VideoWhereUniqueInput | VideoWhereUniqueInput[]
  }

  export type CommandeFormationCreateNestedManyWithoutFormationInput = {
    create?: XOR<CommandeFormationCreateWithoutFormationInput, CommandeFormationUncheckedCreateWithoutFormationInput> | CommandeFormationCreateWithoutFormationInput[] | CommandeFormationUncheckedCreateWithoutFormationInput[]
    connectOrCreate?: CommandeFormationCreateOrConnectWithoutFormationInput | CommandeFormationCreateOrConnectWithoutFormationInput[]
    createMany?: CommandeFormationCreateManyFormationInputEnvelope
    connect?: CommandeFormationWhereUniqueInput | CommandeFormationWhereUniqueInput[]
  }

  export type AchatCreateNestedManyWithoutFormationInput = {
    create?: XOR<AchatCreateWithoutFormationInput, AchatUncheckedCreateWithoutFormationInput> | AchatCreateWithoutFormationInput[] | AchatUncheckedCreateWithoutFormationInput[]
    connectOrCreate?: AchatCreateOrConnectWithoutFormationInput | AchatCreateOrConnectWithoutFormationInput[]
    createMany?: AchatCreateManyFormationInputEnvelope
    connect?: AchatWhereUniqueInput | AchatWhereUniqueInput[]
  }

  export type VideoUncheckedCreateNestedManyWithoutFormationInput = {
    create?: XOR<VideoCreateWithoutFormationInput, VideoUncheckedCreateWithoutFormationInput> | VideoCreateWithoutFormationInput[] | VideoUncheckedCreateWithoutFormationInput[]
    connectOrCreate?: VideoCreateOrConnectWithoutFormationInput | VideoCreateOrConnectWithoutFormationInput[]
    createMany?: VideoCreateManyFormationInputEnvelope
    connect?: VideoWhereUniqueInput | VideoWhereUniqueInput[]
  }

  export type CommandeFormationUncheckedCreateNestedManyWithoutFormationInput = {
    create?: XOR<CommandeFormationCreateWithoutFormationInput, CommandeFormationUncheckedCreateWithoutFormationInput> | CommandeFormationCreateWithoutFormationInput[] | CommandeFormationUncheckedCreateWithoutFormationInput[]
    connectOrCreate?: CommandeFormationCreateOrConnectWithoutFormationInput | CommandeFormationCreateOrConnectWithoutFormationInput[]
    createMany?: CommandeFormationCreateManyFormationInputEnvelope
    connect?: CommandeFormationWhereUniqueInput | CommandeFormationWhereUniqueInput[]
  }

  export type AchatUncheckedCreateNestedManyWithoutFormationInput = {
    create?: XOR<AchatCreateWithoutFormationInput, AchatUncheckedCreateWithoutFormationInput> | AchatCreateWithoutFormationInput[] | AchatUncheckedCreateWithoutFormationInput[]
    connectOrCreate?: AchatCreateOrConnectWithoutFormationInput | AchatCreateOrConnectWithoutFormationInput[]
    createMany?: AchatCreateManyFormationInputEnvelope
    connect?: AchatWhereUniqueInput | AchatWhereUniqueInput[]
  }

  export type NullableBytesFieldUpdateOperationsInput = {
    set?: Uint8Array | null
  }

  export type VideoUpdateManyWithoutFormationNestedInput = {
    create?: XOR<VideoCreateWithoutFormationInput, VideoUncheckedCreateWithoutFormationInput> | VideoCreateWithoutFormationInput[] | VideoUncheckedCreateWithoutFormationInput[]
    connectOrCreate?: VideoCreateOrConnectWithoutFormationInput | VideoCreateOrConnectWithoutFormationInput[]
    upsert?: VideoUpsertWithWhereUniqueWithoutFormationInput | VideoUpsertWithWhereUniqueWithoutFormationInput[]
    createMany?: VideoCreateManyFormationInputEnvelope
    set?: VideoWhereUniqueInput | VideoWhereUniqueInput[]
    disconnect?: VideoWhereUniqueInput | VideoWhereUniqueInput[]
    delete?: VideoWhereUniqueInput | VideoWhereUniqueInput[]
    connect?: VideoWhereUniqueInput | VideoWhereUniqueInput[]
    update?: VideoUpdateWithWhereUniqueWithoutFormationInput | VideoUpdateWithWhereUniqueWithoutFormationInput[]
    updateMany?: VideoUpdateManyWithWhereWithoutFormationInput | VideoUpdateManyWithWhereWithoutFormationInput[]
    deleteMany?: VideoScalarWhereInput | VideoScalarWhereInput[]
  }

  export type CommandeFormationUpdateManyWithoutFormationNestedInput = {
    create?: XOR<CommandeFormationCreateWithoutFormationInput, CommandeFormationUncheckedCreateWithoutFormationInput> | CommandeFormationCreateWithoutFormationInput[] | CommandeFormationUncheckedCreateWithoutFormationInput[]
    connectOrCreate?: CommandeFormationCreateOrConnectWithoutFormationInput | CommandeFormationCreateOrConnectWithoutFormationInput[]
    upsert?: CommandeFormationUpsertWithWhereUniqueWithoutFormationInput | CommandeFormationUpsertWithWhereUniqueWithoutFormationInput[]
    createMany?: CommandeFormationCreateManyFormationInputEnvelope
    set?: CommandeFormationWhereUniqueInput | CommandeFormationWhereUniqueInput[]
    disconnect?: CommandeFormationWhereUniqueInput | CommandeFormationWhereUniqueInput[]
    delete?: CommandeFormationWhereUniqueInput | CommandeFormationWhereUniqueInput[]
    connect?: CommandeFormationWhereUniqueInput | CommandeFormationWhereUniqueInput[]
    update?: CommandeFormationUpdateWithWhereUniqueWithoutFormationInput | CommandeFormationUpdateWithWhereUniqueWithoutFormationInput[]
    updateMany?: CommandeFormationUpdateManyWithWhereWithoutFormationInput | CommandeFormationUpdateManyWithWhereWithoutFormationInput[]
    deleteMany?: CommandeFormationScalarWhereInput | CommandeFormationScalarWhereInput[]
  }

  export type AchatUpdateManyWithoutFormationNestedInput = {
    create?: XOR<AchatCreateWithoutFormationInput, AchatUncheckedCreateWithoutFormationInput> | AchatCreateWithoutFormationInput[] | AchatUncheckedCreateWithoutFormationInput[]
    connectOrCreate?: AchatCreateOrConnectWithoutFormationInput | AchatCreateOrConnectWithoutFormationInput[]
    upsert?: AchatUpsertWithWhereUniqueWithoutFormationInput | AchatUpsertWithWhereUniqueWithoutFormationInput[]
    createMany?: AchatCreateManyFormationInputEnvelope
    set?: AchatWhereUniqueInput | AchatWhereUniqueInput[]
    disconnect?: AchatWhereUniqueInput | AchatWhereUniqueInput[]
    delete?: AchatWhereUniqueInput | AchatWhereUniqueInput[]
    connect?: AchatWhereUniqueInput | AchatWhereUniqueInput[]
    update?: AchatUpdateWithWhereUniqueWithoutFormationInput | AchatUpdateWithWhereUniqueWithoutFormationInput[]
    updateMany?: AchatUpdateManyWithWhereWithoutFormationInput | AchatUpdateManyWithWhereWithoutFormationInput[]
    deleteMany?: AchatScalarWhereInput | AchatScalarWhereInput[]
  }

  export type VideoUncheckedUpdateManyWithoutFormationNestedInput = {
    create?: XOR<VideoCreateWithoutFormationInput, VideoUncheckedCreateWithoutFormationInput> | VideoCreateWithoutFormationInput[] | VideoUncheckedCreateWithoutFormationInput[]
    connectOrCreate?: VideoCreateOrConnectWithoutFormationInput | VideoCreateOrConnectWithoutFormationInput[]
    upsert?: VideoUpsertWithWhereUniqueWithoutFormationInput | VideoUpsertWithWhereUniqueWithoutFormationInput[]
    createMany?: VideoCreateManyFormationInputEnvelope
    set?: VideoWhereUniqueInput | VideoWhereUniqueInput[]
    disconnect?: VideoWhereUniqueInput | VideoWhereUniqueInput[]
    delete?: VideoWhereUniqueInput | VideoWhereUniqueInput[]
    connect?: VideoWhereUniqueInput | VideoWhereUniqueInput[]
    update?: VideoUpdateWithWhereUniqueWithoutFormationInput | VideoUpdateWithWhereUniqueWithoutFormationInput[]
    updateMany?: VideoUpdateManyWithWhereWithoutFormationInput | VideoUpdateManyWithWhereWithoutFormationInput[]
    deleteMany?: VideoScalarWhereInput | VideoScalarWhereInput[]
  }

  export type CommandeFormationUncheckedUpdateManyWithoutFormationNestedInput = {
    create?: XOR<CommandeFormationCreateWithoutFormationInput, CommandeFormationUncheckedCreateWithoutFormationInput> | CommandeFormationCreateWithoutFormationInput[] | CommandeFormationUncheckedCreateWithoutFormationInput[]
    connectOrCreate?: CommandeFormationCreateOrConnectWithoutFormationInput | CommandeFormationCreateOrConnectWithoutFormationInput[]
    upsert?: CommandeFormationUpsertWithWhereUniqueWithoutFormationInput | CommandeFormationUpsertWithWhereUniqueWithoutFormationInput[]
    createMany?: CommandeFormationCreateManyFormationInputEnvelope
    set?: CommandeFormationWhereUniqueInput | CommandeFormationWhereUniqueInput[]
    disconnect?: CommandeFormationWhereUniqueInput | CommandeFormationWhereUniqueInput[]
    delete?: CommandeFormationWhereUniqueInput | CommandeFormationWhereUniqueInput[]
    connect?: CommandeFormationWhereUniqueInput | CommandeFormationWhereUniqueInput[]
    update?: CommandeFormationUpdateWithWhereUniqueWithoutFormationInput | CommandeFormationUpdateWithWhereUniqueWithoutFormationInput[]
    updateMany?: CommandeFormationUpdateManyWithWhereWithoutFormationInput | CommandeFormationUpdateManyWithWhereWithoutFormationInput[]
    deleteMany?: CommandeFormationScalarWhereInput | CommandeFormationScalarWhereInput[]
  }

  export type AchatUncheckedUpdateManyWithoutFormationNestedInput = {
    create?: XOR<AchatCreateWithoutFormationInput, AchatUncheckedCreateWithoutFormationInput> | AchatCreateWithoutFormationInput[] | AchatUncheckedCreateWithoutFormationInput[]
    connectOrCreate?: AchatCreateOrConnectWithoutFormationInput | AchatCreateOrConnectWithoutFormationInput[]
    upsert?: AchatUpsertWithWhereUniqueWithoutFormationInput | AchatUpsertWithWhereUniqueWithoutFormationInput[]
    createMany?: AchatCreateManyFormationInputEnvelope
    set?: AchatWhereUniqueInput | AchatWhereUniqueInput[]
    disconnect?: AchatWhereUniqueInput | AchatWhereUniqueInput[]
    delete?: AchatWhereUniqueInput | AchatWhereUniqueInput[]
    connect?: AchatWhereUniqueInput | AchatWhereUniqueInput[]
    update?: AchatUpdateWithWhereUniqueWithoutFormationInput | AchatUpdateWithWhereUniqueWithoutFormationInput[]
    updateMany?: AchatUpdateManyWithWhereWithoutFormationInput | AchatUpdateManyWithWhereWithoutFormationInput[]
    deleteMany?: AchatScalarWhereInput | AchatScalarWhereInput[]
  }

  export type FormationCreateNestedOneWithoutFo_videoInput = {
    create?: XOR<FormationCreateWithoutFo_videoInput, FormationUncheckedCreateWithoutFo_videoInput>
    connectOrCreate?: FormationCreateOrConnectWithoutFo_videoInput
    connect?: FormationWhereUniqueInput
  }

  export type TagVideoCreateNestedManyWithoutVideoInput = {
    create?: XOR<TagVideoCreateWithoutVideoInput, TagVideoUncheckedCreateWithoutVideoInput> | TagVideoCreateWithoutVideoInput[] | TagVideoUncheckedCreateWithoutVideoInput[]
    connectOrCreate?: TagVideoCreateOrConnectWithoutVideoInput | TagVideoCreateOrConnectWithoutVideoInput[]
    createMany?: TagVideoCreateManyVideoInputEnvelope
    connect?: TagVideoWhereUniqueInput | TagVideoWhereUniqueInput[]
  }

  export type TagVideoUncheckedCreateNestedManyWithoutVideoInput = {
    create?: XOR<TagVideoCreateWithoutVideoInput, TagVideoUncheckedCreateWithoutVideoInput> | TagVideoCreateWithoutVideoInput[] | TagVideoUncheckedCreateWithoutVideoInput[]
    connectOrCreate?: TagVideoCreateOrConnectWithoutVideoInput | TagVideoCreateOrConnectWithoutVideoInput[]
    createMany?: TagVideoCreateManyVideoInputEnvelope
    connect?: TagVideoWhereUniqueInput | TagVideoWhereUniqueInput[]
  }

  export type FormationUpdateOneRequiredWithoutFo_videoNestedInput = {
    create?: XOR<FormationCreateWithoutFo_videoInput, FormationUncheckedCreateWithoutFo_videoInput>
    connectOrCreate?: FormationCreateOrConnectWithoutFo_videoInput
    upsert?: FormationUpsertWithoutFo_videoInput
    connect?: FormationWhereUniqueInput
    update?: XOR<XOR<FormationUpdateToOneWithWhereWithoutFo_videoInput, FormationUpdateWithoutFo_videoInput>, FormationUncheckedUpdateWithoutFo_videoInput>
  }

  export type TagVideoUpdateManyWithoutVideoNestedInput = {
    create?: XOR<TagVideoCreateWithoutVideoInput, TagVideoUncheckedCreateWithoutVideoInput> | TagVideoCreateWithoutVideoInput[] | TagVideoUncheckedCreateWithoutVideoInput[]
    connectOrCreate?: TagVideoCreateOrConnectWithoutVideoInput | TagVideoCreateOrConnectWithoutVideoInput[]
    upsert?: TagVideoUpsertWithWhereUniqueWithoutVideoInput | TagVideoUpsertWithWhereUniqueWithoutVideoInput[]
    createMany?: TagVideoCreateManyVideoInputEnvelope
    set?: TagVideoWhereUniqueInput | TagVideoWhereUniqueInput[]
    disconnect?: TagVideoWhereUniqueInput | TagVideoWhereUniqueInput[]
    delete?: TagVideoWhereUniqueInput | TagVideoWhereUniqueInput[]
    connect?: TagVideoWhereUniqueInput | TagVideoWhereUniqueInput[]
    update?: TagVideoUpdateWithWhereUniqueWithoutVideoInput | TagVideoUpdateWithWhereUniqueWithoutVideoInput[]
    updateMany?: TagVideoUpdateManyWithWhereWithoutVideoInput | TagVideoUpdateManyWithWhereWithoutVideoInput[]
    deleteMany?: TagVideoScalarWhereInput | TagVideoScalarWhereInput[]
  }

  export type TagVideoUncheckedUpdateManyWithoutVideoNestedInput = {
    create?: XOR<TagVideoCreateWithoutVideoInput, TagVideoUncheckedCreateWithoutVideoInput> | TagVideoCreateWithoutVideoInput[] | TagVideoUncheckedCreateWithoutVideoInput[]
    connectOrCreate?: TagVideoCreateOrConnectWithoutVideoInput | TagVideoCreateOrConnectWithoutVideoInput[]
    upsert?: TagVideoUpsertWithWhereUniqueWithoutVideoInput | TagVideoUpsertWithWhereUniqueWithoutVideoInput[]
    createMany?: TagVideoCreateManyVideoInputEnvelope
    set?: TagVideoWhereUniqueInput | TagVideoWhereUniqueInput[]
    disconnect?: TagVideoWhereUniqueInput | TagVideoWhereUniqueInput[]
    delete?: TagVideoWhereUniqueInput | TagVideoWhereUniqueInput[]
    connect?: TagVideoWhereUniqueInput | TagVideoWhereUniqueInput[]
    update?: TagVideoUpdateWithWhereUniqueWithoutVideoInput | TagVideoUpdateWithWhereUniqueWithoutVideoInput[]
    updateMany?: TagVideoUpdateManyWithWhereWithoutVideoInput | TagVideoUpdateManyWithWhereWithoutVideoInput[]
    deleteMany?: TagVideoScalarWhereInput | TagVideoScalarWhereInput[]
  }

  export type UtilisateurCreateNestedOneWithoutCommandeInput = {
    create?: XOR<UtilisateurCreateWithoutCommandeInput, UtilisateurUncheckedCreateWithoutCommandeInput>
    connectOrCreate?: UtilisateurCreateOrConnectWithoutCommandeInput
    connect?: UtilisateurWhereUniqueInput
  }

  export type StringFieldUpdateOperationsInput = {
    set?: string
  }

  export type UtilisateurUpdateOneRequiredWithoutCommandeNestedInput = {
    create?: XOR<UtilisateurCreateWithoutCommandeInput, UtilisateurUncheckedCreateWithoutCommandeInput>
    connectOrCreate?: UtilisateurCreateOrConnectWithoutCommandeInput
    upsert?: UtilisateurUpsertWithoutCommandeInput
    connect?: UtilisateurWhereUniqueInput
    update?: XOR<XOR<UtilisateurUpdateToOneWithWhereWithoutCommandeInput, UtilisateurUpdateWithoutCommandeInput>, UtilisateurUncheckedUpdateWithoutCommandeInput>
  }

  export type FormationCreateNestedOneWithoutCommandeFormationInput = {
    create?: XOR<FormationCreateWithoutCommandeFormationInput, FormationUncheckedCreateWithoutCommandeFormationInput>
    connectOrCreate?: FormationCreateOrConnectWithoutCommandeFormationInput
    connect?: FormationWhereUniqueInput
  }

  export type FormationUpdateOneRequiredWithoutCommandeFormationNestedInput = {
    create?: XOR<FormationCreateWithoutCommandeFormationInput, FormationUncheckedCreateWithoutCommandeFormationInput>
    connectOrCreate?: FormationCreateOrConnectWithoutCommandeFormationInput
    upsert?: FormationUpsertWithoutCommandeFormationInput
    connect?: FormationWhereUniqueInput
    update?: XOR<XOR<FormationUpdateToOneWithWhereWithoutCommandeFormationInput, FormationUpdateWithoutCommandeFormationInput>, FormationUncheckedUpdateWithoutCommandeFormationInput>
  }

  export type UtilisateurCreateNestedOneWithoutAchatInput = {
    create?: XOR<UtilisateurCreateWithoutAchatInput, UtilisateurUncheckedCreateWithoutAchatInput>
    connectOrCreate?: UtilisateurCreateOrConnectWithoutAchatInput
    connect?: UtilisateurWhereUniqueInput
  }

  export type FormationCreateNestedOneWithoutAchatInput = {
    create?: XOR<FormationCreateWithoutAchatInput, FormationUncheckedCreateWithoutAchatInput>
    connectOrCreate?: FormationCreateOrConnectWithoutAchatInput
    connect?: FormationWhereUniqueInput
  }

  export type UtilisateurUpdateOneRequiredWithoutAchatNestedInput = {
    create?: XOR<UtilisateurCreateWithoutAchatInput, UtilisateurUncheckedCreateWithoutAchatInput>
    connectOrCreate?: UtilisateurCreateOrConnectWithoutAchatInput
    upsert?: UtilisateurUpsertWithoutAchatInput
    connect?: UtilisateurWhereUniqueInput
    update?: XOR<XOR<UtilisateurUpdateToOneWithWhereWithoutAchatInput, UtilisateurUpdateWithoutAchatInput>, UtilisateurUncheckedUpdateWithoutAchatInput>
  }

  export type FormationUpdateOneRequiredWithoutAchatNestedInput = {
    create?: XOR<FormationCreateWithoutAchatInput, FormationUncheckedCreateWithoutAchatInput>
    connectOrCreate?: FormationCreateOrConnectWithoutAchatInput
    upsert?: FormationUpsertWithoutAchatInput
    connect?: FormationWhereUniqueInput
    update?: XOR<XOR<FormationUpdateToOneWithWhereWithoutAchatInput, FormationUpdateWithoutAchatInput>, FormationUncheckedUpdateWithoutAchatInput>
  }

  export type TagVideoCreateNestedManyWithoutTagInput = {
    create?: XOR<TagVideoCreateWithoutTagInput, TagVideoUncheckedCreateWithoutTagInput> | TagVideoCreateWithoutTagInput[] | TagVideoUncheckedCreateWithoutTagInput[]
    connectOrCreate?: TagVideoCreateOrConnectWithoutTagInput | TagVideoCreateOrConnectWithoutTagInput[]
    createMany?: TagVideoCreateManyTagInputEnvelope
    connect?: TagVideoWhereUniqueInput | TagVideoWhereUniqueInput[]
  }

  export type TagVideoUncheckedCreateNestedManyWithoutTagInput = {
    create?: XOR<TagVideoCreateWithoutTagInput, TagVideoUncheckedCreateWithoutTagInput> | TagVideoCreateWithoutTagInput[] | TagVideoUncheckedCreateWithoutTagInput[]
    connectOrCreate?: TagVideoCreateOrConnectWithoutTagInput | TagVideoCreateOrConnectWithoutTagInput[]
    createMany?: TagVideoCreateManyTagInputEnvelope
    connect?: TagVideoWhereUniqueInput | TagVideoWhereUniqueInput[]
  }

  export type TagVideoUpdateManyWithoutTagNestedInput = {
    create?: XOR<TagVideoCreateWithoutTagInput, TagVideoUncheckedCreateWithoutTagInput> | TagVideoCreateWithoutTagInput[] | TagVideoUncheckedCreateWithoutTagInput[]
    connectOrCreate?: TagVideoCreateOrConnectWithoutTagInput | TagVideoCreateOrConnectWithoutTagInput[]
    upsert?: TagVideoUpsertWithWhereUniqueWithoutTagInput | TagVideoUpsertWithWhereUniqueWithoutTagInput[]
    createMany?: TagVideoCreateManyTagInputEnvelope
    set?: TagVideoWhereUniqueInput | TagVideoWhereUniqueInput[]
    disconnect?: TagVideoWhereUniqueInput | TagVideoWhereUniqueInput[]
    delete?: TagVideoWhereUniqueInput | TagVideoWhereUniqueInput[]
    connect?: TagVideoWhereUniqueInput | TagVideoWhereUniqueInput[]
    update?: TagVideoUpdateWithWhereUniqueWithoutTagInput | TagVideoUpdateWithWhereUniqueWithoutTagInput[]
    updateMany?: TagVideoUpdateManyWithWhereWithoutTagInput | TagVideoUpdateManyWithWhereWithoutTagInput[]
    deleteMany?: TagVideoScalarWhereInput | TagVideoScalarWhereInput[]
  }

  export type TagVideoUncheckedUpdateManyWithoutTagNestedInput = {
    create?: XOR<TagVideoCreateWithoutTagInput, TagVideoUncheckedCreateWithoutTagInput> | TagVideoCreateWithoutTagInput[] | TagVideoUncheckedCreateWithoutTagInput[]
    connectOrCreate?: TagVideoCreateOrConnectWithoutTagInput | TagVideoCreateOrConnectWithoutTagInput[]
    upsert?: TagVideoUpsertWithWhereUniqueWithoutTagInput | TagVideoUpsertWithWhereUniqueWithoutTagInput[]
    createMany?: TagVideoCreateManyTagInputEnvelope
    set?: TagVideoWhereUniqueInput | TagVideoWhereUniqueInput[]
    disconnect?: TagVideoWhereUniqueInput | TagVideoWhereUniqueInput[]
    delete?: TagVideoWhereUniqueInput | TagVideoWhereUniqueInput[]
    connect?: TagVideoWhereUniqueInput | TagVideoWhereUniqueInput[]
    update?: TagVideoUpdateWithWhereUniqueWithoutTagInput | TagVideoUpdateWithWhereUniqueWithoutTagInput[]
    updateMany?: TagVideoUpdateManyWithWhereWithoutTagInput | TagVideoUpdateManyWithWhereWithoutTagInput[]
    deleteMany?: TagVideoScalarWhereInput | TagVideoScalarWhereInput[]
  }

  export type TagCreateNestedOneWithoutVi_tvInput = {
    create?: XOR<TagCreateWithoutVi_tvInput, TagUncheckedCreateWithoutVi_tvInput>
    connectOrCreate?: TagCreateOrConnectWithoutVi_tvInput
    connect?: TagWhereUniqueInput
  }

  export type VideoCreateNestedOneWithoutVi_tvInput = {
    create?: XOR<VideoCreateWithoutVi_tvInput, VideoUncheckedCreateWithoutVi_tvInput>
    connectOrCreate?: VideoCreateOrConnectWithoutVi_tvInput
    connect?: VideoWhereUniqueInput
  }

  export type TagUpdateOneRequiredWithoutVi_tvNestedInput = {
    create?: XOR<TagCreateWithoutVi_tvInput, TagUncheckedCreateWithoutVi_tvInput>
    connectOrCreate?: TagCreateOrConnectWithoutVi_tvInput
    upsert?: TagUpsertWithoutVi_tvInput
    connect?: TagWhereUniqueInput
    update?: XOR<XOR<TagUpdateToOneWithWhereWithoutVi_tvInput, TagUpdateWithoutVi_tvInput>, TagUncheckedUpdateWithoutVi_tvInput>
  }

  export type VideoUpdateOneRequiredWithoutVi_tvNestedInput = {
    create?: XOR<VideoCreateWithoutVi_tvInput, VideoUncheckedCreateWithoutVi_tvInput>
    connectOrCreate?: VideoCreateOrConnectWithoutVi_tvInput
    upsert?: VideoUpsertWithoutVi_tvInput
    connect?: VideoWhereUniqueInput
    update?: XOR<XOR<VideoUpdateToOneWithWhereWithoutVi_tvInput, VideoUpdateWithoutVi_tvInput>, VideoUncheckedUpdateWithoutVi_tvInput>
  }

  export type NestedIntFilter<$PrismaModel = never> = {
    equals?: number | IntFieldRefInput<$PrismaModel>
    in?: number[]
    notIn?: number[]
    lt?: number | IntFieldRefInput<$PrismaModel>
    lte?: number | IntFieldRefInput<$PrismaModel>
    gt?: number | IntFieldRefInput<$PrismaModel>
    gte?: number | IntFieldRefInput<$PrismaModel>
    not?: NestedIntFilter<$PrismaModel> | number
  }

  export type NestedStringNullableFilter<$PrismaModel = never> = {
    equals?: string | StringFieldRefInput<$PrismaModel> | null
    in?: string[] | null
    notIn?: string[] | 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>
    search?: string
    not?: NestedStringNullableFilter<$PrismaModel> | string | null
  }

  export type NestedIntNullableFilter<$PrismaModel = never> = {
    equals?: number | IntFieldRefInput<$PrismaModel> | null
    in?: number[] | null
    notIn?: number[] | null
    lt?: number | IntFieldRefInput<$PrismaModel>
    lte?: number | IntFieldRefInput<$PrismaModel>
    gt?: number | IntFieldRefInput<$PrismaModel>
    gte?: number | IntFieldRefInput<$PrismaModel>
    not?: NestedIntNullableFilter<$PrismaModel> | number | null
  }

  export type NestedDateTimeNullableFilter<$PrismaModel = never> = {
    equals?: Date | string | DateTimeFieldRefInput<$PrismaModel> | null
    in?: Date[] | string[] | null
    notIn?: Date[] | string[] | 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 NestedDateTimeFilter<$PrismaModel = never> = {
    equals?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    in?: Date[] | string[]
    notIn?: Date[] | string[]
    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 NestedIntWithAggregatesFilter<$PrismaModel = never> = {
    equals?: number | IntFieldRefInput<$PrismaModel>
    in?: number[]
    notIn?: number[]
    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 NestedFloatFilter<$PrismaModel = never> = {
    equals?: number | FloatFieldRefInput<$PrismaModel>
    in?: number[]
    notIn?: number[]
    lt?: number | FloatFieldRefInput<$PrismaModel>
    lte?: number | FloatFieldRefInput<$PrismaModel>
    gt?: number | FloatFieldRefInput<$PrismaModel>
    gte?: number | FloatFieldRefInput<$PrismaModel>
    not?: NestedFloatFilter<$PrismaModel> | number
  }

  export type NestedStringNullableWithAggregatesFilter<$PrismaModel = never> = {
    equals?: string | StringFieldRefInput<$PrismaModel> | null
    in?: string[] | null
    notIn?: string[] | 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>
    search?: string
    not?: NestedStringNullableWithAggregatesFilter<$PrismaModel> | string | null
    _count?: NestedIntNullableFilter<$PrismaModel>
    _min?: NestedStringNullableFilter<$PrismaModel>
    _max?: NestedStringNullableFilter<$PrismaModel>
  }

  export type NestedIntNullableWithAggregatesFilter<$PrismaModel = never> = {
    equals?: number | IntFieldRefInput<$PrismaModel> | null
    in?: number[] | null
    notIn?: number[] | 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[] | null
    notIn?: number[] | null
    lt?: number | FloatFieldRefInput<$PrismaModel>
    lte?: number | FloatFieldRefInput<$PrismaModel>
    gt?: number | FloatFieldRefInput<$PrismaModel>
    gte?: number | FloatFieldRefInput<$PrismaModel>
    not?: NestedFloatNullableFilter<$PrismaModel> | number | null
  }

  export type NestedDateTimeNullableWithAggregatesFilter<$PrismaModel = never> = {
    equals?: Date | string | DateTimeFieldRefInput<$PrismaModel> | null
    in?: Date[] | string[] | null
    notIn?: Date[] | string[] | 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 NestedDateTimeWithAggregatesFilter<$PrismaModel = never> = {
    equals?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    in?: Date[] | string[]
    notIn?: Date[] | string[]
    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 NestedBytesNullableFilter<$PrismaModel = never> = {
    equals?: Uint8Array | BytesFieldRefInput<$PrismaModel> | null
    in?: Uint8Array[] | null
    notIn?: Uint8Array[] | null
    not?: NestedBytesNullableFilter<$PrismaModel> | Uint8Array | null
  }

  export type NestedBytesNullableWithAggregatesFilter<$PrismaModel = never> = {
    equals?: Uint8Array | BytesFieldRefInput<$PrismaModel> | null
    in?: Uint8Array[] | null
    notIn?: Uint8Array[] | null
    not?: NestedBytesNullableWithAggregatesFilter<$PrismaModel> | Uint8Array | null
    _count?: NestedIntNullableFilter<$PrismaModel>
    _min?: NestedBytesNullableFilter<$PrismaModel>
    _max?: NestedBytesNullableFilter<$PrismaModel>
  }

  export type NestedStringFilter<$PrismaModel = never> = {
    equals?: string | StringFieldRefInput<$PrismaModel>
    in?: string[]
    notIn?: string[]
    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>
    search?: string
    not?: NestedStringFilter<$PrismaModel> | string
  }

  export type NestedStringWithAggregatesFilter<$PrismaModel = never> = {
    equals?: string | StringFieldRefInput<$PrismaModel>
    in?: string[]
    notIn?: string[]
    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>
    search?: string
    not?: NestedStringWithAggregatesFilter<$PrismaModel> | string
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedStringFilter<$PrismaModel>
    _max?: NestedStringFilter<$PrismaModel>
  }

  export type CommandeCreateWithoutUtilisateurInput = {
    co_date_creation?: Date | string
    co_date_update?: Date | string | null
    co_status?: string
  }

  export type CommandeUncheckedCreateWithoutUtilisateurInput = {
    co_id?: number
    co_date_creation?: Date | string
    co_date_update?: Date | string | null
    co_status?: string
  }

  export type CommandeCreateOrConnectWithoutUtilisateurInput = {
    where: CommandeWhereUniqueInput
    create: XOR<CommandeCreateWithoutUtilisateurInput, CommandeUncheckedCreateWithoutUtilisateurInput>
  }

  export type CommandeCreateManyUtilisateurInputEnvelope = {
    data: CommandeCreateManyUtilisateurInput | CommandeCreateManyUtilisateurInput[]
    skipDuplicates?: boolean
  }

  export type AchatCreateWithoutUtilisateurInput = {
    ac_type?: string | null
    ac_date_achat?: Date | string | null
    ac_date_fin?: Date | string | null
    formation: FormationCreateNestedOneWithoutAchatInput
  }

  export type AchatUncheckedCreateWithoutUtilisateurInput = {
    ac_id?: number
    ac_formation: number
    ac_type?: string | null
    ac_date_achat?: Date | string | null
    ac_date_fin?: Date | string | null
  }

  export type AchatCreateOrConnectWithoutUtilisateurInput = {
    where: AchatWhereUniqueInput
    create: XOR<AchatCreateWithoutUtilisateurInput, AchatUncheckedCreateWithoutUtilisateurInput>
  }

  export type AchatCreateManyUtilisateurInputEnvelope = {
    data: AchatCreateManyUtilisateurInput | AchatCreateManyUtilisateurInput[]
    skipDuplicates?: boolean
  }

  export type CommandeUpsertWithWhereUniqueWithoutUtilisateurInput = {
    where: CommandeWhereUniqueInput
    update: XOR<CommandeUpdateWithoutUtilisateurInput, CommandeUncheckedUpdateWithoutUtilisateurInput>
    create: XOR<CommandeCreateWithoutUtilisateurInput, CommandeUncheckedCreateWithoutUtilisateurInput>
  }

  export type CommandeUpdateWithWhereUniqueWithoutUtilisateurInput = {
    where: CommandeWhereUniqueInput
    data: XOR<CommandeUpdateWithoutUtilisateurInput, CommandeUncheckedUpdateWithoutUtilisateurInput>
  }

  export type CommandeUpdateManyWithWhereWithoutUtilisateurInput = {
    where: CommandeScalarWhereInput
    data: XOR<CommandeUpdateManyMutationInput, CommandeUncheckedUpdateManyWithoutUtilisateurInput>
  }

  export type CommandeScalarWhereInput = {
    AND?: CommandeScalarWhereInput | CommandeScalarWhereInput[]
    OR?: CommandeScalarWhereInput[]
    NOT?: CommandeScalarWhereInput | CommandeScalarWhereInput[]
    co_id?: IntFilter<"Commande"> | number
    co_utilisateur?: IntFilter<"Commande"> | number
    co_date_creation?: DateTimeFilter<"Commande"> | Date | string
    co_date_update?: DateTimeNullableFilter<"Commande"> | Date | string | null
    co_status?: StringFilter<"Commande"> | string
  }

  export type AchatUpsertWithWhereUniqueWithoutUtilisateurInput = {
    where: AchatWhereUniqueInput
    update: XOR<AchatUpdateWithoutUtilisateurInput, AchatUncheckedUpdateWithoutUtilisateurInput>
    create: XOR<AchatCreateWithoutUtilisateurInput, AchatUncheckedCreateWithoutUtilisateurInput>
  }

  export type AchatUpdateWithWhereUniqueWithoutUtilisateurInput = {
    where: AchatWhereUniqueInput
    data: XOR<AchatUpdateWithoutUtilisateurInput, AchatUncheckedUpdateWithoutUtilisateurInput>
  }

  export type AchatUpdateManyWithWhereWithoutUtilisateurInput = {
    where: AchatScalarWhereInput
    data: XOR<AchatUpdateManyMutationInput, AchatUncheckedUpdateManyWithoutUtilisateurInput>
  }

  export type AchatScalarWhereInput = {
    AND?: AchatScalarWhereInput | AchatScalarWhereInput[]
    OR?: AchatScalarWhereInput[]
    NOT?: AchatScalarWhereInput | AchatScalarWhereInput[]
    ac_id?: IntFilter<"Achat"> | number
    ac_utilisateur?: IntFilter<"Achat"> | number
    ac_formation?: IntFilter<"Achat"> | number
    ac_type?: StringNullableFilter<"Achat"> | string | null
    ac_date_achat?: DateTimeNullableFilter<"Achat"> | Date | string | null
    ac_date_fin?: DateTimeNullableFilter<"Achat"> | Date | string | null
  }

  export type VideoCreateWithoutFormationInput = {
    vi_titre?: string | null
    vi_description?: string | null
    vi_etape?: number | null
    vi_url?: string | null
    vi_tv?: TagVideoCreateNestedManyWithoutVideoInput
  }

  export type VideoUncheckedCreateWithoutFormationInput = {
    vi_id?: number
    vi_titre?: string | null
    vi_description?: string | null
    vi_etape?: number | null
    vi_url?: string | null
    vi_tv?: TagVideoUncheckedCreateNestedManyWithoutVideoInput
  }

  export type VideoCreateOrConnectWithoutFormationInput = {
    where: VideoWhereUniqueInput
    create: XOR<VideoCreateWithoutFormationInput, VideoUncheckedCreateWithoutFormationInput>
  }

  export type VideoCreateManyFormationInputEnvelope = {
    data: VideoCreateManyFormationInput | VideoCreateManyFormationInput[]
    skipDuplicates?: boolean
  }

  export type CommandeFormationCreateWithoutFormationInput = {

  }

  export type CommandeFormationUncheckedCreateWithoutFormationInput = {
    cof_id?: number
  }

  export type CommandeFormationCreateOrConnectWithoutFormationInput = {
    where: CommandeFormationWhereUniqueInput
    create: XOR<CommandeFormationCreateWithoutFormationInput, CommandeFormationUncheckedCreateWithoutFormationInput>
  }

  export type CommandeFormationCreateManyFormationInputEnvelope = {
    data: CommandeFormationCreateManyFormationInput | CommandeFormationCreateManyFormationInput[]
    skipDuplicates?: boolean
  }

  export type AchatCreateWithoutFormationInput = {
    ac_type?: string | null
    ac_date_achat?: Date | string | null
    ac_date_fin?: Date | string | null
    utilisateur: UtilisateurCreateNestedOneWithoutAchatInput
  }

  export type AchatUncheckedCreateWithoutFormationInput = {
    ac_id?: number
    ac_utilisateur: number
    ac_type?: string | null
    ac_date_achat?: Date | string | null
    ac_date_fin?: Date | string | null
  }

  export type AchatCreateOrConnectWithoutFormationInput = {
    where: AchatWhereUniqueInput
    create: XOR<AchatCreateWithoutFormationInput, AchatUncheckedCreateWithoutFormationInput>
  }

  export type AchatCreateManyFormationInputEnvelope = {
    data: AchatCreateManyFormationInput | AchatCreateManyFormationInput[]
    skipDuplicates?: boolean
  }

  export type VideoUpsertWithWhereUniqueWithoutFormationInput = {
    where: VideoWhereUniqueInput
    update: XOR<VideoUpdateWithoutFormationInput, VideoUncheckedUpdateWithoutFormationInput>
    create: XOR<VideoCreateWithoutFormationInput, VideoUncheckedCreateWithoutFormationInput>
  }

  export type VideoUpdateWithWhereUniqueWithoutFormationInput = {
    where: VideoWhereUniqueInput
    data: XOR<VideoUpdateWithoutFormationInput, VideoUncheckedUpdateWithoutFormationInput>
  }

  export type VideoUpdateManyWithWhereWithoutFormationInput = {
    where: VideoScalarWhereInput
    data: XOR<VideoUpdateManyMutationInput, VideoUncheckedUpdateManyWithoutFormationInput>
  }

  export type VideoScalarWhereInput = {
    AND?: VideoScalarWhereInput | VideoScalarWhereInput[]
    OR?: VideoScalarWhereInput[]
    NOT?: VideoScalarWhereInput | VideoScalarWhereInput[]
    vi_fo_id?: IntFilter<"Video"> | number
    vi_id?: IntFilter<"Video"> | number
    vi_titre?: StringNullableFilter<"Video"> | string | null
    vi_description?: StringNullableFilter<"Video"> | string | null
    vi_etape?: IntNullableFilter<"Video"> | number | null
    vi_url?: StringNullableFilter<"Video"> | string | null
  }

  export type CommandeFormationUpsertWithWhereUniqueWithoutFormationInput = {
    where: CommandeFormationWhereUniqueInput
    update: XOR<CommandeFormationUpdateWithoutFormationInput, CommandeFormationUncheckedUpdateWithoutFormationInput>
    create: XOR<CommandeFormationCreateWithoutFormationInput, CommandeFormationUncheckedCreateWithoutFormationInput>
  }

  export type CommandeFormationUpdateWithWhereUniqueWithoutFormationInput = {
    where: CommandeFormationWhereUniqueInput
    data: XOR<CommandeFormationUpdateWithoutFormationInput, CommandeFormationUncheckedUpdateWithoutFormationInput>
  }

  export type CommandeFormationUpdateManyWithWhereWithoutFormationInput = {
    where: CommandeFormationScalarWhereInput
    data: XOR<CommandeFormationUpdateManyMutationInput, CommandeFormationUncheckedUpdateManyWithoutFormationInput>
  }

  export type CommandeFormationScalarWhereInput = {
    AND?: CommandeFormationScalarWhereInput | CommandeFormationScalarWhereInput[]
    OR?: CommandeFormationScalarWhereInput[]
    NOT?: CommandeFormationScalarWhereInput | CommandeFormationScalarWhereInput[]
    cof_id?: IntFilter<"CommandeFormation"> | number
    cof_formation?: IntFilter<"CommandeFormation"> | number
  }

  export type AchatUpsertWithWhereUniqueWithoutFormationInput = {
    where: AchatWhereUniqueInput
    update: XOR<AchatUpdateWithoutFormationInput, AchatUncheckedUpdateWithoutFormationInput>
    create: XOR<AchatCreateWithoutFormationInput, AchatUncheckedCreateWithoutFormationInput>
  }

  export type AchatUpdateWithWhereUniqueWithoutFormationInput = {
    where: AchatWhereUniqueInput
    data: XOR<AchatUpdateWithoutFormationInput, AchatUncheckedUpdateWithoutFormationInput>
  }

  export type AchatUpdateManyWithWhereWithoutFormationInput = {
    where: AchatScalarWhereInput
    data: XOR<AchatUpdateManyMutationInput, AchatUncheckedUpdateManyWithoutFormationInput>
  }

  export type FormationCreateWithoutFo_videoInput = {
    fo_titre?: string | null
    fo_description?: string | null
    fo_prix?: string | null
    fo_miniature?: Uint8Array | null
    fo_teaser?: string | null
    fo_date_publication?: Date | string
    commandeFormation?: CommandeFormationCreateNestedManyWithoutFormationInput
    achat?: AchatCreateNestedManyWithoutFormationInput
  }

  export type FormationUncheckedCreateWithoutFo_videoInput = {
    fo_id?: number
    fo_titre?: string | null
    fo_description?: string | null
    fo_prix?: string | null
    fo_miniature?: Uint8Array | null
    fo_teaser?: string | null
    fo_date_publication?: Date | string
    commandeFormation?: CommandeFormationUncheckedCreateNestedManyWithoutFormationInput
    achat?: AchatUncheckedCreateNestedManyWithoutFormationInput
  }

  export type FormationCreateOrConnectWithoutFo_videoInput = {
    where: FormationWhereUniqueInput
    create: XOR<FormationCreateWithoutFo_videoInput, FormationUncheckedCreateWithoutFo_videoInput>
  }

  export type TagVideoCreateWithoutVideoInput = {
    tag: TagCreateNestedOneWithoutVi_tvInput
  }

  export type TagVideoUncheckedCreateWithoutVideoInput = {
    tv_tag_id: number
  }

  export type TagVideoCreateOrConnectWithoutVideoInput = {
    where: TagVideoWhereUniqueInput
    create: XOR<TagVideoCreateWithoutVideoInput, TagVideoUncheckedCreateWithoutVideoInput>
  }

  export type TagVideoCreateManyVideoInputEnvelope = {
    data: TagVideoCreateManyVideoInput | TagVideoCreateManyVideoInput[]
    skipDuplicates?: boolean
  }

  export type FormationUpsertWithoutFo_videoInput = {
    update: XOR<FormationUpdateWithoutFo_videoInput, FormationUncheckedUpdateWithoutFo_videoInput>
    create: XOR<FormationCreateWithoutFo_videoInput, FormationUncheckedCreateWithoutFo_videoInput>
    where?: FormationWhereInput
  }

  export type FormationUpdateToOneWithWhereWithoutFo_videoInput = {
    where?: FormationWhereInput
    data: XOR<FormationUpdateWithoutFo_videoInput, FormationUncheckedUpdateWithoutFo_videoInput>
  }

  export type FormationUpdateWithoutFo_videoInput = {
    fo_titre?: NullableStringFieldUpdateOperationsInput | string | null
    fo_description?: NullableStringFieldUpdateOperationsInput | string | null
    fo_prix?: NullableStringFieldUpdateOperationsInput | string | null
    fo_miniature?: NullableBytesFieldUpdateOperationsInput | Uint8Array | null
    fo_teaser?: NullableStringFieldUpdateOperationsInput | string | null
    fo_date_publication?: DateTimeFieldUpdateOperationsInput | Date | string
    commandeFormation?: CommandeFormationUpdateManyWithoutFormationNestedInput
    achat?: AchatUpdateManyWithoutFormationNestedInput
  }

  export type FormationUncheckedUpdateWithoutFo_videoInput = {
    fo_id?: IntFieldUpdateOperationsInput | number
    fo_titre?: NullableStringFieldUpdateOperationsInput | string | null
    fo_description?: NullableStringFieldUpdateOperationsInput | string | null
    fo_prix?: NullableStringFieldUpdateOperationsInput | string | null
    fo_miniature?: NullableBytesFieldUpdateOperationsInput | Uint8Array | null
    fo_teaser?: NullableStringFieldUpdateOperationsInput | string | null
    fo_date_publication?: DateTimeFieldUpdateOperationsInput | Date | string
    commandeFormation?: CommandeFormationUncheckedUpdateManyWithoutFormationNestedInput
    achat?: AchatUncheckedUpdateManyWithoutFormationNestedInput
  }

  export type TagVideoUpsertWithWhereUniqueWithoutVideoInput = {
    where: TagVideoWhereUniqueInput
    update: XOR<TagVideoUpdateWithoutVideoInput, TagVideoUncheckedUpdateWithoutVideoInput>
    create: XOR<TagVideoCreateWithoutVideoInput, TagVideoUncheckedCreateWithoutVideoInput>
  }

  export type TagVideoUpdateWithWhereUniqueWithoutVideoInput = {
    where: TagVideoWhereUniqueInput
    data: XOR<TagVideoUpdateWithoutVideoInput, TagVideoUncheckedUpdateWithoutVideoInput>
  }

  export type TagVideoUpdateManyWithWhereWithoutVideoInput = {
    where: TagVideoScalarWhereInput
    data: XOR<TagVideoUpdateManyMutationInput, TagVideoUncheckedUpdateManyWithoutVideoInput>
  }

  export type TagVideoScalarWhereInput = {
    AND?: TagVideoScalarWhereInput | TagVideoScalarWhereInput[]
    OR?: TagVideoScalarWhereInput[]
    NOT?: TagVideoScalarWhereInput | TagVideoScalarWhereInput[]
    tv_tag_id?: IntFilter<"TagVideo"> | number
    tv_video_id?: IntFilter<"TagVideo"> | number
  }

  export type UtilisateurCreateWithoutCommandeInput = {
    ut_nom?: string | null
    ut_prenom?: string | null
    ut_mail?: string | null
    ut_type_cliente?: number | null
    ut_age?: Date | string | null
    ut_nb_rdv?: number | null
    ut_nb_rdv_honores?: number | null
    ut_prix_moyen?: number | null
    ut_pdp?: number | null
    ut_panier?: number | null
    ut_mdp?: number | null
    ut_telephone?: number | null
    ut_date_inscription?: Date | string
    ut_derniere_connexion?: Date | string | null
    achat?: AchatCreateNestedManyWithoutUtilisateurInput
  }

  export type UtilisateurUncheckedCreateWithoutCommandeInput = {
    ut_id?: number
    ut_nom?: string | null
    ut_prenom?: string | null
    ut_mail?: string | null
    ut_type_cliente?: number | null
    ut_age?: Date | string | null
    ut_nb_rdv?: number | null
    ut_nb_rdv_honores?: number | null
    ut_prix_moyen?: number | null
    ut_pdp?: number | null
    ut_panier?: number | null
    ut_mdp?: number | null
    ut_telephone?: number | null
    ut_date_inscription?: Date | string
    ut_derniere_connexion?: Date | string | null
    achat?: AchatUncheckedCreateNestedManyWithoutUtilisateurInput
  }

  export type UtilisateurCreateOrConnectWithoutCommandeInput = {
    where: UtilisateurWhereUniqueInput
    create: XOR<UtilisateurCreateWithoutCommandeInput, UtilisateurUncheckedCreateWithoutCommandeInput>
  }

  export type UtilisateurUpsertWithoutCommandeInput = {
    update: XOR<UtilisateurUpdateWithoutCommandeInput, UtilisateurUncheckedUpdateWithoutCommandeInput>
    create: XOR<UtilisateurCreateWithoutCommandeInput, UtilisateurUncheckedCreateWithoutCommandeInput>
    where?: UtilisateurWhereInput
  }

  export type UtilisateurUpdateToOneWithWhereWithoutCommandeInput = {
    where?: UtilisateurWhereInput
    data: XOR<UtilisateurUpdateWithoutCommandeInput, UtilisateurUncheckedUpdateWithoutCommandeInput>
  }

  export type UtilisateurUpdateWithoutCommandeInput = {
    ut_nom?: NullableStringFieldUpdateOperationsInput | string | null
    ut_prenom?: NullableStringFieldUpdateOperationsInput | string | null
    ut_mail?: NullableStringFieldUpdateOperationsInput | string | null
    ut_type_cliente?: NullableIntFieldUpdateOperationsInput | number | null
    ut_age?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    ut_nb_rdv?: NullableIntFieldUpdateOperationsInput | number | null
    ut_nb_rdv_honores?: NullableIntFieldUpdateOperationsInput | number | null
    ut_prix_moyen?: NullableIntFieldUpdateOperationsInput | number | null
    ut_pdp?: NullableIntFieldUpdateOperationsInput | number | null
    ut_panier?: NullableIntFieldUpdateOperationsInput | number | null
    ut_mdp?: NullableIntFieldUpdateOperationsInput | number | null
    ut_telephone?: NullableIntFieldUpdateOperationsInput | number | null
    ut_date_inscription?: DateTimeFieldUpdateOperationsInput | Date | string
    ut_derniere_connexion?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    achat?: AchatUpdateManyWithoutUtilisateurNestedInput
  }

  export type UtilisateurUncheckedUpdateWithoutCommandeInput = {
    ut_id?: IntFieldUpdateOperationsInput | number
    ut_nom?: NullableStringFieldUpdateOperationsInput | string | null
    ut_prenom?: NullableStringFieldUpdateOperationsInput | string | null
    ut_mail?: NullableStringFieldUpdateOperationsInput | string | null
    ut_type_cliente?: NullableIntFieldUpdateOperationsInput | number | null
    ut_age?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    ut_nb_rdv?: NullableIntFieldUpdateOperationsInput | number | null
    ut_nb_rdv_honores?: NullableIntFieldUpdateOperationsInput | number | null
    ut_prix_moyen?: NullableIntFieldUpdateOperationsInput | number | null
    ut_pdp?: NullableIntFieldUpdateOperationsInput | number | null
    ut_panier?: NullableIntFieldUpdateOperationsInput | number | null
    ut_mdp?: NullableIntFieldUpdateOperationsInput | number | null
    ut_telephone?: NullableIntFieldUpdateOperationsInput | number | null
    ut_date_inscription?: DateTimeFieldUpdateOperationsInput | Date | string
    ut_derniere_connexion?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    achat?: AchatUncheckedUpdateManyWithoutUtilisateurNestedInput
  }

  export type FormationCreateWithoutCommandeFormationInput = {
    fo_titre?: string | null
    fo_description?: string | null
    fo_prix?: string | null
    fo_miniature?: Uint8Array | null
    fo_teaser?: string | null
    fo_date_publication?: Date | string
    fo_video?: VideoCreateNestedManyWithoutFormationInput
    achat?: AchatCreateNestedManyWithoutFormationInput
  }

  export type FormationUncheckedCreateWithoutCommandeFormationInput = {
    fo_id?: number
    fo_titre?: string | null
    fo_description?: string | null
    fo_prix?: string | null
    fo_miniature?: Uint8Array | null
    fo_teaser?: string | null
    fo_date_publication?: Date | string
    fo_video?: VideoUncheckedCreateNestedManyWithoutFormationInput
    achat?: AchatUncheckedCreateNestedManyWithoutFormationInput
  }

  export type FormationCreateOrConnectWithoutCommandeFormationInput = {
    where: FormationWhereUniqueInput
    create: XOR<FormationCreateWithoutCommandeFormationInput, FormationUncheckedCreateWithoutCommandeFormationInput>
  }

  export type FormationUpsertWithoutCommandeFormationInput = {
    update: XOR<FormationUpdateWithoutCommandeFormationInput, FormationUncheckedUpdateWithoutCommandeFormationInput>
    create: XOR<FormationCreateWithoutCommandeFormationInput, FormationUncheckedCreateWithoutCommandeFormationInput>
    where?: FormationWhereInput
  }

  export type FormationUpdateToOneWithWhereWithoutCommandeFormationInput = {
    where?: FormationWhereInput
    data: XOR<FormationUpdateWithoutCommandeFormationInput, FormationUncheckedUpdateWithoutCommandeFormationInput>
  }

  export type FormationUpdateWithoutCommandeFormationInput = {
    fo_titre?: NullableStringFieldUpdateOperationsInput | string | null
    fo_description?: NullableStringFieldUpdateOperationsInput | string | null
    fo_prix?: NullableStringFieldUpdateOperationsInput | string | null
    fo_miniature?: NullableBytesFieldUpdateOperationsInput | Uint8Array | null
    fo_teaser?: NullableStringFieldUpdateOperationsInput | string | null
    fo_date_publication?: DateTimeFieldUpdateOperationsInput | Date | string
    fo_video?: VideoUpdateManyWithoutFormationNestedInput
    achat?: AchatUpdateManyWithoutFormationNestedInput
  }

  export type FormationUncheckedUpdateWithoutCommandeFormationInput = {
    fo_id?: IntFieldUpdateOperationsInput | number
    fo_titre?: NullableStringFieldUpdateOperationsInput | string | null
    fo_description?: NullableStringFieldUpdateOperationsInput | string | null
    fo_prix?: NullableStringFieldUpdateOperationsInput | string | null
    fo_miniature?: NullableBytesFieldUpdateOperationsInput | Uint8Array | null
    fo_teaser?: NullableStringFieldUpdateOperationsInput | string | null
    fo_date_publication?: DateTimeFieldUpdateOperationsInput | Date | string
    fo_video?: VideoUncheckedUpdateManyWithoutFormationNestedInput
    achat?: AchatUncheckedUpdateManyWithoutFormationNestedInput
  }

  export type UtilisateurCreateWithoutAchatInput = {
    ut_nom?: string | null
    ut_prenom?: string | null
    ut_mail?: string | null
    ut_type_cliente?: number | null
    ut_age?: Date | string | null
    ut_nb_rdv?: number | null
    ut_nb_rdv_honores?: number | null
    ut_prix_moyen?: number | null
    ut_pdp?: number | null
    ut_panier?: number | null
    ut_mdp?: number | null
    ut_telephone?: number | null
    ut_date_inscription?: Date | string
    ut_derniere_connexion?: Date | string | null
    commande?: CommandeCreateNestedManyWithoutUtilisateurInput
  }

  export type UtilisateurUncheckedCreateWithoutAchatInput = {
    ut_id?: number
    ut_nom?: string | null
    ut_prenom?: string | null
    ut_mail?: string | null
    ut_type_cliente?: number | null
    ut_age?: Date | string | null
    ut_nb_rdv?: number | null
    ut_nb_rdv_honores?: number | null
    ut_prix_moyen?: number | null
    ut_pdp?: number | null
    ut_panier?: number | null
    ut_mdp?: number | null
    ut_telephone?: number | null
    ut_date_inscription?: Date | string
    ut_derniere_connexion?: Date | string | null
    commande?: CommandeUncheckedCreateNestedManyWithoutUtilisateurInput
  }

  export type UtilisateurCreateOrConnectWithoutAchatInput = {
    where: UtilisateurWhereUniqueInput
    create: XOR<UtilisateurCreateWithoutAchatInput, UtilisateurUncheckedCreateWithoutAchatInput>
  }

  export type FormationCreateWithoutAchatInput = {
    fo_titre?: string | null
    fo_description?: string | null
    fo_prix?: string | null
    fo_miniature?: Uint8Array | null
    fo_teaser?: string | null
    fo_date_publication?: Date | string
    fo_video?: VideoCreateNestedManyWithoutFormationInput
    commandeFormation?: CommandeFormationCreateNestedManyWithoutFormationInput
  }

  export type FormationUncheckedCreateWithoutAchatInput = {
    fo_id?: number
    fo_titre?: string | null
    fo_description?: string | null
    fo_prix?: string | null
    fo_miniature?: Uint8Array | null
    fo_teaser?: string | null
    fo_date_publication?: Date | string
    fo_video?: VideoUncheckedCreateNestedManyWithoutFormationInput
    commandeFormation?: CommandeFormationUncheckedCreateNestedManyWithoutFormationInput
  }

  export type FormationCreateOrConnectWithoutAchatInput = {
    where: FormationWhereUniqueInput
    create: XOR<FormationCreateWithoutAchatInput, FormationUncheckedCreateWithoutAchatInput>
  }

  export type UtilisateurUpsertWithoutAchatInput = {
    update: XOR<UtilisateurUpdateWithoutAchatInput, UtilisateurUncheckedUpdateWithoutAchatInput>
    create: XOR<UtilisateurCreateWithoutAchatInput, UtilisateurUncheckedCreateWithoutAchatInput>
    where?: UtilisateurWhereInput
  }

  export type UtilisateurUpdateToOneWithWhereWithoutAchatInput = {
    where?: UtilisateurWhereInput
    data: XOR<UtilisateurUpdateWithoutAchatInput, UtilisateurUncheckedUpdateWithoutAchatInput>
  }

  export type UtilisateurUpdateWithoutAchatInput = {
    ut_nom?: NullableStringFieldUpdateOperationsInput | string | null
    ut_prenom?: NullableStringFieldUpdateOperationsInput | string | null
    ut_mail?: NullableStringFieldUpdateOperationsInput | string | null
    ut_type_cliente?: NullableIntFieldUpdateOperationsInput | number | null
    ut_age?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    ut_nb_rdv?: NullableIntFieldUpdateOperationsInput | number | null
    ut_nb_rdv_honores?: NullableIntFieldUpdateOperationsInput | number | null
    ut_prix_moyen?: NullableIntFieldUpdateOperationsInput | number | null
    ut_pdp?: NullableIntFieldUpdateOperationsInput | number | null
    ut_panier?: NullableIntFieldUpdateOperationsInput | number | null
    ut_mdp?: NullableIntFieldUpdateOperationsInput | number | null
    ut_telephone?: NullableIntFieldUpdateOperationsInput | number | null
    ut_date_inscription?: DateTimeFieldUpdateOperationsInput | Date | string
    ut_derniere_connexion?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    commande?: CommandeUpdateManyWithoutUtilisateurNestedInput
  }

  export type UtilisateurUncheckedUpdateWithoutAchatInput = {
    ut_id?: IntFieldUpdateOperationsInput | number
    ut_nom?: NullableStringFieldUpdateOperationsInput | string | null
    ut_prenom?: NullableStringFieldUpdateOperationsInput | string | null
    ut_mail?: NullableStringFieldUpdateOperationsInput | string | null
    ut_type_cliente?: NullableIntFieldUpdateOperationsInput | number | null
    ut_age?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    ut_nb_rdv?: NullableIntFieldUpdateOperationsInput | number | null
    ut_nb_rdv_honores?: NullableIntFieldUpdateOperationsInput | number | null
    ut_prix_moyen?: NullableIntFieldUpdateOperationsInput | number | null
    ut_pdp?: NullableIntFieldUpdateOperationsInput | number | null
    ut_panier?: NullableIntFieldUpdateOperationsInput | number | null
    ut_mdp?: NullableIntFieldUpdateOperationsInput | number | null
    ut_telephone?: NullableIntFieldUpdateOperationsInput | number | null
    ut_date_inscription?: DateTimeFieldUpdateOperationsInput | Date | string
    ut_derniere_connexion?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    commande?: CommandeUncheckedUpdateManyWithoutUtilisateurNestedInput
  }

  export type FormationUpsertWithoutAchatInput = {
    update: XOR<FormationUpdateWithoutAchatInput, FormationUncheckedUpdateWithoutAchatInput>
    create: XOR<FormationCreateWithoutAchatInput, FormationUncheckedCreateWithoutAchatInput>
    where?: FormationWhereInput
  }

  export type FormationUpdateToOneWithWhereWithoutAchatInput = {
    where?: FormationWhereInput
    data: XOR<FormationUpdateWithoutAchatInput, FormationUncheckedUpdateWithoutAchatInput>
  }

  export type FormationUpdateWithoutAchatInput = {
    fo_titre?: NullableStringFieldUpdateOperationsInput | string | null
    fo_description?: NullableStringFieldUpdateOperationsInput | string | null
    fo_prix?: NullableStringFieldUpdateOperationsInput | string | null
    fo_miniature?: NullableBytesFieldUpdateOperationsInput | Uint8Array | null
    fo_teaser?: NullableStringFieldUpdateOperationsInput | string | null
    fo_date_publication?: DateTimeFieldUpdateOperationsInput | Date | string
    fo_video?: VideoUpdateManyWithoutFormationNestedInput
    commandeFormation?: CommandeFormationUpdateManyWithoutFormationNestedInput
  }

  export type FormationUncheckedUpdateWithoutAchatInput = {
    fo_id?: IntFieldUpdateOperationsInput | number
    fo_titre?: NullableStringFieldUpdateOperationsInput | string | null
    fo_description?: NullableStringFieldUpdateOperationsInput | string | null
    fo_prix?: NullableStringFieldUpdateOperationsInput | string | null
    fo_miniature?: NullableBytesFieldUpdateOperationsInput | Uint8Array | null
    fo_teaser?: NullableStringFieldUpdateOperationsInput | string | null
    fo_date_publication?: DateTimeFieldUpdateOperationsInput | Date | string
    fo_video?: VideoUncheckedUpdateManyWithoutFormationNestedInput
    commandeFormation?: CommandeFormationUncheckedUpdateManyWithoutFormationNestedInput
  }

  export type TagVideoCreateWithoutTagInput = {
    video: VideoCreateNestedOneWithoutVi_tvInput
  }

  export type TagVideoUncheckedCreateWithoutTagInput = {
    tv_video_id: number
  }

  export type TagVideoCreateOrConnectWithoutTagInput = {
    where: TagVideoWhereUniqueInput
    create: XOR<TagVideoCreateWithoutTagInput, TagVideoUncheckedCreateWithoutTagInput>
  }

  export type TagVideoCreateManyTagInputEnvelope = {
    data: TagVideoCreateManyTagInput | TagVideoCreateManyTagInput[]
    skipDuplicates?: boolean
  }

  export type TagVideoUpsertWithWhereUniqueWithoutTagInput = {
    where: TagVideoWhereUniqueInput
    update: XOR<TagVideoUpdateWithoutTagInput, TagVideoUncheckedUpdateWithoutTagInput>
    create: XOR<TagVideoCreateWithoutTagInput, TagVideoUncheckedCreateWithoutTagInput>
  }

  export type TagVideoUpdateWithWhereUniqueWithoutTagInput = {
    where: TagVideoWhereUniqueInput
    data: XOR<TagVideoUpdateWithoutTagInput, TagVideoUncheckedUpdateWithoutTagInput>
  }

  export type TagVideoUpdateManyWithWhereWithoutTagInput = {
    where: TagVideoScalarWhereInput
    data: XOR<TagVideoUpdateManyMutationInput, TagVideoUncheckedUpdateManyWithoutTagInput>
  }

  export type TagCreateWithoutVi_tvInput = {
    ta_titre?: string | null
  }

  export type TagUncheckedCreateWithoutVi_tvInput = {
    ta_id?: number
    ta_titre?: string | null
  }

  export type TagCreateOrConnectWithoutVi_tvInput = {
    where: TagWhereUniqueInput
    create: XOR<TagCreateWithoutVi_tvInput, TagUncheckedCreateWithoutVi_tvInput>
  }

  export type VideoCreateWithoutVi_tvInput = {
    vi_titre?: string | null
    vi_description?: string | null
    vi_etape?: number | null
    vi_url?: string | null
    formation: FormationCreateNestedOneWithoutFo_videoInput
  }

  export type VideoUncheckedCreateWithoutVi_tvInput = {
    vi_fo_id: number
    vi_id?: number
    vi_titre?: string | null
    vi_description?: string | null
    vi_etape?: number | null
    vi_url?: string | null
  }

  export type VideoCreateOrConnectWithoutVi_tvInput = {
    where: VideoWhereUniqueInput
    create: XOR<VideoCreateWithoutVi_tvInput, VideoUncheckedCreateWithoutVi_tvInput>
  }

  export type TagUpsertWithoutVi_tvInput = {
    update: XOR<TagUpdateWithoutVi_tvInput, TagUncheckedUpdateWithoutVi_tvInput>
    create: XOR<TagCreateWithoutVi_tvInput, TagUncheckedCreateWithoutVi_tvInput>
    where?: TagWhereInput
  }

  export type TagUpdateToOneWithWhereWithoutVi_tvInput = {
    where?: TagWhereInput
    data: XOR<TagUpdateWithoutVi_tvInput, TagUncheckedUpdateWithoutVi_tvInput>
  }

  export type TagUpdateWithoutVi_tvInput = {
    ta_titre?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type TagUncheckedUpdateWithoutVi_tvInput = {
    ta_id?: IntFieldUpdateOperationsInput | number
    ta_titre?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type VideoUpsertWithoutVi_tvInput = {
    update: XOR<VideoUpdateWithoutVi_tvInput, VideoUncheckedUpdateWithoutVi_tvInput>
    create: XOR<VideoCreateWithoutVi_tvInput, VideoUncheckedCreateWithoutVi_tvInput>
    where?: VideoWhereInput
  }

  export type VideoUpdateToOneWithWhereWithoutVi_tvInput = {
    where?: VideoWhereInput
    data: XOR<VideoUpdateWithoutVi_tvInput, VideoUncheckedUpdateWithoutVi_tvInput>
  }

  export type VideoUpdateWithoutVi_tvInput = {
    vi_titre?: NullableStringFieldUpdateOperationsInput | string | null
    vi_description?: NullableStringFieldUpdateOperationsInput | string | null
    vi_etape?: NullableIntFieldUpdateOperationsInput | number | null
    vi_url?: NullableStringFieldUpdateOperationsInput | string | null
    formation?: FormationUpdateOneRequiredWithoutFo_videoNestedInput
  }

  export type VideoUncheckedUpdateWithoutVi_tvInput = {
    vi_fo_id?: IntFieldUpdateOperationsInput | number
    vi_id?: IntFieldUpdateOperationsInput | number
    vi_titre?: NullableStringFieldUpdateOperationsInput | string | null
    vi_description?: NullableStringFieldUpdateOperationsInput | string | null
    vi_etape?: NullableIntFieldUpdateOperationsInput | number | null
    vi_url?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type CommandeCreateManyUtilisateurInput = {
    co_id?: number
    co_date_creation?: Date | string
    co_date_update?: Date | string | null
    co_status?: string
  }

  export type AchatCreateManyUtilisateurInput = {
    ac_id?: number
    ac_formation: number
    ac_type?: string | null
    ac_date_achat?: Date | string | null
    ac_date_fin?: Date | string | null
  }

  export type CommandeUpdateWithoutUtilisateurInput = {
    co_date_creation?: DateTimeFieldUpdateOperationsInput | Date | string
    co_date_update?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    co_status?: StringFieldUpdateOperationsInput | string
  }

  export type CommandeUncheckedUpdateWithoutUtilisateurInput = {
    co_id?: IntFieldUpdateOperationsInput | number
    co_date_creation?: DateTimeFieldUpdateOperationsInput | Date | string
    co_date_update?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    co_status?: StringFieldUpdateOperationsInput | string
  }

  export type CommandeUncheckedUpdateManyWithoutUtilisateurInput = {
    co_id?: IntFieldUpdateOperationsInput | number
    co_date_creation?: DateTimeFieldUpdateOperationsInput | Date | string
    co_date_update?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    co_status?: StringFieldUpdateOperationsInput | string
  }

  export type AchatUpdateWithoutUtilisateurInput = {
    ac_type?: NullableStringFieldUpdateOperationsInput | string | null
    ac_date_achat?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    ac_date_fin?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    formation?: FormationUpdateOneRequiredWithoutAchatNestedInput
  }

  export type AchatUncheckedUpdateWithoutUtilisateurInput = {
    ac_id?: IntFieldUpdateOperationsInput | number
    ac_formation?: IntFieldUpdateOperationsInput | number
    ac_type?: NullableStringFieldUpdateOperationsInput | string | null
    ac_date_achat?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    ac_date_fin?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type AchatUncheckedUpdateManyWithoutUtilisateurInput = {
    ac_id?: IntFieldUpdateOperationsInput | number
    ac_formation?: IntFieldUpdateOperationsInput | number
    ac_type?: NullableStringFieldUpdateOperationsInput | string | null
    ac_date_achat?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    ac_date_fin?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type VideoCreateManyFormationInput = {
    vi_id?: number
    vi_titre?: string | null
    vi_description?: string | null
    vi_etape?: number | null
    vi_url?: string | null
  }

  export type CommandeFormationCreateManyFormationInput = {
    cof_id?: number
  }

  export type AchatCreateManyFormationInput = {
    ac_id?: number
    ac_utilisateur: number
    ac_type?: string | null
    ac_date_achat?: Date | string | null
    ac_date_fin?: Date | string | null
  }

  export type VideoUpdateWithoutFormationInput = {
    vi_titre?: NullableStringFieldUpdateOperationsInput | string | null
    vi_description?: NullableStringFieldUpdateOperationsInput | string | null
    vi_etape?: NullableIntFieldUpdateOperationsInput | number | null
    vi_url?: NullableStringFieldUpdateOperationsInput | string | null
    vi_tv?: TagVideoUpdateManyWithoutVideoNestedInput
  }

  export type VideoUncheckedUpdateWithoutFormationInput = {
    vi_id?: IntFieldUpdateOperationsInput | number
    vi_titre?: NullableStringFieldUpdateOperationsInput | string | null
    vi_description?: NullableStringFieldUpdateOperationsInput | string | null
    vi_etape?: NullableIntFieldUpdateOperationsInput | number | null
    vi_url?: NullableStringFieldUpdateOperationsInput | string | null
    vi_tv?: TagVideoUncheckedUpdateManyWithoutVideoNestedInput
  }

  export type VideoUncheckedUpdateManyWithoutFormationInput = {
    vi_id?: IntFieldUpdateOperationsInput | number
    vi_titre?: NullableStringFieldUpdateOperationsInput | string | null
    vi_description?: NullableStringFieldUpdateOperationsInput | string | null
    vi_etape?: NullableIntFieldUpdateOperationsInput | number | null
    vi_url?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type CommandeFormationUpdateWithoutFormationInput = {

  }

  export type CommandeFormationUncheckedUpdateWithoutFormationInput = {
    cof_id?: IntFieldUpdateOperationsInput | number
  }

  export type CommandeFormationUncheckedUpdateManyWithoutFormationInput = {
    cof_id?: IntFieldUpdateOperationsInput | number
  }

  export type AchatUpdateWithoutFormationInput = {
    ac_type?: NullableStringFieldUpdateOperationsInput | string | null
    ac_date_achat?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    ac_date_fin?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    utilisateur?: UtilisateurUpdateOneRequiredWithoutAchatNestedInput
  }

  export type AchatUncheckedUpdateWithoutFormationInput = {
    ac_id?: IntFieldUpdateOperationsInput | number
    ac_utilisateur?: IntFieldUpdateOperationsInput | number
    ac_type?: NullableStringFieldUpdateOperationsInput | string | null
    ac_date_achat?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    ac_date_fin?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type AchatUncheckedUpdateManyWithoutFormationInput = {
    ac_id?: IntFieldUpdateOperationsInput | number
    ac_utilisateur?: IntFieldUpdateOperationsInput | number
    ac_type?: NullableStringFieldUpdateOperationsInput | string | null
    ac_date_achat?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    ac_date_fin?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type TagVideoCreateManyVideoInput = {
    tv_tag_id: number
  }

  export type TagVideoUpdateWithoutVideoInput = {
    tag?: TagUpdateOneRequiredWithoutVi_tvNestedInput
  }

  export type TagVideoUncheckedUpdateWithoutVideoInput = {
    tv_tag_id?: IntFieldUpdateOperationsInput | number
  }

  export type TagVideoUncheckedUpdateManyWithoutVideoInput = {
    tv_tag_id?: IntFieldUpdateOperationsInput | number
  }

  export type TagVideoCreateManyTagInput = {
    tv_video_id: number
  }

  export type TagVideoUpdateWithoutTagInput = {
    video?: VideoUpdateOneRequiredWithoutVi_tvNestedInput
  }

  export type TagVideoUncheckedUpdateWithoutTagInput = {
    tv_video_id?: IntFieldUpdateOperationsInput | number
  }

  export type TagVideoUncheckedUpdateManyWithoutTagInput = {
    tv_video_id?: IntFieldUpdateOperationsInput | number
  }



  /**
   * Batch Payload for updateMany & deleteMany & createMany
   */

  export type BatchPayload = {
    count: number
  }

  /**
   * DMMF
   */
  export const dmmf: runtime.BaseDMMF
}