/**
 * 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 Build
 * 
 */
export type Build = $Result.DefaultSelection<Prisma.$BuildPayload>
/**
 * Model Session
 * 
 */
export type Session = $Result.DefaultSelection<Prisma.$SessionPayload>
/**
 * Model SessionLog
 * 
 */
export type SessionLog = $Result.DefaultSelection<Prisma.$SessionLogPayload>
/**
 * Model Log
 * 
 */
export type Log = $Result.DefaultSelection<Prisma.$LogPayload>
/**
 * Model Profiling
 * 
 */
export type Profiling = $Result.DefaultSelection<Prisma.$ProfilingPayload>
/**
 * Model App
 * 
 */
export type App = $Result.DefaultSelection<Prisma.$AppPayload>
/**
 * Model Device
 * 
 */
export type Device = $Result.DefaultSelection<Prisma.$DevicePayload>
/**
 * Model PendingSession
 * 
 */
export type PendingSession = $Result.DefaultSelection<Prisma.$PendingSessionPayload>
/**
 * Model CLIArgs
 * 
 */
export type CLIArgs = $Result.DefaultSelection<Prisma.$CLIArgsPayload>
/**
 * Model WebhookConfig
 * 
 */
export type WebhookConfig = $Result.DefaultSelection<Prisma.$WebhookConfigPayload>
/**
 * Model WebConfig
 * 
 */
export type WebConfig = $Result.DefaultSelection<Prisma.$WebConfigPayload>
/**
 * Model LocatorEtalon
 * 
 */
export type LocatorEtalon = $Result.DefaultSelection<Prisma.$LocatorEtalonPayload>
/**
 * Model PortLease
 * 
 */
export type PortLease = $Result.DefaultSelection<Prisma.$PortLeasePayload>
/**
 * Model Lease
 * 
 */
export type Lease = $Result.DefaultSelection<Prisma.$LeasePayload>
/**
 * Model ApiKey
 * 
 */
export type ApiKey = $Result.DefaultSelection<Prisma.$ApiKeyPayload>
/**
 * Model Team
 * 
 */
export type Team = $Result.DefaultSelection<Prisma.$TeamPayload>
/**
 * Model SelectorState
 * 
 */
export type SelectorState = $Result.DefaultSelection<Prisma.$SelectorStatePayload>
/**
 * Model Recording
 * 
 */
export type Recording = $Result.DefaultSelection<Prisma.$RecordingPayload>
/**
 * Model Bookmark
 * 
 */
export type Bookmark = $Result.DefaultSelection<Prisma.$BookmarkPayload>
/**
 * Model Annotation
 * 
 */
export type Annotation = $Result.DefaultSelection<Prisma.$AnnotationPayload>
/**
 * Model User
 * 
 */
export type User = $Result.DefaultSelection<Prisma.$UserPayload>
/**
 * Model UserSession
 * 
 */
export type UserSession = $Result.DefaultSelection<Prisma.$UserSessionPayload>
/**
 * Model PasswordResetToken
 * 
 */
export type PasswordResetToken = $Result.DefaultSelection<Prisma.$PasswordResetTokenPayload>
/**
 * Model TeamMember
 * 
 */
export type TeamMember = $Result.DefaultSelection<Prisma.$TeamMemberPayload>
/**
 * Model EventLog
 * 
 */
export type EventLog = $Result.DefaultSelection<Prisma.$EventLogPayload>
/**
 * Model Project
 * 
 */
export type Project = $Result.DefaultSelection<Prisma.$ProjectPayload>

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

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

      /**
   * `prisma.build`: Exposes CRUD operations for the **Build** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Builds
    * const builds = await prisma.build.findMany()
    * ```
    */
  get build(): Prisma.BuildDelegate<ExtArgs>;

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

  /**
   * `prisma.sessionLog`: Exposes CRUD operations for the **SessionLog** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more SessionLogs
    * const sessionLogs = await prisma.sessionLog.findMany()
    * ```
    */
  get sessionLog(): Prisma.SessionLogDelegate<ExtArgs>;

  /**
   * `prisma.log`: Exposes CRUD operations for the **Log** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Logs
    * const logs = await prisma.log.findMany()
    * ```
    */
  get log(): Prisma.LogDelegate<ExtArgs>;

  /**
   * `prisma.profiling`: Exposes CRUD operations for the **Profiling** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Profilings
    * const profilings = await prisma.profiling.findMany()
    * ```
    */
  get profiling(): Prisma.ProfilingDelegate<ExtArgs>;

  /**
   * `prisma.app`: Exposes CRUD operations for the **App** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Apps
    * const apps = await prisma.app.findMany()
    * ```
    */
  get app(): Prisma.AppDelegate<ExtArgs>;

  /**
   * `prisma.device`: Exposes CRUD operations for the **Device** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Devices
    * const devices = await prisma.device.findMany()
    * ```
    */
  get device(): Prisma.DeviceDelegate<ExtArgs>;

  /**
   * `prisma.pendingSession`: Exposes CRUD operations for the **PendingSession** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more PendingSessions
    * const pendingSessions = await prisma.pendingSession.findMany()
    * ```
    */
  get pendingSession(): Prisma.PendingSessionDelegate<ExtArgs>;

  /**
   * `prisma.cLIArgs`: Exposes CRUD operations for the **CLIArgs** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more CLIArgs
    * const cLIArgs = await prisma.cLIArgs.findMany()
    * ```
    */
  get cLIArgs(): Prisma.CLIArgsDelegate<ExtArgs>;

  /**
   * `prisma.webhookConfig`: Exposes CRUD operations for the **WebhookConfig** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more WebhookConfigs
    * const webhookConfigs = await prisma.webhookConfig.findMany()
    * ```
    */
  get webhookConfig(): Prisma.WebhookConfigDelegate<ExtArgs>;

  /**
   * `prisma.webConfig`: Exposes CRUD operations for the **WebConfig** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more WebConfigs
    * const webConfigs = await prisma.webConfig.findMany()
    * ```
    */
  get webConfig(): Prisma.WebConfigDelegate<ExtArgs>;

  /**
   * `prisma.locatorEtalon`: Exposes CRUD operations for the **LocatorEtalon** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more LocatorEtalons
    * const locatorEtalons = await prisma.locatorEtalon.findMany()
    * ```
    */
  get locatorEtalon(): Prisma.LocatorEtalonDelegate<ExtArgs>;

  /**
   * `prisma.portLease`: Exposes CRUD operations for the **PortLease** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more PortLeases
    * const portLeases = await prisma.portLease.findMany()
    * ```
    */
  get portLease(): Prisma.PortLeaseDelegate<ExtArgs>;

  /**
   * `prisma.lease`: Exposes CRUD operations for the **Lease** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Leases
    * const leases = await prisma.lease.findMany()
    * ```
    */
  get lease(): Prisma.LeaseDelegate<ExtArgs>;

  /**
   * `prisma.apiKey`: Exposes CRUD operations for the **ApiKey** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more ApiKeys
    * const apiKeys = await prisma.apiKey.findMany()
    * ```
    */
  get apiKey(): Prisma.ApiKeyDelegate<ExtArgs>;

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

  /**
   * `prisma.selectorState`: Exposes CRUD operations for the **SelectorState** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more SelectorStates
    * const selectorStates = await prisma.selectorState.findMany()
    * ```
    */
  get selectorState(): Prisma.SelectorStateDelegate<ExtArgs>;

  /**
   * `prisma.recording`: Exposes CRUD operations for the **Recording** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Recordings
    * const recordings = await prisma.recording.findMany()
    * ```
    */
  get recording(): Prisma.RecordingDelegate<ExtArgs>;

  /**
   * `prisma.bookmark`: Exposes CRUD operations for the **Bookmark** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Bookmarks
    * const bookmarks = await prisma.bookmark.findMany()
    * ```
    */
  get bookmark(): Prisma.BookmarkDelegate<ExtArgs>;

  /**
   * `prisma.annotation`: Exposes CRUD operations for the **Annotation** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Annotations
    * const annotations = await prisma.annotation.findMany()
    * ```
    */
  get annotation(): Prisma.AnnotationDelegate<ExtArgs>;

  /**
   * `prisma.user`: Exposes CRUD operations for the **User** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Users
    * const users = await prisma.user.findMany()
    * ```
    */
  get user(): Prisma.UserDelegate<ExtArgs>;

  /**
   * `prisma.userSession`: Exposes CRUD operations for the **UserSession** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more UserSessions
    * const userSessions = await prisma.userSession.findMany()
    * ```
    */
  get userSession(): Prisma.UserSessionDelegate<ExtArgs>;

  /**
   * `prisma.passwordResetToken`: Exposes CRUD operations for the **PasswordResetToken** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more PasswordResetTokens
    * const passwordResetTokens = await prisma.passwordResetToken.findMany()
    * ```
    */
  get passwordResetToken(): Prisma.PasswordResetTokenDelegate<ExtArgs>;

  /**
   * `prisma.teamMember`: Exposes CRUD operations for the **TeamMember** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more TeamMembers
    * const teamMembers = await prisma.teamMember.findMany()
    * ```
    */
  get teamMember(): Prisma.TeamMemberDelegate<ExtArgs>;

  /**
   * `prisma.eventLog`: Exposes CRUD operations for the **EventLog** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more EventLogs
    * const eventLogs = await prisma.eventLog.findMany()
    * ```
    */
  get eventLog(): Prisma.EventLogDelegate<ExtArgs>;

  /**
   * `prisma.project`: Exposes CRUD operations for the **Project** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Projects
    * const projects = await prisma.project.findMany()
    * ```
    */
  get project(): Prisma.ProjectDelegate<ExtArgs>;
}

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
  export import NotFoundError = runtime.NotFoundError

  /**
   * 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: 5.22.0
   * Query Engine version: 605197351a3c8bdd595af2d2a9bc3025bca48ea2
   */
  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 ? K : 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: {
    Build: 'Build',
    Session: 'Session',
    SessionLog: 'SessionLog',
    Log: 'Log',
    Profiling: 'Profiling',
    App: 'App',
    Device: 'Device',
    PendingSession: 'PendingSession',
    CLIArgs: 'CLIArgs',
    WebhookConfig: 'WebhookConfig',
    WebConfig: 'WebConfig',
    LocatorEtalon: 'LocatorEtalon',
    PortLease: 'PortLease',
    Lease: 'Lease',
    ApiKey: 'ApiKey',
    Team: 'Team',
    SelectorState: 'SelectorState',
    Recording: 'Recording',
    Bookmark: 'Bookmark',
    Annotation: 'Annotation',
    User: 'User',
    UserSession: 'UserSession',
    PasswordResetToken: 'PasswordResetToken',
    TeamMember: 'TeamMember',
    EventLog: 'EventLog',
    Project: 'Project'
  };

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


  export type Datasources = {
    db?: Datasource
  }

  interface TypeMapCb extends $Utils.Fn<{extArgs: $Extensions.InternalArgs, clientOptions: PrismaClientOptions }, $Utils.Record<string, any>> {
    returns: Prisma.TypeMap<this['params']['extArgs'], this['params']['clientOptions']>
  }

  export type TypeMap<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, ClientOptions = {}> = {
    meta: {
      modelProps: "build" | "session" | "sessionLog" | "log" | "profiling" | "app" | "device" | "pendingSession" | "cLIArgs" | "webhookConfig" | "webConfig" | "locatorEtalon" | "portLease" | "lease" | "apiKey" | "team" | "selectorState" | "recording" | "bookmark" | "annotation" | "user" | "userSession" | "passwordResetToken" | "teamMember" | "eventLog" | "project"
      txIsolationLevel: Prisma.TransactionIsolationLevel
    }
    model: {
      Build: {
        payload: Prisma.$BuildPayload<ExtArgs>
        fields: Prisma.BuildFieldRefs
        operations: {
          findUnique: {
            args: Prisma.BuildFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$BuildPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.BuildFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$BuildPayload>
          }
          findFirst: {
            args: Prisma.BuildFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$BuildPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.BuildFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$BuildPayload>
          }
          findMany: {
            args: Prisma.BuildFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$BuildPayload>[]
          }
          create: {
            args: Prisma.BuildCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$BuildPayload>
          }
          createMany: {
            args: Prisma.BuildCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.BuildCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$BuildPayload>[]
          }
          delete: {
            args: Prisma.BuildDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$BuildPayload>
          }
          update: {
            args: Prisma.BuildUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$BuildPayload>
          }
          deleteMany: {
            args: Prisma.BuildDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.BuildUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.BuildUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$BuildPayload>
          }
          aggregate: {
            args: Prisma.BuildAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateBuild>
          }
          groupBy: {
            args: Prisma.BuildGroupByArgs<ExtArgs>
            result: $Utils.Optional<BuildGroupByOutputType>[]
          }
          count: {
            args: Prisma.BuildCountArgs<ExtArgs>
            result: $Utils.Optional<BuildCountAggregateOutputType> | number
          }
        }
      }
      Session: {
        payload: Prisma.$SessionPayload<ExtArgs>
        fields: Prisma.SessionFieldRefs
        operations: {
          findUnique: {
            args: Prisma.SessionFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SessionPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.SessionFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SessionPayload>
          }
          findFirst: {
            args: Prisma.SessionFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SessionPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.SessionFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SessionPayload>
          }
          findMany: {
            args: Prisma.SessionFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SessionPayload>[]
          }
          create: {
            args: Prisma.SessionCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SessionPayload>
          }
          createMany: {
            args: Prisma.SessionCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.SessionCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SessionPayload>[]
          }
          delete: {
            args: Prisma.SessionDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SessionPayload>
          }
          update: {
            args: Prisma.SessionUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SessionPayload>
          }
          deleteMany: {
            args: Prisma.SessionDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.SessionUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.SessionUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SessionPayload>
          }
          aggregate: {
            args: Prisma.SessionAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateSession>
          }
          groupBy: {
            args: Prisma.SessionGroupByArgs<ExtArgs>
            result: $Utils.Optional<SessionGroupByOutputType>[]
          }
          count: {
            args: Prisma.SessionCountArgs<ExtArgs>
            result: $Utils.Optional<SessionCountAggregateOutputType> | number
          }
        }
      }
      SessionLog: {
        payload: Prisma.$SessionLogPayload<ExtArgs>
        fields: Prisma.SessionLogFieldRefs
        operations: {
          findUnique: {
            args: Prisma.SessionLogFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SessionLogPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.SessionLogFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SessionLogPayload>
          }
          findFirst: {
            args: Prisma.SessionLogFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SessionLogPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.SessionLogFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SessionLogPayload>
          }
          findMany: {
            args: Prisma.SessionLogFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SessionLogPayload>[]
          }
          create: {
            args: Prisma.SessionLogCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SessionLogPayload>
          }
          createMany: {
            args: Prisma.SessionLogCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.SessionLogCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SessionLogPayload>[]
          }
          delete: {
            args: Prisma.SessionLogDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SessionLogPayload>
          }
          update: {
            args: Prisma.SessionLogUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SessionLogPayload>
          }
          deleteMany: {
            args: Prisma.SessionLogDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.SessionLogUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.SessionLogUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SessionLogPayload>
          }
          aggregate: {
            args: Prisma.SessionLogAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateSessionLog>
          }
          groupBy: {
            args: Prisma.SessionLogGroupByArgs<ExtArgs>
            result: $Utils.Optional<SessionLogGroupByOutputType>[]
          }
          count: {
            args: Prisma.SessionLogCountArgs<ExtArgs>
            result: $Utils.Optional<SessionLogCountAggregateOutputType> | number
          }
        }
      }
      Log: {
        payload: Prisma.$LogPayload<ExtArgs>
        fields: Prisma.LogFieldRefs
        operations: {
          findUnique: {
            args: Prisma.LogFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$LogPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.LogFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$LogPayload>
          }
          findFirst: {
            args: Prisma.LogFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$LogPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.LogFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$LogPayload>
          }
          findMany: {
            args: Prisma.LogFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$LogPayload>[]
          }
          create: {
            args: Prisma.LogCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$LogPayload>
          }
          createMany: {
            args: Prisma.LogCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.LogCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$LogPayload>[]
          }
          delete: {
            args: Prisma.LogDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$LogPayload>
          }
          update: {
            args: Prisma.LogUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$LogPayload>
          }
          deleteMany: {
            args: Prisma.LogDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.LogUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.LogUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$LogPayload>
          }
          aggregate: {
            args: Prisma.LogAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateLog>
          }
          groupBy: {
            args: Prisma.LogGroupByArgs<ExtArgs>
            result: $Utils.Optional<LogGroupByOutputType>[]
          }
          count: {
            args: Prisma.LogCountArgs<ExtArgs>
            result: $Utils.Optional<LogCountAggregateOutputType> | number
          }
        }
      }
      Profiling: {
        payload: Prisma.$ProfilingPayload<ExtArgs>
        fields: Prisma.ProfilingFieldRefs
        operations: {
          findUnique: {
            args: Prisma.ProfilingFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProfilingPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.ProfilingFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProfilingPayload>
          }
          findFirst: {
            args: Prisma.ProfilingFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProfilingPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.ProfilingFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProfilingPayload>
          }
          findMany: {
            args: Prisma.ProfilingFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProfilingPayload>[]
          }
          create: {
            args: Prisma.ProfilingCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProfilingPayload>
          }
          createMany: {
            args: Prisma.ProfilingCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.ProfilingCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProfilingPayload>[]
          }
          delete: {
            args: Prisma.ProfilingDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProfilingPayload>
          }
          update: {
            args: Prisma.ProfilingUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProfilingPayload>
          }
          deleteMany: {
            args: Prisma.ProfilingDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.ProfilingUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.ProfilingUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProfilingPayload>
          }
          aggregate: {
            args: Prisma.ProfilingAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateProfiling>
          }
          groupBy: {
            args: Prisma.ProfilingGroupByArgs<ExtArgs>
            result: $Utils.Optional<ProfilingGroupByOutputType>[]
          }
          count: {
            args: Prisma.ProfilingCountArgs<ExtArgs>
            result: $Utils.Optional<ProfilingCountAggregateOutputType> | number
          }
        }
      }
      App: {
        payload: Prisma.$AppPayload<ExtArgs>
        fields: Prisma.AppFieldRefs
        operations: {
          findUnique: {
            args: Prisma.AppFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AppPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.AppFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AppPayload>
          }
          findFirst: {
            args: Prisma.AppFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AppPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.AppFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AppPayload>
          }
          findMany: {
            args: Prisma.AppFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AppPayload>[]
          }
          create: {
            args: Prisma.AppCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AppPayload>
          }
          createMany: {
            args: Prisma.AppCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.AppCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AppPayload>[]
          }
          delete: {
            args: Prisma.AppDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AppPayload>
          }
          update: {
            args: Prisma.AppUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AppPayload>
          }
          deleteMany: {
            args: Prisma.AppDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.AppUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.AppUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AppPayload>
          }
          aggregate: {
            args: Prisma.AppAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateApp>
          }
          groupBy: {
            args: Prisma.AppGroupByArgs<ExtArgs>
            result: $Utils.Optional<AppGroupByOutputType>[]
          }
          count: {
            args: Prisma.AppCountArgs<ExtArgs>
            result: $Utils.Optional<AppCountAggregateOutputType> | number
          }
        }
      }
      Device: {
        payload: Prisma.$DevicePayload<ExtArgs>
        fields: Prisma.DeviceFieldRefs
        operations: {
          findUnique: {
            args: Prisma.DeviceFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$DevicePayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.DeviceFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$DevicePayload>
          }
          findFirst: {
            args: Prisma.DeviceFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$DevicePayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.DeviceFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$DevicePayload>
          }
          findMany: {
            args: Prisma.DeviceFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$DevicePayload>[]
          }
          create: {
            args: Prisma.DeviceCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$DevicePayload>
          }
          createMany: {
            args: Prisma.DeviceCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.DeviceCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$DevicePayload>[]
          }
          delete: {
            args: Prisma.DeviceDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$DevicePayload>
          }
          update: {
            args: Prisma.DeviceUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$DevicePayload>
          }
          deleteMany: {
            args: Prisma.DeviceDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.DeviceUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.DeviceUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$DevicePayload>
          }
          aggregate: {
            args: Prisma.DeviceAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateDevice>
          }
          groupBy: {
            args: Prisma.DeviceGroupByArgs<ExtArgs>
            result: $Utils.Optional<DeviceGroupByOutputType>[]
          }
          count: {
            args: Prisma.DeviceCountArgs<ExtArgs>
            result: $Utils.Optional<DeviceCountAggregateOutputType> | number
          }
        }
      }
      PendingSession: {
        payload: Prisma.$PendingSessionPayload<ExtArgs>
        fields: Prisma.PendingSessionFieldRefs
        operations: {
          findUnique: {
            args: Prisma.PendingSessionFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PendingSessionPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.PendingSessionFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PendingSessionPayload>
          }
          findFirst: {
            args: Prisma.PendingSessionFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PendingSessionPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.PendingSessionFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PendingSessionPayload>
          }
          findMany: {
            args: Prisma.PendingSessionFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PendingSessionPayload>[]
          }
          create: {
            args: Prisma.PendingSessionCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PendingSessionPayload>
          }
          createMany: {
            args: Prisma.PendingSessionCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.PendingSessionCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PendingSessionPayload>[]
          }
          delete: {
            args: Prisma.PendingSessionDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PendingSessionPayload>
          }
          update: {
            args: Prisma.PendingSessionUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PendingSessionPayload>
          }
          deleteMany: {
            args: Prisma.PendingSessionDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.PendingSessionUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.PendingSessionUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PendingSessionPayload>
          }
          aggregate: {
            args: Prisma.PendingSessionAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregatePendingSession>
          }
          groupBy: {
            args: Prisma.PendingSessionGroupByArgs<ExtArgs>
            result: $Utils.Optional<PendingSessionGroupByOutputType>[]
          }
          count: {
            args: Prisma.PendingSessionCountArgs<ExtArgs>
            result: $Utils.Optional<PendingSessionCountAggregateOutputType> | number
          }
        }
      }
      CLIArgs: {
        payload: Prisma.$CLIArgsPayload<ExtArgs>
        fields: Prisma.CLIArgsFieldRefs
        operations: {
          findUnique: {
            args: Prisma.CLIArgsFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CLIArgsPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.CLIArgsFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CLIArgsPayload>
          }
          findFirst: {
            args: Prisma.CLIArgsFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CLIArgsPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.CLIArgsFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CLIArgsPayload>
          }
          findMany: {
            args: Prisma.CLIArgsFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CLIArgsPayload>[]
          }
          create: {
            args: Prisma.CLIArgsCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CLIArgsPayload>
          }
          createMany: {
            args: Prisma.CLIArgsCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.CLIArgsCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CLIArgsPayload>[]
          }
          delete: {
            args: Prisma.CLIArgsDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CLIArgsPayload>
          }
          update: {
            args: Prisma.CLIArgsUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CLIArgsPayload>
          }
          deleteMany: {
            args: Prisma.CLIArgsDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.CLIArgsUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.CLIArgsUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CLIArgsPayload>
          }
          aggregate: {
            args: Prisma.CLIArgsAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateCLIArgs>
          }
          groupBy: {
            args: Prisma.CLIArgsGroupByArgs<ExtArgs>
            result: $Utils.Optional<CLIArgsGroupByOutputType>[]
          }
          count: {
            args: Prisma.CLIArgsCountArgs<ExtArgs>
            result: $Utils.Optional<CLIArgsCountAggregateOutputType> | number
          }
        }
      }
      WebhookConfig: {
        payload: Prisma.$WebhookConfigPayload<ExtArgs>
        fields: Prisma.WebhookConfigFieldRefs
        operations: {
          findUnique: {
            args: Prisma.WebhookConfigFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$WebhookConfigPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.WebhookConfigFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$WebhookConfigPayload>
          }
          findFirst: {
            args: Prisma.WebhookConfigFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$WebhookConfigPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.WebhookConfigFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$WebhookConfigPayload>
          }
          findMany: {
            args: Prisma.WebhookConfigFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$WebhookConfigPayload>[]
          }
          create: {
            args: Prisma.WebhookConfigCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$WebhookConfigPayload>
          }
          createMany: {
            args: Prisma.WebhookConfigCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.WebhookConfigCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$WebhookConfigPayload>[]
          }
          delete: {
            args: Prisma.WebhookConfigDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$WebhookConfigPayload>
          }
          update: {
            args: Prisma.WebhookConfigUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$WebhookConfigPayload>
          }
          deleteMany: {
            args: Prisma.WebhookConfigDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.WebhookConfigUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.WebhookConfigUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$WebhookConfigPayload>
          }
          aggregate: {
            args: Prisma.WebhookConfigAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateWebhookConfig>
          }
          groupBy: {
            args: Prisma.WebhookConfigGroupByArgs<ExtArgs>
            result: $Utils.Optional<WebhookConfigGroupByOutputType>[]
          }
          count: {
            args: Prisma.WebhookConfigCountArgs<ExtArgs>
            result: $Utils.Optional<WebhookConfigCountAggregateOutputType> | number
          }
        }
      }
      WebConfig: {
        payload: Prisma.$WebConfigPayload<ExtArgs>
        fields: Prisma.WebConfigFieldRefs
        operations: {
          findUnique: {
            args: Prisma.WebConfigFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$WebConfigPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.WebConfigFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$WebConfigPayload>
          }
          findFirst: {
            args: Prisma.WebConfigFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$WebConfigPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.WebConfigFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$WebConfigPayload>
          }
          findMany: {
            args: Prisma.WebConfigFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$WebConfigPayload>[]
          }
          create: {
            args: Prisma.WebConfigCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$WebConfigPayload>
          }
          createMany: {
            args: Prisma.WebConfigCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.WebConfigCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$WebConfigPayload>[]
          }
          delete: {
            args: Prisma.WebConfigDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$WebConfigPayload>
          }
          update: {
            args: Prisma.WebConfigUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$WebConfigPayload>
          }
          deleteMany: {
            args: Prisma.WebConfigDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.WebConfigUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.WebConfigUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$WebConfigPayload>
          }
          aggregate: {
            args: Prisma.WebConfigAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateWebConfig>
          }
          groupBy: {
            args: Prisma.WebConfigGroupByArgs<ExtArgs>
            result: $Utils.Optional<WebConfigGroupByOutputType>[]
          }
          count: {
            args: Prisma.WebConfigCountArgs<ExtArgs>
            result: $Utils.Optional<WebConfigCountAggregateOutputType> | number
          }
        }
      }
      LocatorEtalon: {
        payload: Prisma.$LocatorEtalonPayload<ExtArgs>
        fields: Prisma.LocatorEtalonFieldRefs
        operations: {
          findUnique: {
            args: Prisma.LocatorEtalonFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$LocatorEtalonPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.LocatorEtalonFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$LocatorEtalonPayload>
          }
          findFirst: {
            args: Prisma.LocatorEtalonFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$LocatorEtalonPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.LocatorEtalonFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$LocatorEtalonPayload>
          }
          findMany: {
            args: Prisma.LocatorEtalonFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$LocatorEtalonPayload>[]
          }
          create: {
            args: Prisma.LocatorEtalonCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$LocatorEtalonPayload>
          }
          createMany: {
            args: Prisma.LocatorEtalonCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.LocatorEtalonCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$LocatorEtalonPayload>[]
          }
          delete: {
            args: Prisma.LocatorEtalonDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$LocatorEtalonPayload>
          }
          update: {
            args: Prisma.LocatorEtalonUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$LocatorEtalonPayload>
          }
          deleteMany: {
            args: Prisma.LocatorEtalonDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.LocatorEtalonUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.LocatorEtalonUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$LocatorEtalonPayload>
          }
          aggregate: {
            args: Prisma.LocatorEtalonAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateLocatorEtalon>
          }
          groupBy: {
            args: Prisma.LocatorEtalonGroupByArgs<ExtArgs>
            result: $Utils.Optional<LocatorEtalonGroupByOutputType>[]
          }
          count: {
            args: Prisma.LocatorEtalonCountArgs<ExtArgs>
            result: $Utils.Optional<LocatorEtalonCountAggregateOutputType> | number
          }
        }
      }
      PortLease: {
        payload: Prisma.$PortLeasePayload<ExtArgs>
        fields: Prisma.PortLeaseFieldRefs
        operations: {
          findUnique: {
            args: Prisma.PortLeaseFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PortLeasePayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.PortLeaseFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PortLeasePayload>
          }
          findFirst: {
            args: Prisma.PortLeaseFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PortLeasePayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.PortLeaseFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PortLeasePayload>
          }
          findMany: {
            args: Prisma.PortLeaseFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PortLeasePayload>[]
          }
          create: {
            args: Prisma.PortLeaseCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PortLeasePayload>
          }
          createMany: {
            args: Prisma.PortLeaseCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.PortLeaseCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PortLeasePayload>[]
          }
          delete: {
            args: Prisma.PortLeaseDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PortLeasePayload>
          }
          update: {
            args: Prisma.PortLeaseUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PortLeasePayload>
          }
          deleteMany: {
            args: Prisma.PortLeaseDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.PortLeaseUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.PortLeaseUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PortLeasePayload>
          }
          aggregate: {
            args: Prisma.PortLeaseAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregatePortLease>
          }
          groupBy: {
            args: Prisma.PortLeaseGroupByArgs<ExtArgs>
            result: $Utils.Optional<PortLeaseGroupByOutputType>[]
          }
          count: {
            args: Prisma.PortLeaseCountArgs<ExtArgs>
            result: $Utils.Optional<PortLeaseCountAggregateOutputType> | number
          }
        }
      }
      Lease: {
        payload: Prisma.$LeasePayload<ExtArgs>
        fields: Prisma.LeaseFieldRefs
        operations: {
          findUnique: {
            args: Prisma.LeaseFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$LeasePayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.LeaseFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$LeasePayload>
          }
          findFirst: {
            args: Prisma.LeaseFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$LeasePayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.LeaseFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$LeasePayload>
          }
          findMany: {
            args: Prisma.LeaseFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$LeasePayload>[]
          }
          create: {
            args: Prisma.LeaseCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$LeasePayload>
          }
          createMany: {
            args: Prisma.LeaseCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.LeaseCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$LeasePayload>[]
          }
          delete: {
            args: Prisma.LeaseDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$LeasePayload>
          }
          update: {
            args: Prisma.LeaseUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$LeasePayload>
          }
          deleteMany: {
            args: Prisma.LeaseDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.LeaseUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.LeaseUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$LeasePayload>
          }
          aggregate: {
            args: Prisma.LeaseAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateLease>
          }
          groupBy: {
            args: Prisma.LeaseGroupByArgs<ExtArgs>
            result: $Utils.Optional<LeaseGroupByOutputType>[]
          }
          count: {
            args: Prisma.LeaseCountArgs<ExtArgs>
            result: $Utils.Optional<LeaseCountAggregateOutputType> | number
          }
        }
      }
      ApiKey: {
        payload: Prisma.$ApiKeyPayload<ExtArgs>
        fields: Prisma.ApiKeyFieldRefs
        operations: {
          findUnique: {
            args: Prisma.ApiKeyFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ApiKeyPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.ApiKeyFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ApiKeyPayload>
          }
          findFirst: {
            args: Prisma.ApiKeyFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ApiKeyPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.ApiKeyFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ApiKeyPayload>
          }
          findMany: {
            args: Prisma.ApiKeyFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ApiKeyPayload>[]
          }
          create: {
            args: Prisma.ApiKeyCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ApiKeyPayload>
          }
          createMany: {
            args: Prisma.ApiKeyCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.ApiKeyCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ApiKeyPayload>[]
          }
          delete: {
            args: Prisma.ApiKeyDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ApiKeyPayload>
          }
          update: {
            args: Prisma.ApiKeyUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ApiKeyPayload>
          }
          deleteMany: {
            args: Prisma.ApiKeyDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.ApiKeyUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.ApiKeyUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ApiKeyPayload>
          }
          aggregate: {
            args: Prisma.ApiKeyAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateApiKey>
          }
          groupBy: {
            args: Prisma.ApiKeyGroupByArgs<ExtArgs>
            result: $Utils.Optional<ApiKeyGroupByOutputType>[]
          }
          count: {
            args: Prisma.ApiKeyCountArgs<ExtArgs>
            result: $Utils.Optional<ApiKeyCountAggregateOutputType> | number
          }
        }
      }
      Team: {
        payload: Prisma.$TeamPayload<ExtArgs>
        fields: Prisma.TeamFieldRefs
        operations: {
          findUnique: {
            args: Prisma.TeamFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TeamPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.TeamFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TeamPayload>
          }
          findFirst: {
            args: Prisma.TeamFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TeamPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.TeamFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TeamPayload>
          }
          findMany: {
            args: Prisma.TeamFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TeamPayload>[]
          }
          create: {
            args: Prisma.TeamCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TeamPayload>
          }
          createMany: {
            args: Prisma.TeamCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.TeamCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TeamPayload>[]
          }
          delete: {
            args: Prisma.TeamDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TeamPayload>
          }
          update: {
            args: Prisma.TeamUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TeamPayload>
          }
          deleteMany: {
            args: Prisma.TeamDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.TeamUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.TeamUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TeamPayload>
          }
          aggregate: {
            args: Prisma.TeamAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateTeam>
          }
          groupBy: {
            args: Prisma.TeamGroupByArgs<ExtArgs>
            result: $Utils.Optional<TeamGroupByOutputType>[]
          }
          count: {
            args: Prisma.TeamCountArgs<ExtArgs>
            result: $Utils.Optional<TeamCountAggregateOutputType> | number
          }
        }
      }
      SelectorState: {
        payload: Prisma.$SelectorStatePayload<ExtArgs>
        fields: Prisma.SelectorStateFieldRefs
        operations: {
          findUnique: {
            args: Prisma.SelectorStateFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SelectorStatePayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.SelectorStateFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SelectorStatePayload>
          }
          findFirst: {
            args: Prisma.SelectorStateFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SelectorStatePayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.SelectorStateFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SelectorStatePayload>
          }
          findMany: {
            args: Prisma.SelectorStateFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SelectorStatePayload>[]
          }
          create: {
            args: Prisma.SelectorStateCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SelectorStatePayload>
          }
          createMany: {
            args: Prisma.SelectorStateCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.SelectorStateCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SelectorStatePayload>[]
          }
          delete: {
            args: Prisma.SelectorStateDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SelectorStatePayload>
          }
          update: {
            args: Prisma.SelectorStateUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SelectorStatePayload>
          }
          deleteMany: {
            args: Prisma.SelectorStateDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.SelectorStateUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.SelectorStateUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SelectorStatePayload>
          }
          aggregate: {
            args: Prisma.SelectorStateAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateSelectorState>
          }
          groupBy: {
            args: Prisma.SelectorStateGroupByArgs<ExtArgs>
            result: $Utils.Optional<SelectorStateGroupByOutputType>[]
          }
          count: {
            args: Prisma.SelectorStateCountArgs<ExtArgs>
            result: $Utils.Optional<SelectorStateCountAggregateOutputType> | number
          }
        }
      }
      Recording: {
        payload: Prisma.$RecordingPayload<ExtArgs>
        fields: Prisma.RecordingFieldRefs
        operations: {
          findUnique: {
            args: Prisma.RecordingFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$RecordingPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.RecordingFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$RecordingPayload>
          }
          findFirst: {
            args: Prisma.RecordingFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$RecordingPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.RecordingFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$RecordingPayload>
          }
          findMany: {
            args: Prisma.RecordingFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$RecordingPayload>[]
          }
          create: {
            args: Prisma.RecordingCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$RecordingPayload>
          }
          createMany: {
            args: Prisma.RecordingCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.RecordingCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$RecordingPayload>[]
          }
          delete: {
            args: Prisma.RecordingDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$RecordingPayload>
          }
          update: {
            args: Prisma.RecordingUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$RecordingPayload>
          }
          deleteMany: {
            args: Prisma.RecordingDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.RecordingUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.RecordingUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$RecordingPayload>
          }
          aggregate: {
            args: Prisma.RecordingAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateRecording>
          }
          groupBy: {
            args: Prisma.RecordingGroupByArgs<ExtArgs>
            result: $Utils.Optional<RecordingGroupByOutputType>[]
          }
          count: {
            args: Prisma.RecordingCountArgs<ExtArgs>
            result: $Utils.Optional<RecordingCountAggregateOutputType> | number
          }
        }
      }
      Bookmark: {
        payload: Prisma.$BookmarkPayload<ExtArgs>
        fields: Prisma.BookmarkFieldRefs
        operations: {
          findUnique: {
            args: Prisma.BookmarkFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$BookmarkPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.BookmarkFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$BookmarkPayload>
          }
          findFirst: {
            args: Prisma.BookmarkFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$BookmarkPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.BookmarkFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$BookmarkPayload>
          }
          findMany: {
            args: Prisma.BookmarkFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$BookmarkPayload>[]
          }
          create: {
            args: Prisma.BookmarkCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$BookmarkPayload>
          }
          createMany: {
            args: Prisma.BookmarkCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.BookmarkCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$BookmarkPayload>[]
          }
          delete: {
            args: Prisma.BookmarkDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$BookmarkPayload>
          }
          update: {
            args: Prisma.BookmarkUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$BookmarkPayload>
          }
          deleteMany: {
            args: Prisma.BookmarkDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.BookmarkUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.BookmarkUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$BookmarkPayload>
          }
          aggregate: {
            args: Prisma.BookmarkAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateBookmark>
          }
          groupBy: {
            args: Prisma.BookmarkGroupByArgs<ExtArgs>
            result: $Utils.Optional<BookmarkGroupByOutputType>[]
          }
          count: {
            args: Prisma.BookmarkCountArgs<ExtArgs>
            result: $Utils.Optional<BookmarkCountAggregateOutputType> | number
          }
        }
      }
      Annotation: {
        payload: Prisma.$AnnotationPayload<ExtArgs>
        fields: Prisma.AnnotationFieldRefs
        operations: {
          findUnique: {
            args: Prisma.AnnotationFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AnnotationPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.AnnotationFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AnnotationPayload>
          }
          findFirst: {
            args: Prisma.AnnotationFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AnnotationPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.AnnotationFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AnnotationPayload>
          }
          findMany: {
            args: Prisma.AnnotationFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AnnotationPayload>[]
          }
          create: {
            args: Prisma.AnnotationCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AnnotationPayload>
          }
          createMany: {
            args: Prisma.AnnotationCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.AnnotationCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AnnotationPayload>[]
          }
          delete: {
            args: Prisma.AnnotationDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AnnotationPayload>
          }
          update: {
            args: Prisma.AnnotationUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AnnotationPayload>
          }
          deleteMany: {
            args: Prisma.AnnotationDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.AnnotationUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.AnnotationUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AnnotationPayload>
          }
          aggregate: {
            args: Prisma.AnnotationAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateAnnotation>
          }
          groupBy: {
            args: Prisma.AnnotationGroupByArgs<ExtArgs>
            result: $Utils.Optional<AnnotationGroupByOutputType>[]
          }
          count: {
            args: Prisma.AnnotationCountArgs<ExtArgs>
            result: $Utils.Optional<AnnotationCountAggregateOutputType> | number
          }
        }
      }
      User: {
        payload: Prisma.$UserPayload<ExtArgs>
        fields: Prisma.UserFieldRefs
        operations: {
          findUnique: {
            args: Prisma.UserFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.UserFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserPayload>
          }
          findFirst: {
            args: Prisma.UserFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.UserFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserPayload>
          }
          findMany: {
            args: Prisma.UserFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserPayload>[]
          }
          create: {
            args: Prisma.UserCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserPayload>
          }
          createMany: {
            args: Prisma.UserCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.UserCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserPayload>[]
          }
          delete: {
            args: Prisma.UserDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserPayload>
          }
          update: {
            args: Prisma.UserUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserPayload>
          }
          deleteMany: {
            args: Prisma.UserDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.UserUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.UserUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserPayload>
          }
          aggregate: {
            args: Prisma.UserAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateUser>
          }
          groupBy: {
            args: Prisma.UserGroupByArgs<ExtArgs>
            result: $Utils.Optional<UserGroupByOutputType>[]
          }
          count: {
            args: Prisma.UserCountArgs<ExtArgs>
            result: $Utils.Optional<UserCountAggregateOutputType> | number
          }
        }
      }
      UserSession: {
        payload: Prisma.$UserSessionPayload<ExtArgs>
        fields: Prisma.UserSessionFieldRefs
        operations: {
          findUnique: {
            args: Prisma.UserSessionFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserSessionPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.UserSessionFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserSessionPayload>
          }
          findFirst: {
            args: Prisma.UserSessionFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserSessionPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.UserSessionFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserSessionPayload>
          }
          findMany: {
            args: Prisma.UserSessionFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserSessionPayload>[]
          }
          create: {
            args: Prisma.UserSessionCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserSessionPayload>
          }
          createMany: {
            args: Prisma.UserSessionCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.UserSessionCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserSessionPayload>[]
          }
          delete: {
            args: Prisma.UserSessionDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserSessionPayload>
          }
          update: {
            args: Prisma.UserSessionUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserSessionPayload>
          }
          deleteMany: {
            args: Prisma.UserSessionDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.UserSessionUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.UserSessionUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserSessionPayload>
          }
          aggregate: {
            args: Prisma.UserSessionAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateUserSession>
          }
          groupBy: {
            args: Prisma.UserSessionGroupByArgs<ExtArgs>
            result: $Utils.Optional<UserSessionGroupByOutputType>[]
          }
          count: {
            args: Prisma.UserSessionCountArgs<ExtArgs>
            result: $Utils.Optional<UserSessionCountAggregateOutputType> | number
          }
        }
      }
      PasswordResetToken: {
        payload: Prisma.$PasswordResetTokenPayload<ExtArgs>
        fields: Prisma.PasswordResetTokenFieldRefs
        operations: {
          findUnique: {
            args: Prisma.PasswordResetTokenFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PasswordResetTokenPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.PasswordResetTokenFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PasswordResetTokenPayload>
          }
          findFirst: {
            args: Prisma.PasswordResetTokenFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PasswordResetTokenPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.PasswordResetTokenFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PasswordResetTokenPayload>
          }
          findMany: {
            args: Prisma.PasswordResetTokenFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PasswordResetTokenPayload>[]
          }
          create: {
            args: Prisma.PasswordResetTokenCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PasswordResetTokenPayload>
          }
          createMany: {
            args: Prisma.PasswordResetTokenCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.PasswordResetTokenCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PasswordResetTokenPayload>[]
          }
          delete: {
            args: Prisma.PasswordResetTokenDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PasswordResetTokenPayload>
          }
          update: {
            args: Prisma.PasswordResetTokenUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PasswordResetTokenPayload>
          }
          deleteMany: {
            args: Prisma.PasswordResetTokenDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.PasswordResetTokenUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.PasswordResetTokenUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PasswordResetTokenPayload>
          }
          aggregate: {
            args: Prisma.PasswordResetTokenAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregatePasswordResetToken>
          }
          groupBy: {
            args: Prisma.PasswordResetTokenGroupByArgs<ExtArgs>
            result: $Utils.Optional<PasswordResetTokenGroupByOutputType>[]
          }
          count: {
            args: Prisma.PasswordResetTokenCountArgs<ExtArgs>
            result: $Utils.Optional<PasswordResetTokenCountAggregateOutputType> | number
          }
        }
      }
      TeamMember: {
        payload: Prisma.$TeamMemberPayload<ExtArgs>
        fields: Prisma.TeamMemberFieldRefs
        operations: {
          findUnique: {
            args: Prisma.TeamMemberFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TeamMemberPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.TeamMemberFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TeamMemberPayload>
          }
          findFirst: {
            args: Prisma.TeamMemberFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TeamMemberPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.TeamMemberFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TeamMemberPayload>
          }
          findMany: {
            args: Prisma.TeamMemberFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TeamMemberPayload>[]
          }
          create: {
            args: Prisma.TeamMemberCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TeamMemberPayload>
          }
          createMany: {
            args: Prisma.TeamMemberCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.TeamMemberCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TeamMemberPayload>[]
          }
          delete: {
            args: Prisma.TeamMemberDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TeamMemberPayload>
          }
          update: {
            args: Prisma.TeamMemberUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TeamMemberPayload>
          }
          deleteMany: {
            args: Prisma.TeamMemberDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.TeamMemberUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.TeamMemberUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TeamMemberPayload>
          }
          aggregate: {
            args: Prisma.TeamMemberAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateTeamMember>
          }
          groupBy: {
            args: Prisma.TeamMemberGroupByArgs<ExtArgs>
            result: $Utils.Optional<TeamMemberGroupByOutputType>[]
          }
          count: {
            args: Prisma.TeamMemberCountArgs<ExtArgs>
            result: $Utils.Optional<TeamMemberCountAggregateOutputType> | number
          }
        }
      }
      EventLog: {
        payload: Prisma.$EventLogPayload<ExtArgs>
        fields: Prisma.EventLogFieldRefs
        operations: {
          findUnique: {
            args: Prisma.EventLogFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$EventLogPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.EventLogFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$EventLogPayload>
          }
          findFirst: {
            args: Prisma.EventLogFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$EventLogPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.EventLogFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$EventLogPayload>
          }
          findMany: {
            args: Prisma.EventLogFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$EventLogPayload>[]
          }
          create: {
            args: Prisma.EventLogCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$EventLogPayload>
          }
          createMany: {
            args: Prisma.EventLogCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.EventLogCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$EventLogPayload>[]
          }
          delete: {
            args: Prisma.EventLogDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$EventLogPayload>
          }
          update: {
            args: Prisma.EventLogUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$EventLogPayload>
          }
          deleteMany: {
            args: Prisma.EventLogDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.EventLogUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.EventLogUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$EventLogPayload>
          }
          aggregate: {
            args: Prisma.EventLogAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateEventLog>
          }
          groupBy: {
            args: Prisma.EventLogGroupByArgs<ExtArgs>
            result: $Utils.Optional<EventLogGroupByOutputType>[]
          }
          count: {
            args: Prisma.EventLogCountArgs<ExtArgs>
            result: $Utils.Optional<EventLogCountAggregateOutputType> | number
          }
        }
      }
      Project: {
        payload: Prisma.$ProjectPayload<ExtArgs>
        fields: Prisma.ProjectFieldRefs
        operations: {
          findUnique: {
            args: Prisma.ProjectFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProjectPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.ProjectFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProjectPayload>
          }
          findFirst: {
            args: Prisma.ProjectFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProjectPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.ProjectFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProjectPayload>
          }
          findMany: {
            args: Prisma.ProjectFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProjectPayload>[]
          }
          create: {
            args: Prisma.ProjectCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProjectPayload>
          }
          createMany: {
            args: Prisma.ProjectCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.ProjectCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProjectPayload>[]
          }
          delete: {
            args: Prisma.ProjectDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProjectPayload>
          }
          update: {
            args: Prisma.ProjectUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProjectPayload>
          }
          deleteMany: {
            args: Prisma.ProjectDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.ProjectUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.ProjectUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProjectPayload>
          }
          aggregate: {
            args: Prisma.ProjectAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateProject>
          }
          groupBy: {
            args: Prisma.ProjectGroupByArgs<ExtArgs>
            result: $Utils.Optional<ProjectGroupByOutputType>[]
          }
          count: {
            args: Prisma.ProjectCountArgs<ExtArgs>
            result: $Utils.Optional<ProjectCountAggregateOutputType> | 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
    }
  }


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

  export type BuildCountOutputType = {
    sessions: number
  }

  export type BuildCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    sessions?: boolean | BuildCountOutputTypeCountSessionsArgs
  }

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

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


  /**
   * Count Type SessionCountOutputType
   */

  export type SessionCountOutputType = {
    Log: number
    Profiling: number
    SessionLog: number
    Recording: number
  }

  export type SessionCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    Log?: boolean | SessionCountOutputTypeCountLogArgs
    Profiling?: boolean | SessionCountOutputTypeCountProfilingArgs
    SessionLog?: boolean | SessionCountOutputTypeCountSessionLogArgs
    Recording?: boolean | SessionCountOutputTypeCountRecordingArgs
  }

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

  /**
   * SessionCountOutputType without action
   */
  export type SessionCountOutputTypeCountLogArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: LogWhereInput
  }

  /**
   * SessionCountOutputType without action
   */
  export type SessionCountOutputTypeCountProfilingArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: ProfilingWhereInput
  }

  /**
   * SessionCountOutputType without action
   */
  export type SessionCountOutputTypeCountSessionLogArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: SessionLogWhereInput
  }

  /**
   * SessionCountOutputType without action
   */
  export type SessionCountOutputTypeCountRecordingArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: RecordingWhereInput
  }


  /**
   * Count Type TeamCountOutputType
   */

  export type TeamCountOutputType = {
    devices: number
    apiKeys: number
    members: number
  }

  export type TeamCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    devices?: boolean | TeamCountOutputTypeCountDevicesArgs
    apiKeys?: boolean | TeamCountOutputTypeCountApiKeysArgs
    members?: boolean | TeamCountOutputTypeCountMembersArgs
  }

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

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

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

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


  /**
   * Count Type RecordingCountOutputType
   */

  export type RecordingCountOutputType = {
    bookmarks: number
    annotations: number
  }

  export type RecordingCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    bookmarks?: boolean | RecordingCountOutputTypeCountBookmarksArgs
    annotations?: boolean | RecordingCountOutputTypeCountAnnotationsArgs
  }

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

  /**
   * RecordingCountOutputType without action
   */
  export type RecordingCountOutputTypeCountBookmarksArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: BookmarkWhereInput
  }

  /**
   * RecordingCountOutputType without action
   */
  export type RecordingCountOutputTypeCountAnnotationsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: AnnotationWhereInput
  }


  /**
   * Count Type UserCountOutputType
   */

  export type UserCountOutputType = {
    apiKeys: number
    sessions: number
    passwordResetTokens: number
    teamMemberships: number
  }

  export type UserCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    apiKeys?: boolean | UserCountOutputTypeCountApiKeysArgs
    sessions?: boolean | UserCountOutputTypeCountSessionsArgs
    passwordResetTokens?: boolean | UserCountOutputTypeCountPasswordResetTokensArgs
    teamMemberships?: boolean | UserCountOutputTypeCountTeamMembershipsArgs
  }

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

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

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

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

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


  /**
   * Models
   */

  /**
   * Model Build
   */

  export type AggregateBuild = {
    _count: BuildCountAggregateOutputType | null
    _min: BuildMinAggregateOutputType | null
    _max: BuildMaxAggregateOutputType | null
  }

  export type BuildMinAggregateOutputType = {
    id: string | null
    name: string | null
    createdAt: Date | null
    updatedAt: Date | null
  }

  export type BuildMaxAggregateOutputType = {
    id: string | null
    name: string | null
    createdAt: Date | null
    updatedAt: Date | null
  }

  export type BuildCountAggregateOutputType = {
    id: number
    name: number
    createdAt: number
    updatedAt: number
    _all: number
  }


  export type BuildMinAggregateInputType = {
    id?: true
    name?: true
    createdAt?: true
    updatedAt?: true
  }

  export type BuildMaxAggregateInputType = {
    id?: true
    name?: true
    createdAt?: true
    updatedAt?: true
  }

  export type BuildCountAggregateInputType = {
    id?: true
    name?: true
    createdAt?: true
    updatedAt?: true
    _all?: true
  }

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

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




  export type BuildGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: BuildWhereInput
    orderBy?: BuildOrderByWithAggregationInput | BuildOrderByWithAggregationInput[]
    by: BuildScalarFieldEnum[] | BuildScalarFieldEnum
    having?: BuildScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: BuildCountAggregateInputType | true
    _min?: BuildMinAggregateInputType
    _max?: BuildMaxAggregateInputType
  }

  export type BuildGroupByOutputType = {
    id: string
    name: string | null
    createdAt: Date
    updatedAt: Date
    _count: BuildCountAggregateOutputType | null
    _min: BuildMinAggregateOutputType | null
    _max: BuildMaxAggregateOutputType | null
  }

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


  export type BuildSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    sessions?: boolean | Build$sessionsArgs<ExtArgs>
    _count?: boolean | BuildCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["build"]>

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

  export type BuildSelectScalar = {
    id?: boolean
    name?: boolean
    createdAt?: boolean
    updatedAt?: boolean
  }

  export type BuildInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    sessions?: boolean | Build$sessionsArgs<ExtArgs>
    _count?: boolean | BuildCountOutputTypeDefaultArgs<ExtArgs>
  }
  export type BuildIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {}

  export type $BuildPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Build"
    objects: {
      sessions: Prisma.$SessionPayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      name: string | null
      createdAt: Date
      updatedAt: Date
    }, ExtArgs["result"]["build"]>
    composites: {}
  }

  type BuildGetPayload<S extends boolean | null | undefined | BuildDefaultArgs> = $Result.GetResult<Prisma.$BuildPayload, S>

  type BuildCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<BuildFindManyArgs, 'select' | 'include' | 'distinct'> & {
      select?: BuildCountAggregateInputType | true
    }

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

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

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

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

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

    /**
     * Create a Build.
     * @param {BuildCreateArgs} args - Arguments to create a Build.
     * @example
     * // Create one Build
     * const Build = await prisma.build.create({
     *   data: {
     *     // ... data to create a Build
     *   }
     * })
     * 
     */
    create<T extends BuildCreateArgs>(args: SelectSubset<T, BuildCreateArgs<ExtArgs>>): Prisma__BuildClient<$Result.GetResult<Prisma.$BuildPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

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

    /**
     * Delete a Build.
     * @param {BuildDeleteArgs} args - Arguments to delete one Build.
     * @example
     * // Delete one Build
     * const Build = await prisma.build.delete({
     *   where: {
     *     // ... filter to delete one Build
     *   }
     * })
     * 
     */
    delete<T extends BuildDeleteArgs>(args: SelectSubset<T, BuildDeleteArgs<ExtArgs>>): Prisma__BuildClient<$Result.GetResult<Prisma.$BuildPayload<ExtArgs>, T, "delete">, never, ExtArgs>

    /**
     * Update one Build.
     * @param {BuildUpdateArgs} args - Arguments to update one Build.
     * @example
     * // Update one Build
     * const build = await prisma.build.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends BuildUpdateArgs>(args: SelectSubset<T, BuildUpdateArgs<ExtArgs>>): Prisma__BuildClient<$Result.GetResult<Prisma.$BuildPayload<ExtArgs>, T, "update">, never, ExtArgs>

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

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

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for Build.
   * 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__BuildClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    sessions<T extends Build$sessionsArgs<ExtArgs> = {}>(args?: Subset<T, Build$sessionsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$SessionPayload<ExtArgs>, T, "findMany"> | 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 Build model
   */ 
  interface BuildFieldRefs {
    readonly id: FieldRef<"Build", 'String'>
    readonly name: FieldRef<"Build", 'String'>
    readonly createdAt: FieldRef<"Build", 'DateTime'>
    readonly updatedAt: FieldRef<"Build", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * Build findUnique
   */
  export type BuildFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Build
     */
    select?: BuildSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: BuildInclude<ExtArgs> | null
    /**
     * Filter, which Build to fetch.
     */
    where: BuildWhereUniqueInput
  }

  /**
   * Build findUniqueOrThrow
   */
  export type BuildFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Build
     */
    select?: BuildSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: BuildInclude<ExtArgs> | null
    /**
     * Filter, which Build to fetch.
     */
    where: BuildWhereUniqueInput
  }

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

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

  /**
   * Build findMany
   */
  export type BuildFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Build
     */
    select?: BuildSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: BuildInclude<ExtArgs> | null
    /**
     * Filter, which Builds to fetch.
     */
    where?: BuildWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Builds to fetch.
     */
    orderBy?: BuildOrderByWithRelationInput | BuildOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing Builds.
     */
    cursor?: BuildWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Builds 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` Builds.
     */
    skip?: number
    distinct?: BuildScalarFieldEnum | BuildScalarFieldEnum[]
  }

  /**
   * Build create
   */
  export type BuildCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Build
     */
    select?: BuildSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: BuildInclude<ExtArgs> | null
    /**
     * The data needed to create a Build.
     */
    data: XOR<BuildCreateInput, BuildUncheckedCreateInput>
  }

  /**
   * Build createMany
   */
  export type BuildCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many Builds.
     */
    data: BuildCreateManyInput | BuildCreateManyInput[]
  }

  /**
   * Build createManyAndReturn
   */
  export type BuildCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Build
     */
    select?: BuildSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many Builds.
     */
    data: BuildCreateManyInput | BuildCreateManyInput[]
  }

  /**
   * Build update
   */
  export type BuildUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Build
     */
    select?: BuildSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: BuildInclude<ExtArgs> | null
    /**
     * The data needed to update a Build.
     */
    data: XOR<BuildUpdateInput, BuildUncheckedUpdateInput>
    /**
     * Choose, which Build to update.
     */
    where: BuildWhereUniqueInput
  }

  /**
   * Build updateMany
   */
  export type BuildUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Builds.
     */
    data: XOR<BuildUpdateManyMutationInput, BuildUncheckedUpdateManyInput>
    /**
     * Filter which Builds to update
     */
    where?: BuildWhereInput
  }

  /**
   * Build upsert
   */
  export type BuildUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Build
     */
    select?: BuildSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: BuildInclude<ExtArgs> | null
    /**
     * The filter to search for the Build to update in case it exists.
     */
    where: BuildWhereUniqueInput
    /**
     * In case the Build found by the `where` argument doesn't exist, create a new Build with this data.
     */
    create: XOR<BuildCreateInput, BuildUncheckedCreateInput>
    /**
     * In case the Build was found with the provided `where` argument, update it with this data.
     */
    update: XOR<BuildUpdateInput, BuildUncheckedUpdateInput>
  }

  /**
   * Build delete
   */
  export type BuildDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Build
     */
    select?: BuildSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: BuildInclude<ExtArgs> | null
    /**
     * Filter which Build to delete.
     */
    where: BuildWhereUniqueInput
  }

  /**
   * Build deleteMany
   */
  export type BuildDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Builds to delete
     */
    where?: BuildWhereInput
  }

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

  /**
   * Build without action
   */
  export type BuildDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Build
     */
    select?: BuildSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: BuildInclude<ExtArgs> | null
  }


  /**
   * Model Session
   */

  export type AggregateSession = {
    _count: SessionCountAggregateOutputType | null
    _avg: SessionAvgAggregateOutputType | null
    _sum: SessionSumAggregateOutputType | null
    _min: SessionMinAggregateOutputType | null
    _max: SessionMaxAggregateOutputType | null
  }

  export type SessionAvgAggregateOutputType = {
    heartbeat_pid: number | null
  }

  export type SessionSumAggregateOutputType = {
    heartbeat_pid: number | null
  }

  export type SessionMinAggregateOutputType = {
    id: string | null
    build_id: string | null
    name: string | null
    status: string | null
    desired_capabilities: string | null
    session_capabilities: string | null
    node_id: string | null
    has_live_video: boolean | null
    video_recording_enabled: boolean | null
    video_recording: string | null
    startTime: Date | null
    endTime: Date | null
    failure_reason: string | null
    is_profiling_available: boolean | null
    device_info: string | null
    device_udid: string | null
    device_platform: string | null
    device_version: string | null
    device_name: string | null
    createdAt: Date | null
    updatedAt: Date | null
    performance_trace: string | null
    failure_category: string | null
    ai_analysis: string | null
    tags: string | null
    trace_id: string | null
    last_heartbeat_at: Date | null
    heartbeat_pid: number | null
    heartbeat_host: string | null
    api_key_id: string | null
    user_id: string | null
  }

  export type SessionMaxAggregateOutputType = {
    id: string | null
    build_id: string | null
    name: string | null
    status: string | null
    desired_capabilities: string | null
    session_capabilities: string | null
    node_id: string | null
    has_live_video: boolean | null
    video_recording_enabled: boolean | null
    video_recording: string | null
    startTime: Date | null
    endTime: Date | null
    failure_reason: string | null
    is_profiling_available: boolean | null
    device_info: string | null
    device_udid: string | null
    device_platform: string | null
    device_version: string | null
    device_name: string | null
    createdAt: Date | null
    updatedAt: Date | null
    performance_trace: string | null
    failure_category: string | null
    ai_analysis: string | null
    tags: string | null
    trace_id: string | null
    last_heartbeat_at: Date | null
    heartbeat_pid: number | null
    heartbeat_host: string | null
    api_key_id: string | null
    user_id: string | null
  }

  export type SessionCountAggregateOutputType = {
    id: number
    build_id: number
    name: number
    status: number
    desired_capabilities: number
    session_capabilities: number
    node_id: number
    has_live_video: number
    video_recording_enabled: number
    video_recording: number
    startTime: number
    endTime: number
    failure_reason: number
    is_profiling_available: number
    device_info: number
    device_udid: number
    device_platform: number
    device_version: number
    device_name: number
    createdAt: number
    updatedAt: number
    performance_trace: number
    failure_category: number
    ai_analysis: number
    tags: number
    trace_id: number
    last_heartbeat_at: number
    heartbeat_pid: number
    heartbeat_host: number
    api_key_id: number
    user_id: number
    _all: number
  }


  export type SessionAvgAggregateInputType = {
    heartbeat_pid?: true
  }

  export type SessionSumAggregateInputType = {
    heartbeat_pid?: true
  }

  export type SessionMinAggregateInputType = {
    id?: true
    build_id?: true
    name?: true
    status?: true
    desired_capabilities?: true
    session_capabilities?: true
    node_id?: true
    has_live_video?: true
    video_recording_enabled?: true
    video_recording?: true
    startTime?: true
    endTime?: true
    failure_reason?: true
    is_profiling_available?: true
    device_info?: true
    device_udid?: true
    device_platform?: true
    device_version?: true
    device_name?: true
    createdAt?: true
    updatedAt?: true
    performance_trace?: true
    failure_category?: true
    ai_analysis?: true
    tags?: true
    trace_id?: true
    last_heartbeat_at?: true
    heartbeat_pid?: true
    heartbeat_host?: true
    api_key_id?: true
    user_id?: true
  }

  export type SessionMaxAggregateInputType = {
    id?: true
    build_id?: true
    name?: true
    status?: true
    desired_capabilities?: true
    session_capabilities?: true
    node_id?: true
    has_live_video?: true
    video_recording_enabled?: true
    video_recording?: true
    startTime?: true
    endTime?: true
    failure_reason?: true
    is_profiling_available?: true
    device_info?: true
    device_udid?: true
    device_platform?: true
    device_version?: true
    device_name?: true
    createdAt?: true
    updatedAt?: true
    performance_trace?: true
    failure_category?: true
    ai_analysis?: true
    tags?: true
    trace_id?: true
    last_heartbeat_at?: true
    heartbeat_pid?: true
    heartbeat_host?: true
    api_key_id?: true
    user_id?: true
  }

  export type SessionCountAggregateInputType = {
    id?: true
    build_id?: true
    name?: true
    status?: true
    desired_capabilities?: true
    session_capabilities?: true
    node_id?: true
    has_live_video?: true
    video_recording_enabled?: true
    video_recording?: true
    startTime?: true
    endTime?: true
    failure_reason?: true
    is_profiling_available?: true
    device_info?: true
    device_udid?: true
    device_platform?: true
    device_version?: true
    device_name?: true
    createdAt?: true
    updatedAt?: true
    performance_trace?: true
    failure_category?: true
    ai_analysis?: true
    tags?: true
    trace_id?: true
    last_heartbeat_at?: true
    heartbeat_pid?: true
    heartbeat_host?: true
    api_key_id?: true
    user_id?: true
    _all?: true
  }

  export type SessionAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Session to aggregate.
     */
    where?: SessionWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Sessions to fetch.
     */
    orderBy?: SessionOrderByWithRelationInput | SessionOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: SessionWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Sessions from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Sessions.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned Sessions
    **/
    _count?: true | SessionCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: SessionAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: SessionSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: SessionMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: SessionMaxAggregateInputType
  }

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




  export type SessionGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: SessionWhereInput
    orderBy?: SessionOrderByWithAggregationInput | SessionOrderByWithAggregationInput[]
    by: SessionScalarFieldEnum[] | SessionScalarFieldEnum
    having?: SessionScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: SessionCountAggregateInputType | true
    _avg?: SessionAvgAggregateInputType
    _sum?: SessionSumAggregateInputType
    _min?: SessionMinAggregateInputType
    _max?: SessionMaxAggregateInputType
  }

  export type SessionGroupByOutputType = {
    id: string
    build_id: string | null
    name: string | null
    status: string
    desired_capabilities: string
    session_capabilities: string
    node_id: string
    has_live_video: boolean
    video_recording_enabled: boolean
    video_recording: string | null
    startTime: Date
    endTime: Date | null
    failure_reason: string | null
    is_profiling_available: boolean
    device_info: string | null
    device_udid: string
    device_platform: string
    device_version: string
    device_name: string | null
    createdAt: Date
    updatedAt: Date
    performance_trace: string | null
    failure_category: string | null
    ai_analysis: string | null
    tags: string | null
    trace_id: string | null
    last_heartbeat_at: Date | null
    heartbeat_pid: number | null
    heartbeat_host: string | null
    api_key_id: string | null
    user_id: string | null
    _count: SessionCountAggregateOutputType | null
    _avg: SessionAvgAggregateOutputType | null
    _sum: SessionSumAggregateOutputType | null
    _min: SessionMinAggregateOutputType | null
    _max: SessionMaxAggregateOutputType | null
  }

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


  export type SessionSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    build_id?: boolean
    name?: boolean
    status?: boolean
    desired_capabilities?: boolean
    session_capabilities?: boolean
    node_id?: boolean
    has_live_video?: boolean
    video_recording_enabled?: boolean
    video_recording?: boolean
    startTime?: boolean
    endTime?: boolean
    failure_reason?: boolean
    is_profiling_available?: boolean
    device_info?: boolean
    device_udid?: boolean
    device_platform?: boolean
    device_version?: boolean
    device_name?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    performance_trace?: boolean
    failure_category?: boolean
    ai_analysis?: boolean
    tags?: boolean
    trace_id?: boolean
    last_heartbeat_at?: boolean
    heartbeat_pid?: boolean
    heartbeat_host?: boolean
    api_key_id?: boolean
    user_id?: boolean
    Log?: boolean | Session$LogArgs<ExtArgs>
    Profiling?: boolean | Session$ProfilingArgs<ExtArgs>
    build?: boolean | Session$buildArgs<ExtArgs>
    SessionLog?: boolean | Session$SessionLogArgs<ExtArgs>
    Recording?: boolean | Session$RecordingArgs<ExtArgs>
    _count?: boolean | SessionCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["session"]>

  export type SessionSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    build_id?: boolean
    name?: boolean
    status?: boolean
    desired_capabilities?: boolean
    session_capabilities?: boolean
    node_id?: boolean
    has_live_video?: boolean
    video_recording_enabled?: boolean
    video_recording?: boolean
    startTime?: boolean
    endTime?: boolean
    failure_reason?: boolean
    is_profiling_available?: boolean
    device_info?: boolean
    device_udid?: boolean
    device_platform?: boolean
    device_version?: boolean
    device_name?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    performance_trace?: boolean
    failure_category?: boolean
    ai_analysis?: boolean
    tags?: boolean
    trace_id?: boolean
    last_heartbeat_at?: boolean
    heartbeat_pid?: boolean
    heartbeat_host?: boolean
    api_key_id?: boolean
    user_id?: boolean
    build?: boolean | Session$buildArgs<ExtArgs>
  }, ExtArgs["result"]["session"]>

  export type SessionSelectScalar = {
    id?: boolean
    build_id?: boolean
    name?: boolean
    status?: boolean
    desired_capabilities?: boolean
    session_capabilities?: boolean
    node_id?: boolean
    has_live_video?: boolean
    video_recording_enabled?: boolean
    video_recording?: boolean
    startTime?: boolean
    endTime?: boolean
    failure_reason?: boolean
    is_profiling_available?: boolean
    device_info?: boolean
    device_udid?: boolean
    device_platform?: boolean
    device_version?: boolean
    device_name?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    performance_trace?: boolean
    failure_category?: boolean
    ai_analysis?: boolean
    tags?: boolean
    trace_id?: boolean
    last_heartbeat_at?: boolean
    heartbeat_pid?: boolean
    heartbeat_host?: boolean
    api_key_id?: boolean
    user_id?: boolean
  }

  export type SessionInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    Log?: boolean | Session$LogArgs<ExtArgs>
    Profiling?: boolean | Session$ProfilingArgs<ExtArgs>
    build?: boolean | Session$buildArgs<ExtArgs>
    SessionLog?: boolean | Session$SessionLogArgs<ExtArgs>
    Recording?: boolean | Session$RecordingArgs<ExtArgs>
    _count?: boolean | SessionCountOutputTypeDefaultArgs<ExtArgs>
  }
  export type SessionIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    build?: boolean | Session$buildArgs<ExtArgs>
  }

  export type $SessionPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Session"
    objects: {
      Log: Prisma.$LogPayload<ExtArgs>[]
      Profiling: Prisma.$ProfilingPayload<ExtArgs>[]
      build: Prisma.$BuildPayload<ExtArgs> | null
      SessionLog: Prisma.$SessionLogPayload<ExtArgs>[]
      Recording: Prisma.$RecordingPayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      build_id: string | null
      name: string | null
      status: string
      desired_capabilities: string
      session_capabilities: string
      node_id: string
      has_live_video: boolean
      video_recording_enabled: boolean
      video_recording: string | null
      startTime: Date
      endTime: Date | null
      failure_reason: string | null
      is_profiling_available: boolean
      device_info: string | null
      device_udid: string
      device_platform: string
      device_version: string
      device_name: string | null
      createdAt: Date
      updatedAt: Date
      performance_trace: string | null
      failure_category: string | null
      ai_analysis: string | null
      tags: string | null
      trace_id: string | null
      last_heartbeat_at: Date | null
      heartbeat_pid: number | null
      heartbeat_host: string | null
      api_key_id: string | null
      user_id: string | null
    }, ExtArgs["result"]["session"]>
    composites: {}
  }

  type SessionGetPayload<S extends boolean | null | undefined | SessionDefaultArgs> = $Result.GetResult<Prisma.$SessionPayload, S>

  type SessionCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<SessionFindManyArgs, 'select' | 'include' | 'distinct'> & {
      select?: SessionCountAggregateInputType | true
    }

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

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

    /**
     * Find the first Session that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {SessionFindFirstArgs} args - Arguments to find a Session
     * @example
     * // Get one Session
     * const session = await prisma.session.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends SessionFindFirstArgs>(args?: SelectSubset<T, SessionFindFirstArgs<ExtArgs>>): Prisma__SessionClient<$Result.GetResult<Prisma.$SessionPayload<ExtArgs>, T, "findFirst"> | null, null, ExtArgs>

    /**
     * Find the first Session that matches the filter or
     * throw `PrismaKnownClientError` with `P2025` code if no matches were found.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {SessionFindFirstOrThrowArgs} args - Arguments to find a Session
     * @example
     * // Get one Session
     * const session = await prisma.session.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends SessionFindFirstOrThrowArgs>(args?: SelectSubset<T, SessionFindFirstOrThrowArgs<ExtArgs>>): Prisma__SessionClient<$Result.GetResult<Prisma.$SessionPayload<ExtArgs>, T, "findFirstOrThrow">, never, ExtArgs>

    /**
     * Find zero or more Sessions that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {SessionFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all Sessions
     * const sessions = await prisma.session.findMany()
     * 
     * // Get first 10 Sessions
     * const sessions = await prisma.session.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const sessionWithIdOnly = await prisma.session.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends SessionFindManyArgs>(args?: SelectSubset<T, SessionFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$SessionPayload<ExtArgs>, T, "findMany">>

    /**
     * Create a Session.
     * @param {SessionCreateArgs} args - Arguments to create a Session.
     * @example
     * // Create one Session
     * const Session = await prisma.session.create({
     *   data: {
     *     // ... data to create a Session
     *   }
     * })
     * 
     */
    create<T extends SessionCreateArgs>(args: SelectSubset<T, SessionCreateArgs<ExtArgs>>): Prisma__SessionClient<$Result.GetResult<Prisma.$SessionPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

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

    /**
     * Delete a Session.
     * @param {SessionDeleteArgs} args - Arguments to delete one Session.
     * @example
     * // Delete one Session
     * const Session = await prisma.session.delete({
     *   where: {
     *     // ... filter to delete one Session
     *   }
     * })
     * 
     */
    delete<T extends SessionDeleteArgs>(args: SelectSubset<T, SessionDeleteArgs<ExtArgs>>): Prisma__SessionClient<$Result.GetResult<Prisma.$SessionPayload<ExtArgs>, T, "delete">, never, ExtArgs>

    /**
     * Update one Session.
     * @param {SessionUpdateArgs} args - Arguments to update one Session.
     * @example
     * // Update one Session
     * const session = await prisma.session.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends SessionUpdateArgs>(args: SelectSubset<T, SessionUpdateArgs<ExtArgs>>): Prisma__SessionClient<$Result.GetResult<Prisma.$SessionPayload<ExtArgs>, T, "update">, never, ExtArgs>

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

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

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


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

    /**
     * Allows you to perform aggregations operations on a Session.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {SessionAggregateArgs} args - Select which aggregations you would like to apply and on what fields.
     * @example
     * // Ordered by age ascending
     * // Where email contains prisma.io
     * // Limited to the 10 users
     * const aggregations = await prisma.user.aggregate({
     *   _avg: {
     *     age: true,
     *   },
     *   where: {
     *     email: {
     *       contains: "prisma.io",
     *     },
     *   },
     *   orderBy: {
     *     age: "asc",
     *   },
     *   take: 10,
     * })
    **/
    aggregate<T extends SessionAggregateArgs>(args: Subset<T, SessionAggregateArgs>): Prisma.PrismaPromise<GetSessionAggregateType<T>>

    /**
     * Group by Session.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {SessionGroupByArgs} args - Group by arguments.
     * @example
     * // Group by city, order by createdAt, get count
     * const result = await prisma.user.groupBy({
     *   by: ['city', 'createdAt'],
     *   orderBy: {
     *     createdAt: true
     *   },
     *   _count: {
     *     _all: true
     *   },
     * })
     * 
    **/
    groupBy<
      T extends SessionGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: SessionGroupByArgs['orderBy'] }
        : { orderBy?: SessionGroupByArgs['orderBy'] },
      OrderFields extends ExcludeUnderscoreKeys<Keys<MaybeTupleToUnion<T['orderBy']>>>,
      ByFields extends MaybeTupleToUnion<T['by']>,
      ByValid extends Has<ByFields, OrderFields>,
      HavingFields extends GetHavingFields<T['having']>,
      HavingValid extends Has<ByFields, HavingFields>,
      ByEmpty extends T['by'] extends never[] ? True : False,
      InputErrors extends ByEmpty extends True
      ? `Error: "by" must not be empty.`
      : HavingValid extends False
      ? {
          [P in HavingFields]: P extends ByFields
            ? never
            : P extends string
            ? `Error: Field "${P}" used in "having" needs to be provided in "by".`
            : [
                Error,
                'Field ',
                P,
                ` in "having" needs to be provided in "by"`,
              ]
        }[HavingFields]
      : 'take' extends Keys<T>
      ? 'orderBy' extends Keys<T>
        ? ByValid extends True
          ? {}
          : {
              [P in OrderFields]: P extends ByFields
                ? never
                : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
            }[OrderFields]
        : 'Error: If you provide "take", you also need to provide "orderBy"'
      : 'skip' extends Keys<T>
      ? 'orderBy' extends Keys<T>
        ? ByValid extends True
          ? {}
          : {
              [P in OrderFields]: P extends ByFields
                ? never
                : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
            }[OrderFields]
        : 'Error: If you provide "skip", you also need to provide "orderBy"'
      : ByValid extends True
      ? {}
      : {
          [P in OrderFields]: P extends ByFields
            ? never
            : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
        }[OrderFields]
    >(args: SubsetIntersection<T, SessionGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetSessionGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the Session model
   */
  readonly fields: SessionFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for Session.
   * Why is this prefixed with `Prisma__`?
   * Because we want to prevent naming conflicts as mentioned in
   * https://github.com/prisma/prisma-client-js/issues/707
   */
  export interface Prisma__SessionClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    Log<T extends Session$LogArgs<ExtArgs> = {}>(args?: Subset<T, Session$LogArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$LogPayload<ExtArgs>, T, "findMany"> | Null>
    Profiling<T extends Session$ProfilingArgs<ExtArgs> = {}>(args?: Subset<T, Session$ProfilingArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ProfilingPayload<ExtArgs>, T, "findMany"> | Null>
    build<T extends Session$buildArgs<ExtArgs> = {}>(args?: Subset<T, Session$buildArgs<ExtArgs>>): Prisma__BuildClient<$Result.GetResult<Prisma.$BuildPayload<ExtArgs>, T, "findUniqueOrThrow"> | null, null, ExtArgs>
    SessionLog<T extends Session$SessionLogArgs<ExtArgs> = {}>(args?: Subset<T, Session$SessionLogArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$SessionLogPayload<ExtArgs>, T, "findMany"> | Null>
    Recording<T extends Session$RecordingArgs<ExtArgs> = {}>(args?: Subset<T, Session$RecordingArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$RecordingPayload<ExtArgs>, T, "findMany"> | 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 Session model
   */ 
  interface SessionFieldRefs {
    readonly id: FieldRef<"Session", 'String'>
    readonly build_id: FieldRef<"Session", 'String'>
    readonly name: FieldRef<"Session", 'String'>
    readonly status: FieldRef<"Session", 'String'>
    readonly desired_capabilities: FieldRef<"Session", 'String'>
    readonly session_capabilities: FieldRef<"Session", 'String'>
    readonly node_id: FieldRef<"Session", 'String'>
    readonly has_live_video: FieldRef<"Session", 'Boolean'>
    readonly video_recording_enabled: FieldRef<"Session", 'Boolean'>
    readonly video_recording: FieldRef<"Session", 'String'>
    readonly startTime: FieldRef<"Session", 'DateTime'>
    readonly endTime: FieldRef<"Session", 'DateTime'>
    readonly failure_reason: FieldRef<"Session", 'String'>
    readonly is_profiling_available: FieldRef<"Session", 'Boolean'>
    readonly device_info: FieldRef<"Session", 'String'>
    readonly device_udid: FieldRef<"Session", 'String'>
    readonly device_platform: FieldRef<"Session", 'String'>
    readonly device_version: FieldRef<"Session", 'String'>
    readonly device_name: FieldRef<"Session", 'String'>
    readonly createdAt: FieldRef<"Session", 'DateTime'>
    readonly updatedAt: FieldRef<"Session", 'DateTime'>
    readonly performance_trace: FieldRef<"Session", 'String'>
    readonly failure_category: FieldRef<"Session", 'String'>
    readonly ai_analysis: FieldRef<"Session", 'String'>
    readonly tags: FieldRef<"Session", 'String'>
    readonly trace_id: FieldRef<"Session", 'String'>
    readonly last_heartbeat_at: FieldRef<"Session", 'DateTime'>
    readonly heartbeat_pid: FieldRef<"Session", 'Int'>
    readonly heartbeat_host: FieldRef<"Session", 'String'>
    readonly api_key_id: FieldRef<"Session", 'String'>
    readonly user_id: FieldRef<"Session", 'String'>
  }
    

  // Custom InputTypes
  /**
   * Session findUnique
   */
  export type SessionFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Session
     */
    select?: SessionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SessionInclude<ExtArgs> | null
    /**
     * Filter, which Session to fetch.
     */
    where: SessionWhereUniqueInput
  }

  /**
   * Session findUniqueOrThrow
   */
  export type SessionFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Session
     */
    select?: SessionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SessionInclude<ExtArgs> | null
    /**
     * Filter, which Session to fetch.
     */
    where: SessionWhereUniqueInput
  }

  /**
   * Session findFirst
   */
  export type SessionFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Session
     */
    select?: SessionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SessionInclude<ExtArgs> | null
    /**
     * Filter, which Session to fetch.
     */
    where?: SessionWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Sessions to fetch.
     */
    orderBy?: SessionOrderByWithRelationInput | SessionOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Sessions.
     */
    cursor?: SessionWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Sessions from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Sessions.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Sessions.
     */
    distinct?: SessionScalarFieldEnum | SessionScalarFieldEnum[]
  }

  /**
   * Session findFirstOrThrow
   */
  export type SessionFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Session
     */
    select?: SessionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SessionInclude<ExtArgs> | null
    /**
     * Filter, which Session to fetch.
     */
    where?: SessionWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Sessions to fetch.
     */
    orderBy?: SessionOrderByWithRelationInput | SessionOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Sessions.
     */
    cursor?: SessionWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Sessions from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Sessions.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Sessions.
     */
    distinct?: SessionScalarFieldEnum | SessionScalarFieldEnum[]
  }

  /**
   * Session findMany
   */
  export type SessionFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Session
     */
    select?: SessionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SessionInclude<ExtArgs> | null
    /**
     * Filter, which Sessions to fetch.
     */
    where?: SessionWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Sessions to fetch.
     */
    orderBy?: SessionOrderByWithRelationInput | SessionOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing Sessions.
     */
    cursor?: SessionWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Sessions from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Sessions.
     */
    skip?: number
    distinct?: SessionScalarFieldEnum | SessionScalarFieldEnum[]
  }

  /**
   * Session create
   */
  export type SessionCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Session
     */
    select?: SessionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SessionInclude<ExtArgs> | null
    /**
     * The data needed to create a Session.
     */
    data: XOR<SessionCreateInput, SessionUncheckedCreateInput>
  }

  /**
   * Session createMany
   */
  export type SessionCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many Sessions.
     */
    data: SessionCreateManyInput | SessionCreateManyInput[]
  }

  /**
   * Session createManyAndReturn
   */
  export type SessionCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Session
     */
    select?: SessionSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many Sessions.
     */
    data: SessionCreateManyInput | SessionCreateManyInput[]
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SessionIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * Session update
   */
  export type SessionUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Session
     */
    select?: SessionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SessionInclude<ExtArgs> | null
    /**
     * The data needed to update a Session.
     */
    data: XOR<SessionUpdateInput, SessionUncheckedUpdateInput>
    /**
     * Choose, which Session to update.
     */
    where: SessionWhereUniqueInput
  }

  /**
   * Session updateMany
   */
  export type SessionUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Sessions.
     */
    data: XOR<SessionUpdateManyMutationInput, SessionUncheckedUpdateManyInput>
    /**
     * Filter which Sessions to update
     */
    where?: SessionWhereInput
  }

  /**
   * Session upsert
   */
  export type SessionUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Session
     */
    select?: SessionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SessionInclude<ExtArgs> | null
    /**
     * The filter to search for the Session to update in case it exists.
     */
    where: SessionWhereUniqueInput
    /**
     * In case the Session found by the `where` argument doesn't exist, create a new Session with this data.
     */
    create: XOR<SessionCreateInput, SessionUncheckedCreateInput>
    /**
     * In case the Session was found with the provided `where` argument, update it with this data.
     */
    update: XOR<SessionUpdateInput, SessionUncheckedUpdateInput>
  }

  /**
   * Session delete
   */
  export type SessionDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Session
     */
    select?: SessionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SessionInclude<ExtArgs> | null
    /**
     * Filter which Session to delete.
     */
    where: SessionWhereUniqueInput
  }

  /**
   * Session deleteMany
   */
  export type SessionDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Sessions to delete
     */
    where?: SessionWhereInput
  }

  /**
   * Session.Log
   */
  export type Session$LogArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Log
     */
    select?: LogSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: LogInclude<ExtArgs> | null
    where?: LogWhereInput
    orderBy?: LogOrderByWithRelationInput | LogOrderByWithRelationInput[]
    cursor?: LogWhereUniqueInput
    take?: number
    skip?: number
    distinct?: LogScalarFieldEnum | LogScalarFieldEnum[]
  }

  /**
   * Session.Profiling
   */
  export type Session$ProfilingArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Profiling
     */
    select?: ProfilingSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ProfilingInclude<ExtArgs> | null
    where?: ProfilingWhereInput
    orderBy?: ProfilingOrderByWithRelationInput | ProfilingOrderByWithRelationInput[]
    cursor?: ProfilingWhereUniqueInput
    take?: number
    skip?: number
    distinct?: ProfilingScalarFieldEnum | ProfilingScalarFieldEnum[]
  }

  /**
   * Session.build
   */
  export type Session$buildArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Build
     */
    select?: BuildSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: BuildInclude<ExtArgs> | null
    where?: BuildWhereInput
  }

  /**
   * Session.SessionLog
   */
  export type Session$SessionLogArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the SessionLog
     */
    select?: SessionLogSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SessionLogInclude<ExtArgs> | null
    where?: SessionLogWhereInput
    orderBy?: SessionLogOrderByWithRelationInput | SessionLogOrderByWithRelationInput[]
    cursor?: SessionLogWhereUniqueInput
    take?: number
    skip?: number
    distinct?: SessionLogScalarFieldEnum | SessionLogScalarFieldEnum[]
  }

  /**
   * Session.Recording
   */
  export type Session$RecordingArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Recording
     */
    select?: RecordingSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: RecordingInclude<ExtArgs> | null
    where?: RecordingWhereInput
    orderBy?: RecordingOrderByWithRelationInput | RecordingOrderByWithRelationInput[]
    cursor?: RecordingWhereUniqueInput
    take?: number
    skip?: number
    distinct?: RecordingScalarFieldEnum | RecordingScalarFieldEnum[]
  }

  /**
   * Session without action
   */
  export type SessionDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Session
     */
    select?: SessionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SessionInclude<ExtArgs> | null
  }


  /**
   * Model SessionLog
   */

  export type AggregateSessionLog = {
    _count: SessionLogCountAggregateOutputType | null
    _avg: SessionLogAvgAggregateOutputType | null
    _sum: SessionLogSumAggregateOutputType | null
    _min: SessionLogMinAggregateOutputType | null
    _max: SessionLogMaxAggregateOutputType | null
  }

  export type SessionLogAvgAggregateOutputType = {
    healing_confidence: number | null
    duration: number | null
  }

  export type SessionLogSumAggregateOutputType = {
    healing_confidence: number | null
    duration: number | null
  }

  export type SessionLogMinAggregateOutputType = {
    id: string | null
    session_id: string | null
    command_name: string | null
    url: string | null
    method: string | null
    title: string | null
    subtitle: string | null
    body: string | null
    response: string | null
    screenshot: string | null
    is_success: boolean | null
    is_error: boolean | null
    is_healed: boolean | null
    original_selector: string | null
    healed_selector: string | null
    healing_confidence: number | null
    healing_tier: string | null
    original_strategy: string | null
    healed_strategy: string | null
    createdAt: Date | null
    updatedAt: Date | null
    duration: number | null
    span_id: string | null
    trace_id: string | null
  }

  export type SessionLogMaxAggregateOutputType = {
    id: string | null
    session_id: string | null
    command_name: string | null
    url: string | null
    method: string | null
    title: string | null
    subtitle: string | null
    body: string | null
    response: string | null
    screenshot: string | null
    is_success: boolean | null
    is_error: boolean | null
    is_healed: boolean | null
    original_selector: string | null
    healed_selector: string | null
    healing_confidence: number | null
    healing_tier: string | null
    original_strategy: string | null
    healed_strategy: string | null
    createdAt: Date | null
    updatedAt: Date | null
    duration: number | null
    span_id: string | null
    trace_id: string | null
  }

  export type SessionLogCountAggregateOutputType = {
    id: number
    session_id: number
    command_name: number
    url: number
    method: number
    title: number
    subtitle: number
    body: number
    response: number
    screenshot: number
    is_success: number
    is_error: number
    is_healed: number
    original_selector: number
    healed_selector: number
    healing_confidence: number
    healing_tier: number
    original_strategy: number
    healed_strategy: number
    createdAt: number
    updatedAt: number
    duration: number
    span_id: number
    trace_id: number
    _all: number
  }


  export type SessionLogAvgAggregateInputType = {
    healing_confidence?: true
    duration?: true
  }

  export type SessionLogSumAggregateInputType = {
    healing_confidence?: true
    duration?: true
  }

  export type SessionLogMinAggregateInputType = {
    id?: true
    session_id?: true
    command_name?: true
    url?: true
    method?: true
    title?: true
    subtitle?: true
    body?: true
    response?: true
    screenshot?: true
    is_success?: true
    is_error?: true
    is_healed?: true
    original_selector?: true
    healed_selector?: true
    healing_confidence?: true
    healing_tier?: true
    original_strategy?: true
    healed_strategy?: true
    createdAt?: true
    updatedAt?: true
    duration?: true
    span_id?: true
    trace_id?: true
  }

  export type SessionLogMaxAggregateInputType = {
    id?: true
    session_id?: true
    command_name?: true
    url?: true
    method?: true
    title?: true
    subtitle?: true
    body?: true
    response?: true
    screenshot?: true
    is_success?: true
    is_error?: true
    is_healed?: true
    original_selector?: true
    healed_selector?: true
    healing_confidence?: true
    healing_tier?: true
    original_strategy?: true
    healed_strategy?: true
    createdAt?: true
    updatedAt?: true
    duration?: true
    span_id?: true
    trace_id?: true
  }

  export type SessionLogCountAggregateInputType = {
    id?: true
    session_id?: true
    command_name?: true
    url?: true
    method?: true
    title?: true
    subtitle?: true
    body?: true
    response?: true
    screenshot?: true
    is_success?: true
    is_error?: true
    is_healed?: true
    original_selector?: true
    healed_selector?: true
    healing_confidence?: true
    healing_tier?: true
    original_strategy?: true
    healed_strategy?: true
    createdAt?: true
    updatedAt?: true
    duration?: true
    span_id?: true
    trace_id?: true
    _all?: true
  }

  export type SessionLogAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which SessionLog to aggregate.
     */
    where?: SessionLogWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of SessionLogs to fetch.
     */
    orderBy?: SessionLogOrderByWithRelationInput | SessionLogOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: SessionLogWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` SessionLogs 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` SessionLogs.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned SessionLogs
    **/
    _count?: true | SessionLogCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: SessionLogAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: SessionLogSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: SessionLogMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: SessionLogMaxAggregateInputType
  }

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




  export type SessionLogGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: SessionLogWhereInput
    orderBy?: SessionLogOrderByWithAggregationInput | SessionLogOrderByWithAggregationInput[]
    by: SessionLogScalarFieldEnum[] | SessionLogScalarFieldEnum
    having?: SessionLogScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: SessionLogCountAggregateInputType | true
    _avg?: SessionLogAvgAggregateInputType
    _sum?: SessionLogSumAggregateInputType
    _min?: SessionLogMinAggregateInputType
    _max?: SessionLogMaxAggregateInputType
  }

  export type SessionLogGroupByOutputType = {
    id: string
    session_id: string
    command_name: string | null
    url: string
    method: string
    title: string
    subtitle: string | null
    body: string | null
    response: string
    screenshot: string | null
    is_success: boolean | null
    is_error: boolean
    is_healed: boolean
    original_selector: string | null
    healed_selector: string | null
    healing_confidence: number | null
    healing_tier: string | null
    original_strategy: string | null
    healed_strategy: string | null
    createdAt: Date
    updatedAt: Date
    duration: number | null
    span_id: string | null
    trace_id: string | null
    _count: SessionLogCountAggregateOutputType | null
    _avg: SessionLogAvgAggregateOutputType | null
    _sum: SessionLogSumAggregateOutputType | null
    _min: SessionLogMinAggregateOutputType | null
    _max: SessionLogMaxAggregateOutputType | null
  }

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


  export type SessionLogSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    session_id?: boolean
    command_name?: boolean
    url?: boolean
    method?: boolean
    title?: boolean
    subtitle?: boolean
    body?: boolean
    response?: boolean
    screenshot?: boolean
    is_success?: boolean
    is_error?: boolean
    is_healed?: boolean
    original_selector?: boolean
    healed_selector?: boolean
    healing_confidence?: boolean
    healing_tier?: boolean
    original_strategy?: boolean
    healed_strategy?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    duration?: boolean
    span_id?: boolean
    trace_id?: boolean
    session?: boolean | SessionDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["sessionLog"]>

  export type SessionLogSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    session_id?: boolean
    command_name?: boolean
    url?: boolean
    method?: boolean
    title?: boolean
    subtitle?: boolean
    body?: boolean
    response?: boolean
    screenshot?: boolean
    is_success?: boolean
    is_error?: boolean
    is_healed?: boolean
    original_selector?: boolean
    healed_selector?: boolean
    healing_confidence?: boolean
    healing_tier?: boolean
    original_strategy?: boolean
    healed_strategy?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    duration?: boolean
    span_id?: boolean
    trace_id?: boolean
    session?: boolean | SessionDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["sessionLog"]>

  export type SessionLogSelectScalar = {
    id?: boolean
    session_id?: boolean
    command_name?: boolean
    url?: boolean
    method?: boolean
    title?: boolean
    subtitle?: boolean
    body?: boolean
    response?: boolean
    screenshot?: boolean
    is_success?: boolean
    is_error?: boolean
    is_healed?: boolean
    original_selector?: boolean
    healed_selector?: boolean
    healing_confidence?: boolean
    healing_tier?: boolean
    original_strategy?: boolean
    healed_strategy?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    duration?: boolean
    span_id?: boolean
    trace_id?: boolean
  }

  export type SessionLogInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    session?: boolean | SessionDefaultArgs<ExtArgs>
  }
  export type SessionLogIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    session?: boolean | SessionDefaultArgs<ExtArgs>
  }

  export type $SessionLogPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "SessionLog"
    objects: {
      session: Prisma.$SessionPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      session_id: string
      command_name: string | null
      url: string
      method: string
      title: string
      subtitle: string | null
      body: string | null
      response: string
      screenshot: string | null
      is_success: boolean | null
      is_error: boolean
      is_healed: boolean
      original_selector: string | null
      healed_selector: string | null
      healing_confidence: number | null
      healing_tier: string | null
      original_strategy: string | null
      healed_strategy: string | null
      createdAt: Date
      updatedAt: Date
      duration: number | null
      span_id: string | null
      trace_id: string | null
    }, ExtArgs["result"]["sessionLog"]>
    composites: {}
  }

  type SessionLogGetPayload<S extends boolean | null | undefined | SessionLogDefaultArgs> = $Result.GetResult<Prisma.$SessionLogPayload, S>

  type SessionLogCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<SessionLogFindManyArgs, 'select' | 'include' | 'distinct'> & {
      select?: SessionLogCountAggregateInputType | true
    }

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

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

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

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

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

    /**
     * Create a SessionLog.
     * @param {SessionLogCreateArgs} args - Arguments to create a SessionLog.
     * @example
     * // Create one SessionLog
     * const SessionLog = await prisma.sessionLog.create({
     *   data: {
     *     // ... data to create a SessionLog
     *   }
     * })
     * 
     */
    create<T extends SessionLogCreateArgs>(args: SelectSubset<T, SessionLogCreateArgs<ExtArgs>>): Prisma__SessionLogClient<$Result.GetResult<Prisma.$SessionLogPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

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

    /**
     * Delete a SessionLog.
     * @param {SessionLogDeleteArgs} args - Arguments to delete one SessionLog.
     * @example
     * // Delete one SessionLog
     * const SessionLog = await prisma.sessionLog.delete({
     *   where: {
     *     // ... filter to delete one SessionLog
     *   }
     * })
     * 
     */
    delete<T extends SessionLogDeleteArgs>(args: SelectSubset<T, SessionLogDeleteArgs<ExtArgs>>): Prisma__SessionLogClient<$Result.GetResult<Prisma.$SessionLogPayload<ExtArgs>, T, "delete">, never, ExtArgs>

    /**
     * Update one SessionLog.
     * @param {SessionLogUpdateArgs} args - Arguments to update one SessionLog.
     * @example
     * // Update one SessionLog
     * const sessionLog = await prisma.sessionLog.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends SessionLogUpdateArgs>(args: SelectSubset<T, SessionLogUpdateArgs<ExtArgs>>): Prisma__SessionLogClient<$Result.GetResult<Prisma.$SessionLogPayload<ExtArgs>, T, "update">, never, ExtArgs>

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

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

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for SessionLog.
   * 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__SessionLogClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    session<T extends SessionDefaultArgs<ExtArgs> = {}>(args?: Subset<T, SessionDefaultArgs<ExtArgs>>): Prisma__SessionClient<$Result.GetResult<Prisma.$SessionPayload<ExtArgs>, T, "findUniqueOrThrow"> | Null, Null, ExtArgs>
    /**
     * 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 SessionLog model
   */ 
  interface SessionLogFieldRefs {
    readonly id: FieldRef<"SessionLog", 'String'>
    readonly session_id: FieldRef<"SessionLog", 'String'>
    readonly command_name: FieldRef<"SessionLog", 'String'>
    readonly url: FieldRef<"SessionLog", 'String'>
    readonly method: FieldRef<"SessionLog", 'String'>
    readonly title: FieldRef<"SessionLog", 'String'>
    readonly subtitle: FieldRef<"SessionLog", 'String'>
    readonly body: FieldRef<"SessionLog", 'String'>
    readonly response: FieldRef<"SessionLog", 'String'>
    readonly screenshot: FieldRef<"SessionLog", 'String'>
    readonly is_success: FieldRef<"SessionLog", 'Boolean'>
    readonly is_error: FieldRef<"SessionLog", 'Boolean'>
    readonly is_healed: FieldRef<"SessionLog", 'Boolean'>
    readonly original_selector: FieldRef<"SessionLog", 'String'>
    readonly healed_selector: FieldRef<"SessionLog", 'String'>
    readonly healing_confidence: FieldRef<"SessionLog", 'Float'>
    readonly healing_tier: FieldRef<"SessionLog", 'String'>
    readonly original_strategy: FieldRef<"SessionLog", 'String'>
    readonly healed_strategy: FieldRef<"SessionLog", 'String'>
    readonly createdAt: FieldRef<"SessionLog", 'DateTime'>
    readonly updatedAt: FieldRef<"SessionLog", 'DateTime'>
    readonly duration: FieldRef<"SessionLog", 'Int'>
    readonly span_id: FieldRef<"SessionLog", 'String'>
    readonly trace_id: FieldRef<"SessionLog", 'String'>
  }
    

  // Custom InputTypes
  /**
   * SessionLog findUnique
   */
  export type SessionLogFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the SessionLog
     */
    select?: SessionLogSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SessionLogInclude<ExtArgs> | null
    /**
     * Filter, which SessionLog to fetch.
     */
    where: SessionLogWhereUniqueInput
  }

  /**
   * SessionLog findUniqueOrThrow
   */
  export type SessionLogFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the SessionLog
     */
    select?: SessionLogSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SessionLogInclude<ExtArgs> | null
    /**
     * Filter, which SessionLog to fetch.
     */
    where: SessionLogWhereUniqueInput
  }

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

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

  /**
   * SessionLog findMany
   */
  export type SessionLogFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the SessionLog
     */
    select?: SessionLogSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SessionLogInclude<ExtArgs> | null
    /**
     * Filter, which SessionLogs to fetch.
     */
    where?: SessionLogWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of SessionLogs to fetch.
     */
    orderBy?: SessionLogOrderByWithRelationInput | SessionLogOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing SessionLogs.
     */
    cursor?: SessionLogWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` SessionLogs 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` SessionLogs.
     */
    skip?: number
    distinct?: SessionLogScalarFieldEnum | SessionLogScalarFieldEnum[]
  }

  /**
   * SessionLog create
   */
  export type SessionLogCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the SessionLog
     */
    select?: SessionLogSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SessionLogInclude<ExtArgs> | null
    /**
     * The data needed to create a SessionLog.
     */
    data: XOR<SessionLogCreateInput, SessionLogUncheckedCreateInput>
  }

  /**
   * SessionLog createMany
   */
  export type SessionLogCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many SessionLogs.
     */
    data: SessionLogCreateManyInput | SessionLogCreateManyInput[]
  }

  /**
   * SessionLog createManyAndReturn
   */
  export type SessionLogCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the SessionLog
     */
    select?: SessionLogSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many SessionLogs.
     */
    data: SessionLogCreateManyInput | SessionLogCreateManyInput[]
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SessionLogIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * SessionLog update
   */
  export type SessionLogUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the SessionLog
     */
    select?: SessionLogSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SessionLogInclude<ExtArgs> | null
    /**
     * The data needed to update a SessionLog.
     */
    data: XOR<SessionLogUpdateInput, SessionLogUncheckedUpdateInput>
    /**
     * Choose, which SessionLog to update.
     */
    where: SessionLogWhereUniqueInput
  }

  /**
   * SessionLog updateMany
   */
  export type SessionLogUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update SessionLogs.
     */
    data: XOR<SessionLogUpdateManyMutationInput, SessionLogUncheckedUpdateManyInput>
    /**
     * Filter which SessionLogs to update
     */
    where?: SessionLogWhereInput
  }

  /**
   * SessionLog upsert
   */
  export type SessionLogUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the SessionLog
     */
    select?: SessionLogSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SessionLogInclude<ExtArgs> | null
    /**
     * The filter to search for the SessionLog to update in case it exists.
     */
    where: SessionLogWhereUniqueInput
    /**
     * In case the SessionLog found by the `where` argument doesn't exist, create a new SessionLog with this data.
     */
    create: XOR<SessionLogCreateInput, SessionLogUncheckedCreateInput>
    /**
     * In case the SessionLog was found with the provided `where` argument, update it with this data.
     */
    update: XOR<SessionLogUpdateInput, SessionLogUncheckedUpdateInput>
  }

  /**
   * SessionLog delete
   */
  export type SessionLogDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the SessionLog
     */
    select?: SessionLogSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SessionLogInclude<ExtArgs> | null
    /**
     * Filter which SessionLog to delete.
     */
    where: SessionLogWhereUniqueInput
  }

  /**
   * SessionLog deleteMany
   */
  export type SessionLogDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which SessionLogs to delete
     */
    where?: SessionLogWhereInput
  }

  /**
   * SessionLog without action
   */
  export type SessionLogDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the SessionLog
     */
    select?: SessionLogSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SessionLogInclude<ExtArgs> | null
  }


  /**
   * Model Log
   */

  export type AggregateLog = {
    _count: LogCountAggregateOutputType | null
    _min: LogMinAggregateOutputType | null
    _max: LogMaxAggregateOutputType | null
  }

  export type LogMinAggregateOutputType = {
    id: string | null
    session_id: string | null
    log_type: string | null
    message: string | null
    timestamp: Date | null
    createdAt: Date | null
    updatedAt: Date | null
  }

  export type LogMaxAggregateOutputType = {
    id: string | null
    session_id: string | null
    log_type: string | null
    message: string | null
    timestamp: Date | null
    createdAt: Date | null
    updatedAt: Date | null
  }

  export type LogCountAggregateOutputType = {
    id: number
    session_id: number
    log_type: number
    message: number
    timestamp: number
    createdAt: number
    updatedAt: number
    _all: number
  }


  export type LogMinAggregateInputType = {
    id?: true
    session_id?: true
    log_type?: true
    message?: true
    timestamp?: true
    createdAt?: true
    updatedAt?: true
  }

  export type LogMaxAggregateInputType = {
    id?: true
    session_id?: true
    log_type?: true
    message?: true
    timestamp?: true
    createdAt?: true
    updatedAt?: true
  }

  export type LogCountAggregateInputType = {
    id?: true
    session_id?: true
    log_type?: true
    message?: true
    timestamp?: true
    createdAt?: true
    updatedAt?: true
    _all?: true
  }

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

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




  export type LogGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: LogWhereInput
    orderBy?: LogOrderByWithAggregationInput | LogOrderByWithAggregationInput[]
    by: LogScalarFieldEnum[] | LogScalarFieldEnum
    having?: LogScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: LogCountAggregateInputType | true
    _min?: LogMinAggregateInputType
    _max?: LogMaxAggregateInputType
  }

  export type LogGroupByOutputType = {
    id: string
    session_id: string
    log_type: string
    message: string
    timestamp: Date
    createdAt: Date
    updatedAt: Date
    _count: LogCountAggregateOutputType | null
    _min: LogMinAggregateOutputType | null
    _max: LogMaxAggregateOutputType | null
  }

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


  export type LogSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    session_id?: boolean
    log_type?: boolean
    message?: boolean
    timestamp?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    session?: boolean | SessionDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["log"]>

  export type LogSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    session_id?: boolean
    log_type?: boolean
    message?: boolean
    timestamp?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    session?: boolean | SessionDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["log"]>

  export type LogSelectScalar = {
    id?: boolean
    session_id?: boolean
    log_type?: boolean
    message?: boolean
    timestamp?: boolean
    createdAt?: boolean
    updatedAt?: boolean
  }

  export type LogInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    session?: boolean | SessionDefaultArgs<ExtArgs>
  }
  export type LogIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    session?: boolean | SessionDefaultArgs<ExtArgs>
  }

  export type $LogPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Log"
    objects: {
      session: Prisma.$SessionPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      session_id: string
      log_type: string
      message: string
      timestamp: Date
      createdAt: Date
      updatedAt: Date
    }, ExtArgs["result"]["log"]>
    composites: {}
  }

  type LogGetPayload<S extends boolean | null | undefined | LogDefaultArgs> = $Result.GetResult<Prisma.$LogPayload, S>

  type LogCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<LogFindManyArgs, 'select' | 'include' | 'distinct'> & {
      select?: LogCountAggregateInputType | true
    }

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

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

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

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

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

    /**
     * Create a Log.
     * @param {LogCreateArgs} args - Arguments to create a Log.
     * @example
     * // Create one Log
     * const Log = await prisma.log.create({
     *   data: {
     *     // ... data to create a Log
     *   }
     * })
     * 
     */
    create<T extends LogCreateArgs>(args: SelectSubset<T, LogCreateArgs<ExtArgs>>): Prisma__LogClient<$Result.GetResult<Prisma.$LogPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

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

    /**
     * Delete a Log.
     * @param {LogDeleteArgs} args - Arguments to delete one Log.
     * @example
     * // Delete one Log
     * const Log = await prisma.log.delete({
     *   where: {
     *     // ... filter to delete one Log
     *   }
     * })
     * 
     */
    delete<T extends LogDeleteArgs>(args: SelectSubset<T, LogDeleteArgs<ExtArgs>>): Prisma__LogClient<$Result.GetResult<Prisma.$LogPayload<ExtArgs>, T, "delete">, never, ExtArgs>

    /**
     * Update one Log.
     * @param {LogUpdateArgs} args - Arguments to update one Log.
     * @example
     * // Update one Log
     * const log = await prisma.log.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends LogUpdateArgs>(args: SelectSubset<T, LogUpdateArgs<ExtArgs>>): Prisma__LogClient<$Result.GetResult<Prisma.$LogPayload<ExtArgs>, T, "update">, never, ExtArgs>

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

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

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for Log.
   * 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__LogClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    session<T extends SessionDefaultArgs<ExtArgs> = {}>(args?: Subset<T, SessionDefaultArgs<ExtArgs>>): Prisma__SessionClient<$Result.GetResult<Prisma.$SessionPayload<ExtArgs>, T, "findUniqueOrThrow"> | Null, Null, ExtArgs>
    /**
     * 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 Log model
   */ 
  interface LogFieldRefs {
    readonly id: FieldRef<"Log", 'String'>
    readonly session_id: FieldRef<"Log", 'String'>
    readonly log_type: FieldRef<"Log", 'String'>
    readonly message: FieldRef<"Log", 'String'>
    readonly timestamp: FieldRef<"Log", 'DateTime'>
    readonly createdAt: FieldRef<"Log", 'DateTime'>
    readonly updatedAt: FieldRef<"Log", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * Log findUnique
   */
  export type LogFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Log
     */
    select?: LogSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: LogInclude<ExtArgs> | null
    /**
     * Filter, which Log to fetch.
     */
    where: LogWhereUniqueInput
  }

  /**
   * Log findUniqueOrThrow
   */
  export type LogFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Log
     */
    select?: LogSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: LogInclude<ExtArgs> | null
    /**
     * Filter, which Log to fetch.
     */
    where: LogWhereUniqueInput
  }

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

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

  /**
   * Log findMany
   */
  export type LogFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Log
     */
    select?: LogSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: LogInclude<ExtArgs> | null
    /**
     * Filter, which Logs to fetch.
     */
    where?: LogWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Logs to fetch.
     */
    orderBy?: LogOrderByWithRelationInput | LogOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing Logs.
     */
    cursor?: LogWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Logs 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` Logs.
     */
    skip?: number
    distinct?: LogScalarFieldEnum | LogScalarFieldEnum[]
  }

  /**
   * Log create
   */
  export type LogCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Log
     */
    select?: LogSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: LogInclude<ExtArgs> | null
    /**
     * The data needed to create a Log.
     */
    data: XOR<LogCreateInput, LogUncheckedCreateInput>
  }

  /**
   * Log createMany
   */
  export type LogCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many Logs.
     */
    data: LogCreateManyInput | LogCreateManyInput[]
  }

  /**
   * Log createManyAndReturn
   */
  export type LogCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Log
     */
    select?: LogSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many Logs.
     */
    data: LogCreateManyInput | LogCreateManyInput[]
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: LogIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * Log update
   */
  export type LogUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Log
     */
    select?: LogSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: LogInclude<ExtArgs> | null
    /**
     * The data needed to update a Log.
     */
    data: XOR<LogUpdateInput, LogUncheckedUpdateInput>
    /**
     * Choose, which Log to update.
     */
    where: LogWhereUniqueInput
  }

  /**
   * Log updateMany
   */
  export type LogUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Logs.
     */
    data: XOR<LogUpdateManyMutationInput, LogUncheckedUpdateManyInput>
    /**
     * Filter which Logs to update
     */
    where?: LogWhereInput
  }

  /**
   * Log upsert
   */
  export type LogUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Log
     */
    select?: LogSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: LogInclude<ExtArgs> | null
    /**
     * The filter to search for the Log to update in case it exists.
     */
    where: LogWhereUniqueInput
    /**
     * In case the Log found by the `where` argument doesn't exist, create a new Log with this data.
     */
    create: XOR<LogCreateInput, LogUncheckedCreateInput>
    /**
     * In case the Log was found with the provided `where` argument, update it with this data.
     */
    update: XOR<LogUpdateInput, LogUncheckedUpdateInput>
  }

  /**
   * Log delete
   */
  export type LogDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Log
     */
    select?: LogSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: LogInclude<ExtArgs> | null
    /**
     * Filter which Log to delete.
     */
    where: LogWhereUniqueInput
  }

  /**
   * Log deleteMany
   */
  export type LogDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Logs to delete
     */
    where?: LogWhereInput
  }

  /**
   * Log without action
   */
  export type LogDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Log
     */
    select?: LogSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: LogInclude<ExtArgs> | null
  }


  /**
   * Model Profiling
   */

  export type AggregateProfiling = {
    _count: ProfilingCountAggregateOutputType | null
    _avg: ProfilingAvgAggregateOutputType | null
    _sum: ProfilingSumAggregateOutputType | null
    _min: ProfilingMinAggregateOutputType | null
    _max: ProfilingMaxAggregateOutputType | null
  }

  export type ProfilingAvgAggregateOutputType = {
    id: number | null
  }

  export type ProfilingSumAggregateOutputType = {
    id: number | null
  }

  export type ProfilingMinAggregateOutputType = {
    id: number | null
    session_id: string | null
    cpu: string | null
    memory: string | null
    total_cpu_used: string | null
    total_memory_used: string | null
    raw_cpu_log: string | null
    raw_memory_log: string | null
    timestamp: Date | null
    createdAt: Date | null
    updatedAt: Date | null
  }

  export type ProfilingMaxAggregateOutputType = {
    id: number | null
    session_id: string | null
    cpu: string | null
    memory: string | null
    total_cpu_used: string | null
    total_memory_used: string | null
    raw_cpu_log: string | null
    raw_memory_log: string | null
    timestamp: Date | null
    createdAt: Date | null
    updatedAt: Date | null
  }

  export type ProfilingCountAggregateOutputType = {
    id: number
    session_id: number
    cpu: number
    memory: number
    total_cpu_used: number
    total_memory_used: number
    raw_cpu_log: number
    raw_memory_log: number
    timestamp: number
    createdAt: number
    updatedAt: number
    _all: number
  }


  export type ProfilingAvgAggregateInputType = {
    id?: true
  }

  export type ProfilingSumAggregateInputType = {
    id?: true
  }

  export type ProfilingMinAggregateInputType = {
    id?: true
    session_id?: true
    cpu?: true
    memory?: true
    total_cpu_used?: true
    total_memory_used?: true
    raw_cpu_log?: true
    raw_memory_log?: true
    timestamp?: true
    createdAt?: true
    updatedAt?: true
  }

  export type ProfilingMaxAggregateInputType = {
    id?: true
    session_id?: true
    cpu?: true
    memory?: true
    total_cpu_used?: true
    total_memory_used?: true
    raw_cpu_log?: true
    raw_memory_log?: true
    timestamp?: true
    createdAt?: true
    updatedAt?: true
  }

  export type ProfilingCountAggregateInputType = {
    id?: true
    session_id?: true
    cpu?: true
    memory?: true
    total_cpu_used?: true
    total_memory_used?: true
    raw_cpu_log?: true
    raw_memory_log?: true
    timestamp?: true
    createdAt?: true
    updatedAt?: true
    _all?: true
  }

  export type ProfilingAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Profiling to aggregate.
     */
    where?: ProfilingWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Profilings to fetch.
     */
    orderBy?: ProfilingOrderByWithRelationInput | ProfilingOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: ProfilingWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Profilings 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` Profilings.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned Profilings
    **/
    _count?: true | ProfilingCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: ProfilingAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: ProfilingSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: ProfilingMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: ProfilingMaxAggregateInputType
  }

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




  export type ProfilingGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: ProfilingWhereInput
    orderBy?: ProfilingOrderByWithAggregationInput | ProfilingOrderByWithAggregationInput[]
    by: ProfilingScalarFieldEnum[] | ProfilingScalarFieldEnum
    having?: ProfilingScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: ProfilingCountAggregateInputType | true
    _avg?: ProfilingAvgAggregateInputType
    _sum?: ProfilingSumAggregateInputType
    _min?: ProfilingMinAggregateInputType
    _max?: ProfilingMaxAggregateInputType
  }

  export type ProfilingGroupByOutputType = {
    id: number
    session_id: string
    cpu: string | null
    memory: string | null
    total_cpu_used: string | null
    total_memory_used: string | null
    raw_cpu_log: string | null
    raw_memory_log: string | null
    timestamp: Date
    createdAt: Date
    updatedAt: Date
    _count: ProfilingCountAggregateOutputType | null
    _avg: ProfilingAvgAggregateOutputType | null
    _sum: ProfilingSumAggregateOutputType | null
    _min: ProfilingMinAggregateOutputType | null
    _max: ProfilingMaxAggregateOutputType | null
  }

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


  export type ProfilingSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    session_id?: boolean
    cpu?: boolean
    memory?: boolean
    total_cpu_used?: boolean
    total_memory_used?: boolean
    raw_cpu_log?: boolean
    raw_memory_log?: boolean
    timestamp?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    session?: boolean | SessionDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["profiling"]>

  export type ProfilingSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    session_id?: boolean
    cpu?: boolean
    memory?: boolean
    total_cpu_used?: boolean
    total_memory_used?: boolean
    raw_cpu_log?: boolean
    raw_memory_log?: boolean
    timestamp?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    session?: boolean | SessionDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["profiling"]>

  export type ProfilingSelectScalar = {
    id?: boolean
    session_id?: boolean
    cpu?: boolean
    memory?: boolean
    total_cpu_used?: boolean
    total_memory_used?: boolean
    raw_cpu_log?: boolean
    raw_memory_log?: boolean
    timestamp?: boolean
    createdAt?: boolean
    updatedAt?: boolean
  }

  export type ProfilingInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    session?: boolean | SessionDefaultArgs<ExtArgs>
  }
  export type ProfilingIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    session?: boolean | SessionDefaultArgs<ExtArgs>
  }

  export type $ProfilingPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Profiling"
    objects: {
      session: Prisma.$SessionPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: number
      session_id: string
      cpu: string | null
      memory: string | null
      total_cpu_used: string | null
      total_memory_used: string | null
      raw_cpu_log: string | null
      raw_memory_log: string | null
      timestamp: Date
      createdAt: Date
      updatedAt: Date
    }, ExtArgs["result"]["profiling"]>
    composites: {}
  }

  type ProfilingGetPayload<S extends boolean | null | undefined | ProfilingDefaultArgs> = $Result.GetResult<Prisma.$ProfilingPayload, S>

  type ProfilingCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<ProfilingFindManyArgs, 'select' | 'include' | 'distinct'> & {
      select?: ProfilingCountAggregateInputType | true
    }

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

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

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

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

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

    /**
     * Create a Profiling.
     * @param {ProfilingCreateArgs} args - Arguments to create a Profiling.
     * @example
     * // Create one Profiling
     * const Profiling = await prisma.profiling.create({
     *   data: {
     *     // ... data to create a Profiling
     *   }
     * })
     * 
     */
    create<T extends ProfilingCreateArgs>(args: SelectSubset<T, ProfilingCreateArgs<ExtArgs>>): Prisma__ProfilingClient<$Result.GetResult<Prisma.$ProfilingPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

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

    /**
     * Delete a Profiling.
     * @param {ProfilingDeleteArgs} args - Arguments to delete one Profiling.
     * @example
     * // Delete one Profiling
     * const Profiling = await prisma.profiling.delete({
     *   where: {
     *     // ... filter to delete one Profiling
     *   }
     * })
     * 
     */
    delete<T extends ProfilingDeleteArgs>(args: SelectSubset<T, ProfilingDeleteArgs<ExtArgs>>): Prisma__ProfilingClient<$Result.GetResult<Prisma.$ProfilingPayload<ExtArgs>, T, "delete">, never, ExtArgs>

    /**
     * Update one Profiling.
     * @param {ProfilingUpdateArgs} args - Arguments to update one Profiling.
     * @example
     * // Update one Profiling
     * const profiling = await prisma.profiling.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends ProfilingUpdateArgs>(args: SelectSubset<T, ProfilingUpdateArgs<ExtArgs>>): Prisma__ProfilingClient<$Result.GetResult<Prisma.$ProfilingPayload<ExtArgs>, T, "update">, never, ExtArgs>

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

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

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for Profiling.
   * 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__ProfilingClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    session<T extends SessionDefaultArgs<ExtArgs> = {}>(args?: Subset<T, SessionDefaultArgs<ExtArgs>>): Prisma__SessionClient<$Result.GetResult<Prisma.$SessionPayload<ExtArgs>, T, "findUniqueOrThrow"> | Null, Null, ExtArgs>
    /**
     * 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 Profiling model
   */ 
  interface ProfilingFieldRefs {
    readonly id: FieldRef<"Profiling", 'Int'>
    readonly session_id: FieldRef<"Profiling", 'String'>
    readonly cpu: FieldRef<"Profiling", 'String'>
    readonly memory: FieldRef<"Profiling", 'String'>
    readonly total_cpu_used: FieldRef<"Profiling", 'String'>
    readonly total_memory_used: FieldRef<"Profiling", 'String'>
    readonly raw_cpu_log: FieldRef<"Profiling", 'String'>
    readonly raw_memory_log: FieldRef<"Profiling", 'String'>
    readonly timestamp: FieldRef<"Profiling", 'DateTime'>
    readonly createdAt: FieldRef<"Profiling", 'DateTime'>
    readonly updatedAt: FieldRef<"Profiling", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * Profiling findUnique
   */
  export type ProfilingFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Profiling
     */
    select?: ProfilingSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ProfilingInclude<ExtArgs> | null
    /**
     * Filter, which Profiling to fetch.
     */
    where: ProfilingWhereUniqueInput
  }

  /**
   * Profiling findUniqueOrThrow
   */
  export type ProfilingFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Profiling
     */
    select?: ProfilingSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ProfilingInclude<ExtArgs> | null
    /**
     * Filter, which Profiling to fetch.
     */
    where: ProfilingWhereUniqueInput
  }

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

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

  /**
   * Profiling findMany
   */
  export type ProfilingFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Profiling
     */
    select?: ProfilingSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ProfilingInclude<ExtArgs> | null
    /**
     * Filter, which Profilings to fetch.
     */
    where?: ProfilingWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Profilings to fetch.
     */
    orderBy?: ProfilingOrderByWithRelationInput | ProfilingOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing Profilings.
     */
    cursor?: ProfilingWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Profilings 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` Profilings.
     */
    skip?: number
    distinct?: ProfilingScalarFieldEnum | ProfilingScalarFieldEnum[]
  }

  /**
   * Profiling create
   */
  export type ProfilingCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Profiling
     */
    select?: ProfilingSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ProfilingInclude<ExtArgs> | null
    /**
     * The data needed to create a Profiling.
     */
    data: XOR<ProfilingCreateInput, ProfilingUncheckedCreateInput>
  }

  /**
   * Profiling createMany
   */
  export type ProfilingCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many Profilings.
     */
    data: ProfilingCreateManyInput | ProfilingCreateManyInput[]
  }

  /**
   * Profiling createManyAndReturn
   */
  export type ProfilingCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Profiling
     */
    select?: ProfilingSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many Profilings.
     */
    data: ProfilingCreateManyInput | ProfilingCreateManyInput[]
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ProfilingIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * Profiling update
   */
  export type ProfilingUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Profiling
     */
    select?: ProfilingSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ProfilingInclude<ExtArgs> | null
    /**
     * The data needed to update a Profiling.
     */
    data: XOR<ProfilingUpdateInput, ProfilingUncheckedUpdateInput>
    /**
     * Choose, which Profiling to update.
     */
    where: ProfilingWhereUniqueInput
  }

  /**
   * Profiling updateMany
   */
  export type ProfilingUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Profilings.
     */
    data: XOR<ProfilingUpdateManyMutationInput, ProfilingUncheckedUpdateManyInput>
    /**
     * Filter which Profilings to update
     */
    where?: ProfilingWhereInput
  }

  /**
   * Profiling upsert
   */
  export type ProfilingUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Profiling
     */
    select?: ProfilingSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ProfilingInclude<ExtArgs> | null
    /**
     * The filter to search for the Profiling to update in case it exists.
     */
    where: ProfilingWhereUniqueInput
    /**
     * In case the Profiling found by the `where` argument doesn't exist, create a new Profiling with this data.
     */
    create: XOR<ProfilingCreateInput, ProfilingUncheckedCreateInput>
    /**
     * In case the Profiling was found with the provided `where` argument, update it with this data.
     */
    update: XOR<ProfilingUpdateInput, ProfilingUncheckedUpdateInput>
  }

  /**
   * Profiling delete
   */
  export type ProfilingDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Profiling
     */
    select?: ProfilingSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ProfilingInclude<ExtArgs> | null
    /**
     * Filter which Profiling to delete.
     */
    where: ProfilingWhereUniqueInput
  }

  /**
   * Profiling deleteMany
   */
  export type ProfilingDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Profilings to delete
     */
    where?: ProfilingWhereInput
  }

  /**
   * Profiling without action
   */
  export type ProfilingDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Profiling
     */
    select?: ProfilingSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ProfilingInclude<ExtArgs> | null
  }


  /**
   * Model App
   */

  export type AggregateApp = {
    _count: AppCountAggregateOutputType | null
    _avg: AppAvgAggregateOutputType | null
    _sum: AppSumAggregateOutputType | null
    _min: AppMinAggregateOutputType | null
    _max: AppMaxAggregateOutputType | null
  }

  export type AppAvgAggregateOutputType = {
    size: number | null
  }

  export type AppSumAggregateOutputType = {
    size: number | null
  }

  export type AppMinAggregateOutputType = {
    id: string | null
    name: string | null
    filename: string | null
    filepath: string | null
    mimetype: string | null
    size: number | null
    packageName: string | null
    version: string | null
    platform: string | null
    md5: string | null
    createdAt: Date | null
    updatedAt: Date | null
  }

  export type AppMaxAggregateOutputType = {
    id: string | null
    name: string | null
    filename: string | null
    filepath: string | null
    mimetype: string | null
    size: number | null
    packageName: string | null
    version: string | null
    platform: string | null
    md5: string | null
    createdAt: Date | null
    updatedAt: Date | null
  }

  export type AppCountAggregateOutputType = {
    id: number
    name: number
    filename: number
    filepath: number
    mimetype: number
    size: number
    packageName: number
    version: number
    platform: number
    md5: number
    createdAt: number
    updatedAt: number
    _all: number
  }


  export type AppAvgAggregateInputType = {
    size?: true
  }

  export type AppSumAggregateInputType = {
    size?: true
  }

  export type AppMinAggregateInputType = {
    id?: true
    name?: true
    filename?: true
    filepath?: true
    mimetype?: true
    size?: true
    packageName?: true
    version?: true
    platform?: true
    md5?: true
    createdAt?: true
    updatedAt?: true
  }

  export type AppMaxAggregateInputType = {
    id?: true
    name?: true
    filename?: true
    filepath?: true
    mimetype?: true
    size?: true
    packageName?: true
    version?: true
    platform?: true
    md5?: true
    createdAt?: true
    updatedAt?: true
  }

  export type AppCountAggregateInputType = {
    id?: true
    name?: true
    filename?: true
    filepath?: true
    mimetype?: true
    size?: true
    packageName?: true
    version?: true
    platform?: true
    md5?: true
    createdAt?: true
    updatedAt?: true
    _all?: true
  }

  export type AppAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which App to aggregate.
     */
    where?: AppWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Apps to fetch.
     */
    orderBy?: AppOrderByWithRelationInput | AppOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: AppWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Apps 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` Apps.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned Apps
    **/
    _count?: true | AppCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: AppAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: AppSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: AppMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: AppMaxAggregateInputType
  }

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




  export type AppGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: AppWhereInput
    orderBy?: AppOrderByWithAggregationInput | AppOrderByWithAggregationInput[]
    by: AppScalarFieldEnum[] | AppScalarFieldEnum
    having?: AppScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: AppCountAggregateInputType | true
    _avg?: AppAvgAggregateInputType
    _sum?: AppSumAggregateInputType
    _min?: AppMinAggregateInputType
    _max?: AppMaxAggregateInputType
  }

  export type AppGroupByOutputType = {
    id: string
    name: string
    filename: string
    filepath: string
    mimetype: string
    size: number
    packageName: string | null
    version: string | null
    platform: string | null
    md5: string | null
    createdAt: Date
    updatedAt: Date
    _count: AppCountAggregateOutputType | null
    _avg: AppAvgAggregateOutputType | null
    _sum: AppSumAggregateOutputType | null
    _min: AppMinAggregateOutputType | null
    _max: AppMaxAggregateOutputType | null
  }

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


  export type AppSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
    filename?: boolean
    filepath?: boolean
    mimetype?: boolean
    size?: boolean
    packageName?: boolean
    version?: boolean
    platform?: boolean
    md5?: boolean
    createdAt?: boolean
    updatedAt?: boolean
  }, ExtArgs["result"]["app"]>

  export type AppSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
    filename?: boolean
    filepath?: boolean
    mimetype?: boolean
    size?: boolean
    packageName?: boolean
    version?: boolean
    platform?: boolean
    md5?: boolean
    createdAt?: boolean
    updatedAt?: boolean
  }, ExtArgs["result"]["app"]>

  export type AppSelectScalar = {
    id?: boolean
    name?: boolean
    filename?: boolean
    filepath?: boolean
    mimetype?: boolean
    size?: boolean
    packageName?: boolean
    version?: boolean
    platform?: boolean
    md5?: boolean
    createdAt?: boolean
    updatedAt?: boolean
  }


  export type $AppPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "App"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: string
      name: string
      filename: string
      filepath: string
      mimetype: string
      size: number
      packageName: string | null
      version: string | null
      platform: string | null
      md5: string | null
      createdAt: Date
      updatedAt: Date
    }, ExtArgs["result"]["app"]>
    composites: {}
  }

  type AppGetPayload<S extends boolean | null | undefined | AppDefaultArgs> = $Result.GetResult<Prisma.$AppPayload, S>

  type AppCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<AppFindManyArgs, 'select' | 'include' | 'distinct'> & {
      select?: AppCountAggregateInputType | true
    }

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

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

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

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

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

    /**
     * Create a App.
     * @param {AppCreateArgs} args - Arguments to create a App.
     * @example
     * // Create one App
     * const App = await prisma.app.create({
     *   data: {
     *     // ... data to create a App
     *   }
     * })
     * 
     */
    create<T extends AppCreateArgs>(args: SelectSubset<T, AppCreateArgs<ExtArgs>>): Prisma__AppClient<$Result.GetResult<Prisma.$AppPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

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

    /**
     * Delete a App.
     * @param {AppDeleteArgs} args - Arguments to delete one App.
     * @example
     * // Delete one App
     * const App = await prisma.app.delete({
     *   where: {
     *     // ... filter to delete one App
     *   }
     * })
     * 
     */
    delete<T extends AppDeleteArgs>(args: SelectSubset<T, AppDeleteArgs<ExtArgs>>): Prisma__AppClient<$Result.GetResult<Prisma.$AppPayload<ExtArgs>, T, "delete">, never, ExtArgs>

    /**
     * Update one App.
     * @param {AppUpdateArgs} args - Arguments to update one App.
     * @example
     * // Update one App
     * const app = await prisma.app.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends AppUpdateArgs>(args: SelectSubset<T, AppUpdateArgs<ExtArgs>>): Prisma__AppClient<$Result.GetResult<Prisma.$AppPayload<ExtArgs>, T, "update">, never, ExtArgs>

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

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

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for App.
   * 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__AppClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
    /**
     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
     * resolved value cannot be modified from the callback.
     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
     * @returns A Promise for the completion of the callback.
     */
    finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
  }




  /**
   * Fields of the App model
   */ 
  interface AppFieldRefs {
    readonly id: FieldRef<"App", 'String'>
    readonly name: FieldRef<"App", 'String'>
    readonly filename: FieldRef<"App", 'String'>
    readonly filepath: FieldRef<"App", 'String'>
    readonly mimetype: FieldRef<"App", 'String'>
    readonly size: FieldRef<"App", 'Int'>
    readonly packageName: FieldRef<"App", 'String'>
    readonly version: FieldRef<"App", 'String'>
    readonly platform: FieldRef<"App", 'String'>
    readonly md5: FieldRef<"App", 'String'>
    readonly createdAt: FieldRef<"App", 'DateTime'>
    readonly updatedAt: FieldRef<"App", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * App findUnique
   */
  export type AppFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the App
     */
    select?: AppSelect<ExtArgs> | null
    /**
     * Filter, which App to fetch.
     */
    where: AppWhereUniqueInput
  }

  /**
   * App findUniqueOrThrow
   */
  export type AppFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the App
     */
    select?: AppSelect<ExtArgs> | null
    /**
     * Filter, which App to fetch.
     */
    where: AppWhereUniqueInput
  }

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

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

  /**
   * App findMany
   */
  export type AppFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the App
     */
    select?: AppSelect<ExtArgs> | null
    /**
     * Filter, which Apps to fetch.
     */
    where?: AppWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Apps to fetch.
     */
    orderBy?: AppOrderByWithRelationInput | AppOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing Apps.
     */
    cursor?: AppWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Apps 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` Apps.
     */
    skip?: number
    distinct?: AppScalarFieldEnum | AppScalarFieldEnum[]
  }

  /**
   * App create
   */
  export type AppCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the App
     */
    select?: AppSelect<ExtArgs> | null
    /**
     * The data needed to create a App.
     */
    data: XOR<AppCreateInput, AppUncheckedCreateInput>
  }

  /**
   * App createMany
   */
  export type AppCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many Apps.
     */
    data: AppCreateManyInput | AppCreateManyInput[]
  }

  /**
   * App createManyAndReturn
   */
  export type AppCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the App
     */
    select?: AppSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many Apps.
     */
    data: AppCreateManyInput | AppCreateManyInput[]
  }

  /**
   * App update
   */
  export type AppUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the App
     */
    select?: AppSelect<ExtArgs> | null
    /**
     * The data needed to update a App.
     */
    data: XOR<AppUpdateInput, AppUncheckedUpdateInput>
    /**
     * Choose, which App to update.
     */
    where: AppWhereUniqueInput
  }

  /**
   * App updateMany
   */
  export type AppUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Apps.
     */
    data: XOR<AppUpdateManyMutationInput, AppUncheckedUpdateManyInput>
    /**
     * Filter which Apps to update
     */
    where?: AppWhereInput
  }

  /**
   * App upsert
   */
  export type AppUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the App
     */
    select?: AppSelect<ExtArgs> | null
    /**
     * The filter to search for the App to update in case it exists.
     */
    where: AppWhereUniqueInput
    /**
     * In case the App found by the `where` argument doesn't exist, create a new App with this data.
     */
    create: XOR<AppCreateInput, AppUncheckedCreateInput>
    /**
     * In case the App was found with the provided `where` argument, update it with this data.
     */
    update: XOR<AppUpdateInput, AppUncheckedUpdateInput>
  }

  /**
   * App delete
   */
  export type AppDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the App
     */
    select?: AppSelect<ExtArgs> | null
    /**
     * Filter which App to delete.
     */
    where: AppWhereUniqueInput
  }

  /**
   * App deleteMany
   */
  export type AppDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Apps to delete
     */
    where?: AppWhereInput
  }

  /**
   * App without action
   */
  export type AppDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the App
     */
    select?: AppSelect<ExtArgs> | null
  }


  /**
   * Model Device
   */

  export type AggregateDevice = {
    _count: DeviceCountAggregateOutputType | null
    _avg: DeviceAvgAggregateOutputType | null
    _sum: DeviceSumAggregateOutputType | null
    _min: DeviceMinAggregateOutputType | null
    _max: DeviceMaxAggregateOutputType | null
  }

  export type DeviceAvgAggregateOutputType = {
    systemPort: number | null
    proxyPort: number | null
    wdaLocalPort: number | null
    mjpegServerPort: number | null
    lastCmdExecutedAt: number | null
    totalUtilizationTimeMilliSec: number | null
    sessionStartTime: number | null
    newCommandTimeout: number | null
    adbPort: number | null
    total_session_count: number | null
    lastHealthCheckAt: number | null
    batteryLevel: number | null
    reservedUntil: number | null
    totalHealedCount: number | null
    lockedAt: number | null
  }

  export type DeviceSumAggregateOutputType = {
    systemPort: number | null
    proxyPort: number | null
    wdaLocalPort: number | null
    mjpegServerPort: number | null
    lastCmdExecutedAt: number | null
    totalUtilizationTimeMilliSec: number | null
    sessionStartTime: number | null
    newCommandTimeout: number | null
    adbPort: number | null
    total_session_count: number | null
    lastHealthCheckAt: number | null
    batteryLevel: number | null
    reservedUntil: number | null
    totalHealedCount: number | null
    lockedAt: number | null
  }

  export type DeviceMinAggregateOutputType = {
    udid: string | null
    host: string | null
    systemPort: number | null
    proxyPort: number | null
    proxyHost: string | null
    wdaLocalPort: number | null
    name: string | null
    state: string | null
    sdk: string | null
    platform: string | null
    deviceType: string | null
    busy: boolean | null
    userBlocked: boolean | null
    realDevice: boolean | null
    session_id: string | null
    offline: boolean | null
    mjpegServerPort: number | null
    lastCmdExecutedAt: number | null
    totalUtilizationTimeMilliSec: number | null
    sessionStartTime: number | null
    newCommandTimeout: number | null
    cloud: string | null
    derivedDataPath: string | null
    chromeDriverPath: string | null
    capability: string | null
    adbRemoteHost: string | null
    adbPort: number | null
    nodeId: string | null
    screenWidth: string | null
    screenHeight: string | null
    dashboard_link: string | null
    total_session_count: number | null
    createdAt: Date | null
    updatedAt: Date | null
    healthCheckError: string | null
    healthStatus: string | null
    lastHealthCheckAt: number | null
    batteryLevel: number | null
    reservationReason: string | null
    reservedBy: string | null
    reservedUntil: number | null
    storageFree: string | null
    tags: string | null
    thermalStatus: string | null
    sessionProgress: string | null
    totalHealedCount: number | null
    ip: string | null
    cpuArchitecture: string | null
    owningSessionId: string | null
    lockedAt: number | null
    teamId: string | null
  }

  export type DeviceMaxAggregateOutputType = {
    udid: string | null
    host: string | null
    systemPort: number | null
    proxyPort: number | null
    proxyHost: string | null
    wdaLocalPort: number | null
    name: string | null
    state: string | null
    sdk: string | null
    platform: string | null
    deviceType: string | null
    busy: boolean | null
    userBlocked: boolean | null
    realDevice: boolean | null
    session_id: string | null
    offline: boolean | null
    mjpegServerPort: number | null
    lastCmdExecutedAt: number | null
    totalUtilizationTimeMilliSec: number | null
    sessionStartTime: number | null
    newCommandTimeout: number | null
    cloud: string | null
    derivedDataPath: string | null
    chromeDriverPath: string | null
    capability: string | null
    adbRemoteHost: string | null
    adbPort: number | null
    nodeId: string | null
    screenWidth: string | null
    screenHeight: string | null
    dashboard_link: string | null
    total_session_count: number | null
    createdAt: Date | null
    updatedAt: Date | null
    healthCheckError: string | null
    healthStatus: string | null
    lastHealthCheckAt: number | null
    batteryLevel: number | null
    reservationReason: string | null
    reservedBy: string | null
    reservedUntil: number | null
    storageFree: string | null
    tags: string | null
    thermalStatus: string | null
    sessionProgress: string | null
    totalHealedCount: number | null
    ip: string | null
    cpuArchitecture: string | null
    owningSessionId: string | null
    lockedAt: number | null
    teamId: string | null
  }

  export type DeviceCountAggregateOutputType = {
    udid: number
    host: number
    systemPort: number
    proxyPort: number
    proxyHost: number
    wdaLocalPort: number
    name: number
    state: number
    sdk: number
    platform: number
    deviceType: number
    busy: number
    userBlocked: number
    realDevice: number
    session_id: number
    offline: number
    mjpegServerPort: number
    lastCmdExecutedAt: number
    totalUtilizationTimeMilliSec: number
    sessionStartTime: number
    newCommandTimeout: number
    cloud: number
    derivedDataPath: number
    chromeDriverPath: number
    capability: number
    adbRemoteHost: number
    adbPort: number
    nodeId: number
    screenWidth: number
    screenHeight: number
    dashboard_link: number
    total_session_count: number
    createdAt: number
    updatedAt: number
    healthCheckError: number
    healthStatus: number
    lastHealthCheckAt: number
    batteryLevel: number
    reservationReason: number
    reservedBy: number
    reservedUntil: number
    storageFree: number
    tags: number
    thermalStatus: number
    sessionProgress: number
    totalHealedCount: number
    ip: number
    cpuArchitecture: number
    owningSessionId: number
    lockedAt: number
    teamId: number
    _all: number
  }


  export type DeviceAvgAggregateInputType = {
    systemPort?: true
    proxyPort?: true
    wdaLocalPort?: true
    mjpegServerPort?: true
    lastCmdExecutedAt?: true
    totalUtilizationTimeMilliSec?: true
    sessionStartTime?: true
    newCommandTimeout?: true
    adbPort?: true
    total_session_count?: true
    lastHealthCheckAt?: true
    batteryLevel?: true
    reservedUntil?: true
    totalHealedCount?: true
    lockedAt?: true
  }

  export type DeviceSumAggregateInputType = {
    systemPort?: true
    proxyPort?: true
    wdaLocalPort?: true
    mjpegServerPort?: true
    lastCmdExecutedAt?: true
    totalUtilizationTimeMilliSec?: true
    sessionStartTime?: true
    newCommandTimeout?: true
    adbPort?: true
    total_session_count?: true
    lastHealthCheckAt?: true
    batteryLevel?: true
    reservedUntil?: true
    totalHealedCount?: true
    lockedAt?: true
  }

  export type DeviceMinAggregateInputType = {
    udid?: true
    host?: true
    systemPort?: true
    proxyPort?: true
    proxyHost?: true
    wdaLocalPort?: true
    name?: true
    state?: true
    sdk?: true
    platform?: true
    deviceType?: true
    busy?: true
    userBlocked?: true
    realDevice?: true
    session_id?: true
    offline?: true
    mjpegServerPort?: true
    lastCmdExecutedAt?: true
    totalUtilizationTimeMilliSec?: true
    sessionStartTime?: true
    newCommandTimeout?: true
    cloud?: true
    derivedDataPath?: true
    chromeDriverPath?: true
    capability?: true
    adbRemoteHost?: true
    adbPort?: true
    nodeId?: true
    screenWidth?: true
    screenHeight?: true
    dashboard_link?: true
    total_session_count?: true
    createdAt?: true
    updatedAt?: true
    healthCheckError?: true
    healthStatus?: true
    lastHealthCheckAt?: true
    batteryLevel?: true
    reservationReason?: true
    reservedBy?: true
    reservedUntil?: true
    storageFree?: true
    tags?: true
    thermalStatus?: true
    sessionProgress?: true
    totalHealedCount?: true
    ip?: true
    cpuArchitecture?: true
    owningSessionId?: true
    lockedAt?: true
    teamId?: true
  }

  export type DeviceMaxAggregateInputType = {
    udid?: true
    host?: true
    systemPort?: true
    proxyPort?: true
    proxyHost?: true
    wdaLocalPort?: true
    name?: true
    state?: true
    sdk?: true
    platform?: true
    deviceType?: true
    busy?: true
    userBlocked?: true
    realDevice?: true
    session_id?: true
    offline?: true
    mjpegServerPort?: true
    lastCmdExecutedAt?: true
    totalUtilizationTimeMilliSec?: true
    sessionStartTime?: true
    newCommandTimeout?: true
    cloud?: true
    derivedDataPath?: true
    chromeDriverPath?: true
    capability?: true
    adbRemoteHost?: true
    adbPort?: true
    nodeId?: true
    screenWidth?: true
    screenHeight?: true
    dashboard_link?: true
    total_session_count?: true
    createdAt?: true
    updatedAt?: true
    healthCheckError?: true
    healthStatus?: true
    lastHealthCheckAt?: true
    batteryLevel?: true
    reservationReason?: true
    reservedBy?: true
    reservedUntil?: true
    storageFree?: true
    tags?: true
    thermalStatus?: true
    sessionProgress?: true
    totalHealedCount?: true
    ip?: true
    cpuArchitecture?: true
    owningSessionId?: true
    lockedAt?: true
    teamId?: true
  }

  export type DeviceCountAggregateInputType = {
    udid?: true
    host?: true
    systemPort?: true
    proxyPort?: true
    proxyHost?: true
    wdaLocalPort?: true
    name?: true
    state?: true
    sdk?: true
    platform?: true
    deviceType?: true
    busy?: true
    userBlocked?: true
    realDevice?: true
    session_id?: true
    offline?: true
    mjpegServerPort?: true
    lastCmdExecutedAt?: true
    totalUtilizationTimeMilliSec?: true
    sessionStartTime?: true
    newCommandTimeout?: true
    cloud?: true
    derivedDataPath?: true
    chromeDriverPath?: true
    capability?: true
    adbRemoteHost?: true
    adbPort?: true
    nodeId?: true
    screenWidth?: true
    screenHeight?: true
    dashboard_link?: true
    total_session_count?: true
    createdAt?: true
    updatedAt?: true
    healthCheckError?: true
    healthStatus?: true
    lastHealthCheckAt?: true
    batteryLevel?: true
    reservationReason?: true
    reservedBy?: true
    reservedUntil?: true
    storageFree?: true
    tags?: true
    thermalStatus?: true
    sessionProgress?: true
    totalHealedCount?: true
    ip?: true
    cpuArchitecture?: true
    owningSessionId?: true
    lockedAt?: true
    teamId?: true
    _all?: true
  }

  export type DeviceAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Device to aggregate.
     */
    where?: DeviceWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Devices to fetch.
     */
    orderBy?: DeviceOrderByWithRelationInput | DeviceOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: DeviceWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Devices 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` Devices.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned Devices
    **/
    _count?: true | DeviceCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: DeviceAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: DeviceSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: DeviceMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: DeviceMaxAggregateInputType
  }

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




  export type DeviceGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: DeviceWhereInput
    orderBy?: DeviceOrderByWithAggregationInput | DeviceOrderByWithAggregationInput[]
    by: DeviceScalarFieldEnum[] | DeviceScalarFieldEnum
    having?: DeviceScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: DeviceCountAggregateInputType | true
    _avg?: DeviceAvgAggregateInputType
    _sum?: DeviceSumAggregateInputType
    _min?: DeviceMinAggregateInputType
    _max?: DeviceMaxAggregateInputType
  }

  export type DeviceGroupByOutputType = {
    udid: string
    host: string
    systemPort: number | null
    proxyPort: number | null
    proxyHost: string | null
    wdaLocalPort: number | null
    name: string | null
    state: string | null
    sdk: string | null
    platform: string | null
    deviceType: string | null
    busy: boolean | null
    userBlocked: boolean | null
    realDevice: boolean | null
    session_id: string | null
    offline: boolean | null
    mjpegServerPort: number | null
    lastCmdExecutedAt: number | null
    totalUtilizationTimeMilliSec: number
    sessionStartTime: number
    newCommandTimeout: number | null
    cloud: string | null
    derivedDataPath: string | null
    chromeDriverPath: string | null
    capability: string | null
    adbRemoteHost: string | null
    adbPort: number | null
    nodeId: string | null
    screenWidth: string | null
    screenHeight: string | null
    dashboard_link: string | null
    total_session_count: number | null
    createdAt: Date
    updatedAt: Date
    healthCheckError: string | null
    healthStatus: string | null
    lastHealthCheckAt: number | null
    batteryLevel: number | null
    reservationReason: string | null
    reservedBy: string | null
    reservedUntil: number | null
    storageFree: string | null
    tags: string | null
    thermalStatus: string | null
    sessionProgress: string | null
    totalHealedCount: number | null
    ip: string | null
    cpuArchitecture: string | null
    owningSessionId: string | null
    lockedAt: number | null
    teamId: string | null
    _count: DeviceCountAggregateOutputType | null
    _avg: DeviceAvgAggregateOutputType | null
    _sum: DeviceSumAggregateOutputType | null
    _min: DeviceMinAggregateOutputType | null
    _max: DeviceMaxAggregateOutputType | null
  }

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


  export type DeviceSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    udid?: boolean
    host?: boolean
    systemPort?: boolean
    proxyPort?: boolean
    proxyHost?: boolean
    wdaLocalPort?: boolean
    name?: boolean
    state?: boolean
    sdk?: boolean
    platform?: boolean
    deviceType?: boolean
    busy?: boolean
    userBlocked?: boolean
    realDevice?: boolean
    session_id?: boolean
    offline?: boolean
    mjpegServerPort?: boolean
    lastCmdExecutedAt?: boolean
    totalUtilizationTimeMilliSec?: boolean
    sessionStartTime?: boolean
    newCommandTimeout?: boolean
    cloud?: boolean
    derivedDataPath?: boolean
    chromeDriverPath?: boolean
    capability?: boolean
    adbRemoteHost?: boolean
    adbPort?: boolean
    nodeId?: boolean
    screenWidth?: boolean
    screenHeight?: boolean
    dashboard_link?: boolean
    total_session_count?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    healthCheckError?: boolean
    healthStatus?: boolean
    lastHealthCheckAt?: boolean
    batteryLevel?: boolean
    reservationReason?: boolean
    reservedBy?: boolean
    reservedUntil?: boolean
    storageFree?: boolean
    tags?: boolean
    thermalStatus?: boolean
    sessionProgress?: boolean
    totalHealedCount?: boolean
    ip?: boolean
    cpuArchitecture?: boolean
    owningSessionId?: boolean
    lockedAt?: boolean
    teamId?: boolean
    team?: boolean | Device$teamArgs<ExtArgs>
  }, ExtArgs["result"]["device"]>

  export type DeviceSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    udid?: boolean
    host?: boolean
    systemPort?: boolean
    proxyPort?: boolean
    proxyHost?: boolean
    wdaLocalPort?: boolean
    name?: boolean
    state?: boolean
    sdk?: boolean
    platform?: boolean
    deviceType?: boolean
    busy?: boolean
    userBlocked?: boolean
    realDevice?: boolean
    session_id?: boolean
    offline?: boolean
    mjpegServerPort?: boolean
    lastCmdExecutedAt?: boolean
    totalUtilizationTimeMilliSec?: boolean
    sessionStartTime?: boolean
    newCommandTimeout?: boolean
    cloud?: boolean
    derivedDataPath?: boolean
    chromeDriverPath?: boolean
    capability?: boolean
    adbRemoteHost?: boolean
    adbPort?: boolean
    nodeId?: boolean
    screenWidth?: boolean
    screenHeight?: boolean
    dashboard_link?: boolean
    total_session_count?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    healthCheckError?: boolean
    healthStatus?: boolean
    lastHealthCheckAt?: boolean
    batteryLevel?: boolean
    reservationReason?: boolean
    reservedBy?: boolean
    reservedUntil?: boolean
    storageFree?: boolean
    tags?: boolean
    thermalStatus?: boolean
    sessionProgress?: boolean
    totalHealedCount?: boolean
    ip?: boolean
    cpuArchitecture?: boolean
    owningSessionId?: boolean
    lockedAt?: boolean
    teamId?: boolean
    team?: boolean | Device$teamArgs<ExtArgs>
  }, ExtArgs["result"]["device"]>

  export type DeviceSelectScalar = {
    udid?: boolean
    host?: boolean
    systemPort?: boolean
    proxyPort?: boolean
    proxyHost?: boolean
    wdaLocalPort?: boolean
    name?: boolean
    state?: boolean
    sdk?: boolean
    platform?: boolean
    deviceType?: boolean
    busy?: boolean
    userBlocked?: boolean
    realDevice?: boolean
    session_id?: boolean
    offline?: boolean
    mjpegServerPort?: boolean
    lastCmdExecutedAt?: boolean
    totalUtilizationTimeMilliSec?: boolean
    sessionStartTime?: boolean
    newCommandTimeout?: boolean
    cloud?: boolean
    derivedDataPath?: boolean
    chromeDriverPath?: boolean
    capability?: boolean
    adbRemoteHost?: boolean
    adbPort?: boolean
    nodeId?: boolean
    screenWidth?: boolean
    screenHeight?: boolean
    dashboard_link?: boolean
    total_session_count?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    healthCheckError?: boolean
    healthStatus?: boolean
    lastHealthCheckAt?: boolean
    batteryLevel?: boolean
    reservationReason?: boolean
    reservedBy?: boolean
    reservedUntil?: boolean
    storageFree?: boolean
    tags?: boolean
    thermalStatus?: boolean
    sessionProgress?: boolean
    totalHealedCount?: boolean
    ip?: boolean
    cpuArchitecture?: boolean
    owningSessionId?: boolean
    lockedAt?: boolean
    teamId?: boolean
  }

  export type DeviceInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    team?: boolean | Device$teamArgs<ExtArgs>
  }
  export type DeviceIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    team?: boolean | Device$teamArgs<ExtArgs>
  }

  export type $DevicePayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Device"
    objects: {
      team: Prisma.$TeamPayload<ExtArgs> | null
    }
    scalars: $Extensions.GetPayloadResult<{
      udid: string
      host: string
      systemPort: number | null
      proxyPort: number | null
      proxyHost: string | null
      wdaLocalPort: number | null
      name: string | null
      state: string | null
      sdk: string | null
      platform: string | null
      deviceType: string | null
      busy: boolean | null
      userBlocked: boolean | null
      realDevice: boolean | null
      session_id: string | null
      offline: boolean | null
      mjpegServerPort: number | null
      lastCmdExecutedAt: number | null
      totalUtilizationTimeMilliSec: number
      sessionStartTime: number
      newCommandTimeout: number | null
      cloud: string | null
      derivedDataPath: string | null
      chromeDriverPath: string | null
      capability: string | null
      adbRemoteHost: string | null
      adbPort: number | null
      nodeId: string | null
      screenWidth: string | null
      screenHeight: string | null
      dashboard_link: string | null
      total_session_count: number | null
      createdAt: Date
      updatedAt: Date
      healthCheckError: string | null
      healthStatus: string | null
      lastHealthCheckAt: number | null
      batteryLevel: number | null
      reservationReason: string | null
      reservedBy: string | null
      reservedUntil: number | null
      storageFree: string | null
      tags: string | null
      thermalStatus: string | null
      sessionProgress: string | null
      totalHealedCount: number | null
      ip: string | null
      cpuArchitecture: string | null
      owningSessionId: string | null
      lockedAt: number | null
      teamId: string | null
    }, ExtArgs["result"]["device"]>
    composites: {}
  }

  type DeviceGetPayload<S extends boolean | null | undefined | DeviceDefaultArgs> = $Result.GetResult<Prisma.$DevicePayload, S>

  type DeviceCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<DeviceFindManyArgs, 'select' | 'include' | 'distinct'> & {
      select?: DeviceCountAggregateInputType | true
    }

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

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

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

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

    /**
     * Find zero or more Devices 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 {DeviceFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all Devices
     * const devices = await prisma.device.findMany()
     * 
     * // Get first 10 Devices
     * const devices = await prisma.device.findMany({ take: 10 })
     * 
     * // Only select the `udid`
     * const deviceWithUdidOnly = await prisma.device.findMany({ select: { udid: true } })
     * 
     */
    findMany<T extends DeviceFindManyArgs>(args?: SelectSubset<T, DeviceFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$DevicePayload<ExtArgs>, T, "findMany">>

    /**
     * Create a Device.
     * @param {DeviceCreateArgs} args - Arguments to create a Device.
     * @example
     * // Create one Device
     * const Device = await prisma.device.create({
     *   data: {
     *     // ... data to create a Device
     *   }
     * })
     * 
     */
    create<T extends DeviceCreateArgs>(args: SelectSubset<T, DeviceCreateArgs<ExtArgs>>): Prisma__DeviceClient<$Result.GetResult<Prisma.$DevicePayload<ExtArgs>, T, "create">, never, ExtArgs>

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

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

    /**
     * Delete a Device.
     * @param {DeviceDeleteArgs} args - Arguments to delete one Device.
     * @example
     * // Delete one Device
     * const Device = await prisma.device.delete({
     *   where: {
     *     // ... filter to delete one Device
     *   }
     * })
     * 
     */
    delete<T extends DeviceDeleteArgs>(args: SelectSubset<T, DeviceDeleteArgs<ExtArgs>>): Prisma__DeviceClient<$Result.GetResult<Prisma.$DevicePayload<ExtArgs>, T, "delete">, never, ExtArgs>

    /**
     * Update one Device.
     * @param {DeviceUpdateArgs} args - Arguments to update one Device.
     * @example
     * // Update one Device
     * const device = await prisma.device.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends DeviceUpdateArgs>(args: SelectSubset<T, DeviceUpdateArgs<ExtArgs>>): Prisma__DeviceClient<$Result.GetResult<Prisma.$DevicePayload<ExtArgs>, T, "update">, never, ExtArgs>

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

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

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for Device.
   * 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__DeviceClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    team<T extends Device$teamArgs<ExtArgs> = {}>(args?: Subset<T, Device$teamArgs<ExtArgs>>): Prisma__TeamClient<$Result.GetResult<Prisma.$TeamPayload<ExtArgs>, T, "findUniqueOrThrow"> | null, null, ExtArgs>
    /**
     * 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 Device model
   */ 
  interface DeviceFieldRefs {
    readonly udid: FieldRef<"Device", 'String'>
    readonly host: FieldRef<"Device", 'String'>
    readonly systemPort: FieldRef<"Device", 'Int'>
    readonly proxyPort: FieldRef<"Device", 'Int'>
    readonly proxyHost: FieldRef<"Device", 'String'>
    readonly wdaLocalPort: FieldRef<"Device", 'Int'>
    readonly name: FieldRef<"Device", 'String'>
    readonly state: FieldRef<"Device", 'String'>
    readonly sdk: FieldRef<"Device", 'String'>
    readonly platform: FieldRef<"Device", 'String'>
    readonly deviceType: FieldRef<"Device", 'String'>
    readonly busy: FieldRef<"Device", 'Boolean'>
    readonly userBlocked: FieldRef<"Device", 'Boolean'>
    readonly realDevice: FieldRef<"Device", 'Boolean'>
    readonly session_id: FieldRef<"Device", 'String'>
    readonly offline: FieldRef<"Device", 'Boolean'>
    readonly mjpegServerPort: FieldRef<"Device", 'Int'>
    readonly lastCmdExecutedAt: FieldRef<"Device", 'Float'>
    readonly totalUtilizationTimeMilliSec: FieldRef<"Device", 'Float'>
    readonly sessionStartTime: FieldRef<"Device", 'Float'>
    readonly newCommandTimeout: FieldRef<"Device", 'Int'>
    readonly cloud: FieldRef<"Device", 'String'>
    readonly derivedDataPath: FieldRef<"Device", 'String'>
    readonly chromeDriverPath: FieldRef<"Device", 'String'>
    readonly capability: FieldRef<"Device", 'String'>
    readonly adbRemoteHost: FieldRef<"Device", 'String'>
    readonly adbPort: FieldRef<"Device", 'Int'>
    readonly nodeId: FieldRef<"Device", 'String'>
    readonly screenWidth: FieldRef<"Device", 'String'>
    readonly screenHeight: FieldRef<"Device", 'String'>
    readonly dashboard_link: FieldRef<"Device", 'String'>
    readonly total_session_count: FieldRef<"Device", 'Int'>
    readonly createdAt: FieldRef<"Device", 'DateTime'>
    readonly updatedAt: FieldRef<"Device", 'DateTime'>
    readonly healthCheckError: FieldRef<"Device", 'String'>
    readonly healthStatus: FieldRef<"Device", 'String'>
    readonly lastHealthCheckAt: FieldRef<"Device", 'Float'>
    readonly batteryLevel: FieldRef<"Device", 'Int'>
    readonly reservationReason: FieldRef<"Device", 'String'>
    readonly reservedBy: FieldRef<"Device", 'String'>
    readonly reservedUntil: FieldRef<"Device", 'Float'>
    readonly storageFree: FieldRef<"Device", 'String'>
    readonly tags: FieldRef<"Device", 'String'>
    readonly thermalStatus: FieldRef<"Device", 'String'>
    readonly sessionProgress: FieldRef<"Device", 'String'>
    readonly totalHealedCount: FieldRef<"Device", 'Int'>
    readonly ip: FieldRef<"Device", 'String'>
    readonly cpuArchitecture: FieldRef<"Device", 'String'>
    readonly owningSessionId: FieldRef<"Device", 'String'>
    readonly lockedAt: FieldRef<"Device", 'Float'>
    readonly teamId: FieldRef<"Device", 'String'>
  }
    

  // Custom InputTypes
  /**
   * Device findUnique
   */
  export type DeviceFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Device
     */
    select?: DeviceSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: DeviceInclude<ExtArgs> | null
    /**
     * Filter, which Device to fetch.
     */
    where: DeviceWhereUniqueInput
  }

  /**
   * Device findUniqueOrThrow
   */
  export type DeviceFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Device
     */
    select?: DeviceSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: DeviceInclude<ExtArgs> | null
    /**
     * Filter, which Device to fetch.
     */
    where: DeviceWhereUniqueInput
  }

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

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

  /**
   * Device findMany
   */
  export type DeviceFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Device
     */
    select?: DeviceSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: DeviceInclude<ExtArgs> | null
    /**
     * Filter, which Devices to fetch.
     */
    where?: DeviceWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Devices to fetch.
     */
    orderBy?: DeviceOrderByWithRelationInput | DeviceOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing Devices.
     */
    cursor?: DeviceWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Devices 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` Devices.
     */
    skip?: number
    distinct?: DeviceScalarFieldEnum | DeviceScalarFieldEnum[]
  }

  /**
   * Device create
   */
  export type DeviceCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Device
     */
    select?: DeviceSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: DeviceInclude<ExtArgs> | null
    /**
     * The data needed to create a Device.
     */
    data: XOR<DeviceCreateInput, DeviceUncheckedCreateInput>
  }

  /**
   * Device createMany
   */
  export type DeviceCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many Devices.
     */
    data: DeviceCreateManyInput | DeviceCreateManyInput[]
  }

  /**
   * Device createManyAndReturn
   */
  export type DeviceCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Device
     */
    select?: DeviceSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many Devices.
     */
    data: DeviceCreateManyInput | DeviceCreateManyInput[]
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: DeviceIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * Device update
   */
  export type DeviceUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Device
     */
    select?: DeviceSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: DeviceInclude<ExtArgs> | null
    /**
     * The data needed to update a Device.
     */
    data: XOR<DeviceUpdateInput, DeviceUncheckedUpdateInput>
    /**
     * Choose, which Device to update.
     */
    where: DeviceWhereUniqueInput
  }

  /**
   * Device updateMany
   */
  export type DeviceUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Devices.
     */
    data: XOR<DeviceUpdateManyMutationInput, DeviceUncheckedUpdateManyInput>
    /**
     * Filter which Devices to update
     */
    where?: DeviceWhereInput
  }

  /**
   * Device upsert
   */
  export type DeviceUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Device
     */
    select?: DeviceSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: DeviceInclude<ExtArgs> | null
    /**
     * The filter to search for the Device to update in case it exists.
     */
    where: DeviceWhereUniqueInput
    /**
     * In case the Device found by the `where` argument doesn't exist, create a new Device with this data.
     */
    create: XOR<DeviceCreateInput, DeviceUncheckedCreateInput>
    /**
     * In case the Device was found with the provided `where` argument, update it with this data.
     */
    update: XOR<DeviceUpdateInput, DeviceUncheckedUpdateInput>
  }

  /**
   * Device delete
   */
  export type DeviceDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Device
     */
    select?: DeviceSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: DeviceInclude<ExtArgs> | null
    /**
     * Filter which Device to delete.
     */
    where: DeviceWhereUniqueInput
  }

  /**
   * Device deleteMany
   */
  export type DeviceDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Devices to delete
     */
    where?: DeviceWhereInput
  }

  /**
   * Device.team
   */
  export type Device$teamArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Team
     */
    select?: TeamSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TeamInclude<ExtArgs> | null
    where?: TeamWhereInput
  }

  /**
   * Device without action
   */
  export type DeviceDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Device
     */
    select?: DeviceSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: DeviceInclude<ExtArgs> | null
  }


  /**
   * Model PendingSession
   */

  export type AggregatePendingSession = {
    _count: PendingSessionCountAggregateOutputType | null
    _avg: PendingSessionAvgAggregateOutputType | null
    _sum: PendingSessionSumAggregateOutputType | null
    _min: PendingSessionMinAggregateOutputType | null
    _max: PendingSessionMaxAggregateOutputType | null
  }

  export type PendingSessionAvgAggregateOutputType = {
    id: number | null
    createdAt: number | null
  }

  export type PendingSessionSumAggregateOutputType = {
    id: number | null
    createdAt: number | null
  }

  export type PendingSessionMinAggregateOutputType = {
    id: number | null
    capability_id: string | null
    capability: string | null
    createdAt: number | null
  }

  export type PendingSessionMaxAggregateOutputType = {
    id: number | null
    capability_id: string | null
    capability: string | null
    createdAt: number | null
  }

  export type PendingSessionCountAggregateOutputType = {
    id: number
    capability_id: number
    capability: number
    createdAt: number
    _all: number
  }


  export type PendingSessionAvgAggregateInputType = {
    id?: true
    createdAt?: true
  }

  export type PendingSessionSumAggregateInputType = {
    id?: true
    createdAt?: true
  }

  export type PendingSessionMinAggregateInputType = {
    id?: true
    capability_id?: true
    capability?: true
    createdAt?: true
  }

  export type PendingSessionMaxAggregateInputType = {
    id?: true
    capability_id?: true
    capability?: true
    createdAt?: true
  }

  export type PendingSessionCountAggregateInputType = {
    id?: true
    capability_id?: true
    capability?: true
    createdAt?: true
    _all?: true
  }

  export type PendingSessionAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which PendingSession to aggregate.
     */
    where?: PendingSessionWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of PendingSessions to fetch.
     */
    orderBy?: PendingSessionOrderByWithRelationInput | PendingSessionOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: PendingSessionWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` PendingSessions 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` PendingSessions.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned PendingSessions
    **/
    _count?: true | PendingSessionCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: PendingSessionAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: PendingSessionSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: PendingSessionMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: PendingSessionMaxAggregateInputType
  }

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




  export type PendingSessionGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: PendingSessionWhereInput
    orderBy?: PendingSessionOrderByWithAggregationInput | PendingSessionOrderByWithAggregationInput[]
    by: PendingSessionScalarFieldEnum[] | PendingSessionScalarFieldEnum
    having?: PendingSessionScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: PendingSessionCountAggregateInputType | true
    _avg?: PendingSessionAvgAggregateInputType
    _sum?: PendingSessionSumAggregateInputType
    _min?: PendingSessionMinAggregateInputType
    _max?: PendingSessionMaxAggregateInputType
  }

  export type PendingSessionGroupByOutputType = {
    id: number
    capability_id: string
    capability: string
    createdAt: number
    _count: PendingSessionCountAggregateOutputType | null
    _avg: PendingSessionAvgAggregateOutputType | null
    _sum: PendingSessionSumAggregateOutputType | null
    _min: PendingSessionMinAggregateOutputType | null
    _max: PendingSessionMaxAggregateOutputType | null
  }

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


  export type PendingSessionSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    capability_id?: boolean
    capability?: boolean
    createdAt?: boolean
  }, ExtArgs["result"]["pendingSession"]>

  export type PendingSessionSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    capability_id?: boolean
    capability?: boolean
    createdAt?: boolean
  }, ExtArgs["result"]["pendingSession"]>

  export type PendingSessionSelectScalar = {
    id?: boolean
    capability_id?: boolean
    capability?: boolean
    createdAt?: boolean
  }


  export type $PendingSessionPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "PendingSession"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: number
      capability_id: string
      capability: string
      createdAt: number
    }, ExtArgs["result"]["pendingSession"]>
    composites: {}
  }

  type PendingSessionGetPayload<S extends boolean | null | undefined | PendingSessionDefaultArgs> = $Result.GetResult<Prisma.$PendingSessionPayload, S>

  type PendingSessionCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<PendingSessionFindManyArgs, 'select' | 'include' | 'distinct'> & {
      select?: PendingSessionCountAggregateInputType | true
    }

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

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

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

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

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

    /**
     * Create a PendingSession.
     * @param {PendingSessionCreateArgs} args - Arguments to create a PendingSession.
     * @example
     * // Create one PendingSession
     * const PendingSession = await prisma.pendingSession.create({
     *   data: {
     *     // ... data to create a PendingSession
     *   }
     * })
     * 
     */
    create<T extends PendingSessionCreateArgs>(args: SelectSubset<T, PendingSessionCreateArgs<ExtArgs>>): Prisma__PendingSessionClient<$Result.GetResult<Prisma.$PendingSessionPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

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

    /**
     * Delete a PendingSession.
     * @param {PendingSessionDeleteArgs} args - Arguments to delete one PendingSession.
     * @example
     * // Delete one PendingSession
     * const PendingSession = await prisma.pendingSession.delete({
     *   where: {
     *     // ... filter to delete one PendingSession
     *   }
     * })
     * 
     */
    delete<T extends PendingSessionDeleteArgs>(args: SelectSubset<T, PendingSessionDeleteArgs<ExtArgs>>): Prisma__PendingSessionClient<$Result.GetResult<Prisma.$PendingSessionPayload<ExtArgs>, T, "delete">, never, ExtArgs>

    /**
     * Update one PendingSession.
     * @param {PendingSessionUpdateArgs} args - Arguments to update one PendingSession.
     * @example
     * // Update one PendingSession
     * const pendingSession = await prisma.pendingSession.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends PendingSessionUpdateArgs>(args: SelectSubset<T, PendingSessionUpdateArgs<ExtArgs>>): Prisma__PendingSessionClient<$Result.GetResult<Prisma.$PendingSessionPayload<ExtArgs>, T, "update">, never, ExtArgs>

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

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

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for PendingSession.
   * 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__PendingSessionClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
    /**
     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
     * resolved value cannot be modified from the callback.
     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
     * @returns A Promise for the completion of the callback.
     */
    finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
  }




  /**
   * Fields of the PendingSession model
   */ 
  interface PendingSessionFieldRefs {
    readonly id: FieldRef<"PendingSession", 'Int'>
    readonly capability_id: FieldRef<"PendingSession", 'String'>
    readonly capability: FieldRef<"PendingSession", 'String'>
    readonly createdAt: FieldRef<"PendingSession", 'Float'>
  }
    

  // Custom InputTypes
  /**
   * PendingSession findUnique
   */
  export type PendingSessionFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PendingSession
     */
    select?: PendingSessionSelect<ExtArgs> | null
    /**
     * Filter, which PendingSession to fetch.
     */
    where: PendingSessionWhereUniqueInput
  }

  /**
   * PendingSession findUniqueOrThrow
   */
  export type PendingSessionFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PendingSession
     */
    select?: PendingSessionSelect<ExtArgs> | null
    /**
     * Filter, which PendingSession to fetch.
     */
    where: PendingSessionWhereUniqueInput
  }

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

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

  /**
   * PendingSession findMany
   */
  export type PendingSessionFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PendingSession
     */
    select?: PendingSessionSelect<ExtArgs> | null
    /**
     * Filter, which PendingSessions to fetch.
     */
    where?: PendingSessionWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of PendingSessions to fetch.
     */
    orderBy?: PendingSessionOrderByWithRelationInput | PendingSessionOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing PendingSessions.
     */
    cursor?: PendingSessionWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` PendingSessions 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` PendingSessions.
     */
    skip?: number
    distinct?: PendingSessionScalarFieldEnum | PendingSessionScalarFieldEnum[]
  }

  /**
   * PendingSession create
   */
  export type PendingSessionCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PendingSession
     */
    select?: PendingSessionSelect<ExtArgs> | null
    /**
     * The data needed to create a PendingSession.
     */
    data: XOR<PendingSessionCreateInput, PendingSessionUncheckedCreateInput>
  }

  /**
   * PendingSession createMany
   */
  export type PendingSessionCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many PendingSessions.
     */
    data: PendingSessionCreateManyInput | PendingSessionCreateManyInput[]
  }

  /**
   * PendingSession createManyAndReturn
   */
  export type PendingSessionCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PendingSession
     */
    select?: PendingSessionSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many PendingSessions.
     */
    data: PendingSessionCreateManyInput | PendingSessionCreateManyInput[]
  }

  /**
   * PendingSession update
   */
  export type PendingSessionUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PendingSession
     */
    select?: PendingSessionSelect<ExtArgs> | null
    /**
     * The data needed to update a PendingSession.
     */
    data: XOR<PendingSessionUpdateInput, PendingSessionUncheckedUpdateInput>
    /**
     * Choose, which PendingSession to update.
     */
    where: PendingSessionWhereUniqueInput
  }

  /**
   * PendingSession updateMany
   */
  export type PendingSessionUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update PendingSessions.
     */
    data: XOR<PendingSessionUpdateManyMutationInput, PendingSessionUncheckedUpdateManyInput>
    /**
     * Filter which PendingSessions to update
     */
    where?: PendingSessionWhereInput
  }

  /**
   * PendingSession upsert
   */
  export type PendingSessionUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PendingSession
     */
    select?: PendingSessionSelect<ExtArgs> | null
    /**
     * The filter to search for the PendingSession to update in case it exists.
     */
    where: PendingSessionWhereUniqueInput
    /**
     * In case the PendingSession found by the `where` argument doesn't exist, create a new PendingSession with this data.
     */
    create: XOR<PendingSessionCreateInput, PendingSessionUncheckedCreateInput>
    /**
     * In case the PendingSession was found with the provided `where` argument, update it with this data.
     */
    update: XOR<PendingSessionUpdateInput, PendingSessionUncheckedUpdateInput>
  }

  /**
   * PendingSession delete
   */
  export type PendingSessionDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PendingSession
     */
    select?: PendingSessionSelect<ExtArgs> | null
    /**
     * Filter which PendingSession to delete.
     */
    where: PendingSessionWhereUniqueInput
  }

  /**
   * PendingSession deleteMany
   */
  export type PendingSessionDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which PendingSessions to delete
     */
    where?: PendingSessionWhereInput
  }

  /**
   * PendingSession without action
   */
  export type PendingSessionDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PendingSession
     */
    select?: PendingSessionSelect<ExtArgs> | null
  }


  /**
   * Model CLIArgs
   */

  export type AggregateCLIArgs = {
    _count: CLIArgsCountAggregateOutputType | null
    _avg: CLIArgsAvgAggregateOutputType | null
    _sum: CLIArgsSumAggregateOutputType | null
    _min: CLIArgsMinAggregateOutputType | null
    _max: CLIArgsMaxAggregateOutputType | null
  }

  export type CLIArgsAvgAggregateOutputType = {
    id: number | null
  }

  export type CLIArgsSumAggregateOutputType = {
    id: number | null
  }

  export type CLIArgsMinAggregateOutputType = {
    id: number | null
    args: string | null
    createdAt: Date | null
  }

  export type CLIArgsMaxAggregateOutputType = {
    id: number | null
    args: string | null
    createdAt: Date | null
  }

  export type CLIArgsCountAggregateOutputType = {
    id: number
    args: number
    createdAt: number
    _all: number
  }


  export type CLIArgsAvgAggregateInputType = {
    id?: true
  }

  export type CLIArgsSumAggregateInputType = {
    id?: true
  }

  export type CLIArgsMinAggregateInputType = {
    id?: true
    args?: true
    createdAt?: true
  }

  export type CLIArgsMaxAggregateInputType = {
    id?: true
    args?: true
    createdAt?: true
  }

  export type CLIArgsCountAggregateInputType = {
    id?: true
    args?: true
    createdAt?: true
    _all?: true
  }

  export type CLIArgsAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which CLIArgs to aggregate.
     */
    where?: CLIArgsWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of CLIArgs to fetch.
     */
    orderBy?: CLIArgsOrderByWithRelationInput | CLIArgsOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: CLIArgsWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` CLIArgs 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` CLIArgs.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned CLIArgs
    **/
    _count?: true | CLIArgsCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: CLIArgsAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: CLIArgsSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: CLIArgsMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: CLIArgsMaxAggregateInputType
  }

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




  export type CLIArgsGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: CLIArgsWhereInput
    orderBy?: CLIArgsOrderByWithAggregationInput | CLIArgsOrderByWithAggregationInput[]
    by: CLIArgsScalarFieldEnum[] | CLIArgsScalarFieldEnum
    having?: CLIArgsScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: CLIArgsCountAggregateInputType | true
    _avg?: CLIArgsAvgAggregateInputType
    _sum?: CLIArgsSumAggregateInputType
    _min?: CLIArgsMinAggregateInputType
    _max?: CLIArgsMaxAggregateInputType
  }

  export type CLIArgsGroupByOutputType = {
    id: number
    args: string
    createdAt: Date
    _count: CLIArgsCountAggregateOutputType | null
    _avg: CLIArgsAvgAggregateOutputType | null
    _sum: CLIArgsSumAggregateOutputType | null
    _min: CLIArgsMinAggregateOutputType | null
    _max: CLIArgsMaxAggregateOutputType | null
  }

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


  export type CLIArgsSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    args?: boolean
    createdAt?: boolean
  }, ExtArgs["result"]["cLIArgs"]>

  export type CLIArgsSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    args?: boolean
    createdAt?: boolean
  }, ExtArgs["result"]["cLIArgs"]>

  export type CLIArgsSelectScalar = {
    id?: boolean
    args?: boolean
    createdAt?: boolean
  }


  export type $CLIArgsPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "CLIArgs"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: number
      args: string
      createdAt: Date
    }, ExtArgs["result"]["cLIArgs"]>
    composites: {}
  }

  type CLIArgsGetPayload<S extends boolean | null | undefined | CLIArgsDefaultArgs> = $Result.GetResult<Prisma.$CLIArgsPayload, S>

  type CLIArgsCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<CLIArgsFindManyArgs, 'select' | 'include' | 'distinct'> & {
      select?: CLIArgsCountAggregateInputType | true
    }

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

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

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

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

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

    /**
     * Create a CLIArgs.
     * @param {CLIArgsCreateArgs} args - Arguments to create a CLIArgs.
     * @example
     * // Create one CLIArgs
     * const CLIArgs = await prisma.cLIArgs.create({
     *   data: {
     *     // ... data to create a CLIArgs
     *   }
     * })
     * 
     */
    create<T extends CLIArgsCreateArgs>(args: SelectSubset<T, CLIArgsCreateArgs<ExtArgs>>): Prisma__CLIArgsClient<$Result.GetResult<Prisma.$CLIArgsPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

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

    /**
     * Delete a CLIArgs.
     * @param {CLIArgsDeleteArgs} args - Arguments to delete one CLIArgs.
     * @example
     * // Delete one CLIArgs
     * const CLIArgs = await prisma.cLIArgs.delete({
     *   where: {
     *     // ... filter to delete one CLIArgs
     *   }
     * })
     * 
     */
    delete<T extends CLIArgsDeleteArgs>(args: SelectSubset<T, CLIArgsDeleteArgs<ExtArgs>>): Prisma__CLIArgsClient<$Result.GetResult<Prisma.$CLIArgsPayload<ExtArgs>, T, "delete">, never, ExtArgs>

    /**
     * Update one CLIArgs.
     * @param {CLIArgsUpdateArgs} args - Arguments to update one CLIArgs.
     * @example
     * // Update one CLIArgs
     * const cLIArgs = await prisma.cLIArgs.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends CLIArgsUpdateArgs>(args: SelectSubset<T, CLIArgsUpdateArgs<ExtArgs>>): Prisma__CLIArgsClient<$Result.GetResult<Prisma.$CLIArgsPayload<ExtArgs>, T, "update">, never, ExtArgs>

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

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

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for CLIArgs.
   * 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__CLIArgsClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
    /**
     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
     * resolved value cannot be modified from the callback.
     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
     * @returns A Promise for the completion of the callback.
     */
    finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
  }




  /**
   * Fields of the CLIArgs model
   */ 
  interface CLIArgsFieldRefs {
    readonly id: FieldRef<"CLIArgs", 'Int'>
    readonly args: FieldRef<"CLIArgs", 'String'>
    readonly createdAt: FieldRef<"CLIArgs", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * CLIArgs findUnique
   */
  export type CLIArgsFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CLIArgs
     */
    select?: CLIArgsSelect<ExtArgs> | null
    /**
     * Filter, which CLIArgs to fetch.
     */
    where: CLIArgsWhereUniqueInput
  }

  /**
   * CLIArgs findUniqueOrThrow
   */
  export type CLIArgsFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CLIArgs
     */
    select?: CLIArgsSelect<ExtArgs> | null
    /**
     * Filter, which CLIArgs to fetch.
     */
    where: CLIArgsWhereUniqueInput
  }

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

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

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

  /**
   * CLIArgs create
   */
  export type CLIArgsCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CLIArgs
     */
    select?: CLIArgsSelect<ExtArgs> | null
    /**
     * The data needed to create a CLIArgs.
     */
    data: XOR<CLIArgsCreateInput, CLIArgsUncheckedCreateInput>
  }

  /**
   * CLIArgs createMany
   */
  export type CLIArgsCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many CLIArgs.
     */
    data: CLIArgsCreateManyInput | CLIArgsCreateManyInput[]
  }

  /**
   * CLIArgs createManyAndReturn
   */
  export type CLIArgsCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CLIArgs
     */
    select?: CLIArgsSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many CLIArgs.
     */
    data: CLIArgsCreateManyInput | CLIArgsCreateManyInput[]
  }

  /**
   * CLIArgs update
   */
  export type CLIArgsUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CLIArgs
     */
    select?: CLIArgsSelect<ExtArgs> | null
    /**
     * The data needed to update a CLIArgs.
     */
    data: XOR<CLIArgsUpdateInput, CLIArgsUncheckedUpdateInput>
    /**
     * Choose, which CLIArgs to update.
     */
    where: CLIArgsWhereUniqueInput
  }

  /**
   * CLIArgs updateMany
   */
  export type CLIArgsUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update CLIArgs.
     */
    data: XOR<CLIArgsUpdateManyMutationInput, CLIArgsUncheckedUpdateManyInput>
    /**
     * Filter which CLIArgs to update
     */
    where?: CLIArgsWhereInput
  }

  /**
   * CLIArgs upsert
   */
  export type CLIArgsUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CLIArgs
     */
    select?: CLIArgsSelect<ExtArgs> | null
    /**
     * The filter to search for the CLIArgs to update in case it exists.
     */
    where: CLIArgsWhereUniqueInput
    /**
     * In case the CLIArgs found by the `where` argument doesn't exist, create a new CLIArgs with this data.
     */
    create: XOR<CLIArgsCreateInput, CLIArgsUncheckedCreateInput>
    /**
     * In case the CLIArgs was found with the provided `where` argument, update it with this data.
     */
    update: XOR<CLIArgsUpdateInput, CLIArgsUncheckedUpdateInput>
  }

  /**
   * CLIArgs delete
   */
  export type CLIArgsDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CLIArgs
     */
    select?: CLIArgsSelect<ExtArgs> | null
    /**
     * Filter which CLIArgs to delete.
     */
    where: CLIArgsWhereUniqueInput
  }

  /**
   * CLIArgs deleteMany
   */
  export type CLIArgsDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which CLIArgs to delete
     */
    where?: CLIArgsWhereInput
  }

  /**
   * CLIArgs without action
   */
  export type CLIArgsDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CLIArgs
     */
    select?: CLIArgsSelect<ExtArgs> | null
  }


  /**
   * Model WebhookConfig
   */

  export type AggregateWebhookConfig = {
    _count: WebhookConfigCountAggregateOutputType | null
    _min: WebhookConfigMinAggregateOutputType | null
    _max: WebhookConfigMaxAggregateOutputType | null
  }

  export type WebhookConfigMinAggregateOutputType = {
    id: string | null
    url: string | null
    type: string | null
    events: string | null
    active: boolean | null
    createdAt: Date | null
    updatedAt: Date | null
    payloadTemplate: string | null
  }

  export type WebhookConfigMaxAggregateOutputType = {
    id: string | null
    url: string | null
    type: string | null
    events: string | null
    active: boolean | null
    createdAt: Date | null
    updatedAt: Date | null
    payloadTemplate: string | null
  }

  export type WebhookConfigCountAggregateOutputType = {
    id: number
    url: number
    type: number
    events: number
    active: number
    createdAt: number
    updatedAt: number
    payloadTemplate: number
    _all: number
  }


  export type WebhookConfigMinAggregateInputType = {
    id?: true
    url?: true
    type?: true
    events?: true
    active?: true
    createdAt?: true
    updatedAt?: true
    payloadTemplate?: true
  }

  export type WebhookConfigMaxAggregateInputType = {
    id?: true
    url?: true
    type?: true
    events?: true
    active?: true
    createdAt?: true
    updatedAt?: true
    payloadTemplate?: true
  }

  export type WebhookConfigCountAggregateInputType = {
    id?: true
    url?: true
    type?: true
    events?: true
    active?: true
    createdAt?: true
    updatedAt?: true
    payloadTemplate?: true
    _all?: true
  }

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

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




  export type WebhookConfigGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: WebhookConfigWhereInput
    orderBy?: WebhookConfigOrderByWithAggregationInput | WebhookConfigOrderByWithAggregationInput[]
    by: WebhookConfigScalarFieldEnum[] | WebhookConfigScalarFieldEnum
    having?: WebhookConfigScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: WebhookConfigCountAggregateInputType | true
    _min?: WebhookConfigMinAggregateInputType
    _max?: WebhookConfigMaxAggregateInputType
  }

  export type WebhookConfigGroupByOutputType = {
    id: string
    url: string
    type: string
    events: string
    active: boolean
    createdAt: Date
    updatedAt: Date
    payloadTemplate: string | null
    _count: WebhookConfigCountAggregateOutputType | null
    _min: WebhookConfigMinAggregateOutputType | null
    _max: WebhookConfigMaxAggregateOutputType | null
  }

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


  export type WebhookConfigSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    url?: boolean
    type?: boolean
    events?: boolean
    active?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    payloadTemplate?: boolean
  }, ExtArgs["result"]["webhookConfig"]>

  export type WebhookConfigSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    url?: boolean
    type?: boolean
    events?: boolean
    active?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    payloadTemplate?: boolean
  }, ExtArgs["result"]["webhookConfig"]>

  export type WebhookConfigSelectScalar = {
    id?: boolean
    url?: boolean
    type?: boolean
    events?: boolean
    active?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    payloadTemplate?: boolean
  }


  export type $WebhookConfigPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "WebhookConfig"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: string
      url: string
      type: string
      events: string
      active: boolean
      createdAt: Date
      updatedAt: Date
      payloadTemplate: string | null
    }, ExtArgs["result"]["webhookConfig"]>
    composites: {}
  }

  type WebhookConfigGetPayload<S extends boolean | null | undefined | WebhookConfigDefaultArgs> = $Result.GetResult<Prisma.$WebhookConfigPayload, S>

  type WebhookConfigCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<WebhookConfigFindManyArgs, 'select' | 'include' | 'distinct'> & {
      select?: WebhookConfigCountAggregateInputType | true
    }

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

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

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

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

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

    /**
     * Create a WebhookConfig.
     * @param {WebhookConfigCreateArgs} args - Arguments to create a WebhookConfig.
     * @example
     * // Create one WebhookConfig
     * const WebhookConfig = await prisma.webhookConfig.create({
     *   data: {
     *     // ... data to create a WebhookConfig
     *   }
     * })
     * 
     */
    create<T extends WebhookConfigCreateArgs>(args: SelectSubset<T, WebhookConfigCreateArgs<ExtArgs>>): Prisma__WebhookConfigClient<$Result.GetResult<Prisma.$WebhookConfigPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

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

    /**
     * Delete a WebhookConfig.
     * @param {WebhookConfigDeleteArgs} args - Arguments to delete one WebhookConfig.
     * @example
     * // Delete one WebhookConfig
     * const WebhookConfig = await prisma.webhookConfig.delete({
     *   where: {
     *     // ... filter to delete one WebhookConfig
     *   }
     * })
     * 
     */
    delete<T extends WebhookConfigDeleteArgs>(args: SelectSubset<T, WebhookConfigDeleteArgs<ExtArgs>>): Prisma__WebhookConfigClient<$Result.GetResult<Prisma.$WebhookConfigPayload<ExtArgs>, T, "delete">, never, ExtArgs>

    /**
     * Update one WebhookConfig.
     * @param {WebhookConfigUpdateArgs} args - Arguments to update one WebhookConfig.
     * @example
     * // Update one WebhookConfig
     * const webhookConfig = await prisma.webhookConfig.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends WebhookConfigUpdateArgs>(args: SelectSubset<T, WebhookConfigUpdateArgs<ExtArgs>>): Prisma__WebhookConfigClient<$Result.GetResult<Prisma.$WebhookConfigPayload<ExtArgs>, T, "update">, never, ExtArgs>

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

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

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for WebhookConfig.
   * 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__WebhookConfigClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
    /**
     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
     * resolved value cannot be modified from the callback.
     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
     * @returns A Promise for the completion of the callback.
     */
    finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
  }




  /**
   * Fields of the WebhookConfig model
   */ 
  interface WebhookConfigFieldRefs {
    readonly id: FieldRef<"WebhookConfig", 'String'>
    readonly url: FieldRef<"WebhookConfig", 'String'>
    readonly type: FieldRef<"WebhookConfig", 'String'>
    readonly events: FieldRef<"WebhookConfig", 'String'>
    readonly active: FieldRef<"WebhookConfig", 'Boolean'>
    readonly createdAt: FieldRef<"WebhookConfig", 'DateTime'>
    readonly updatedAt: FieldRef<"WebhookConfig", 'DateTime'>
    readonly payloadTemplate: FieldRef<"WebhookConfig", 'String'>
  }
    

  // Custom InputTypes
  /**
   * WebhookConfig findUnique
   */
  export type WebhookConfigFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the WebhookConfig
     */
    select?: WebhookConfigSelect<ExtArgs> | null
    /**
     * Filter, which WebhookConfig to fetch.
     */
    where: WebhookConfigWhereUniqueInput
  }

  /**
   * WebhookConfig findUniqueOrThrow
   */
  export type WebhookConfigFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the WebhookConfig
     */
    select?: WebhookConfigSelect<ExtArgs> | null
    /**
     * Filter, which WebhookConfig to fetch.
     */
    where: WebhookConfigWhereUniqueInput
  }

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

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

  /**
   * WebhookConfig findMany
   */
  export type WebhookConfigFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the WebhookConfig
     */
    select?: WebhookConfigSelect<ExtArgs> | null
    /**
     * Filter, which WebhookConfigs to fetch.
     */
    where?: WebhookConfigWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of WebhookConfigs to fetch.
     */
    orderBy?: WebhookConfigOrderByWithRelationInput | WebhookConfigOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing WebhookConfigs.
     */
    cursor?: WebhookConfigWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` WebhookConfigs 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` WebhookConfigs.
     */
    skip?: number
    distinct?: WebhookConfigScalarFieldEnum | WebhookConfigScalarFieldEnum[]
  }

  /**
   * WebhookConfig create
   */
  export type WebhookConfigCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the WebhookConfig
     */
    select?: WebhookConfigSelect<ExtArgs> | null
    /**
     * The data needed to create a WebhookConfig.
     */
    data: XOR<WebhookConfigCreateInput, WebhookConfigUncheckedCreateInput>
  }

  /**
   * WebhookConfig createMany
   */
  export type WebhookConfigCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many WebhookConfigs.
     */
    data: WebhookConfigCreateManyInput | WebhookConfigCreateManyInput[]
  }

  /**
   * WebhookConfig createManyAndReturn
   */
  export type WebhookConfigCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the WebhookConfig
     */
    select?: WebhookConfigSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many WebhookConfigs.
     */
    data: WebhookConfigCreateManyInput | WebhookConfigCreateManyInput[]
  }

  /**
   * WebhookConfig update
   */
  export type WebhookConfigUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the WebhookConfig
     */
    select?: WebhookConfigSelect<ExtArgs> | null
    /**
     * The data needed to update a WebhookConfig.
     */
    data: XOR<WebhookConfigUpdateInput, WebhookConfigUncheckedUpdateInput>
    /**
     * Choose, which WebhookConfig to update.
     */
    where: WebhookConfigWhereUniqueInput
  }

  /**
   * WebhookConfig updateMany
   */
  export type WebhookConfigUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update WebhookConfigs.
     */
    data: XOR<WebhookConfigUpdateManyMutationInput, WebhookConfigUncheckedUpdateManyInput>
    /**
     * Filter which WebhookConfigs to update
     */
    where?: WebhookConfigWhereInput
  }

  /**
   * WebhookConfig upsert
   */
  export type WebhookConfigUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the WebhookConfig
     */
    select?: WebhookConfigSelect<ExtArgs> | null
    /**
     * The filter to search for the WebhookConfig to update in case it exists.
     */
    where: WebhookConfigWhereUniqueInput
    /**
     * In case the WebhookConfig found by the `where` argument doesn't exist, create a new WebhookConfig with this data.
     */
    create: XOR<WebhookConfigCreateInput, WebhookConfigUncheckedCreateInput>
    /**
     * In case the WebhookConfig was found with the provided `where` argument, update it with this data.
     */
    update: XOR<WebhookConfigUpdateInput, WebhookConfigUncheckedUpdateInput>
  }

  /**
   * WebhookConfig delete
   */
  export type WebhookConfigDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the WebhookConfig
     */
    select?: WebhookConfigSelect<ExtArgs> | null
    /**
     * Filter which WebhookConfig to delete.
     */
    where: WebhookConfigWhereUniqueInput
  }

  /**
   * WebhookConfig deleteMany
   */
  export type WebhookConfigDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which WebhookConfigs to delete
     */
    where?: WebhookConfigWhereInput
  }

  /**
   * WebhookConfig without action
   */
  export type WebhookConfigDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the WebhookConfig
     */
    select?: WebhookConfigSelect<ExtArgs> | null
  }


  /**
   * Model WebConfig
   */

  export type AggregateWebConfig = {
    _count: WebConfigCountAggregateOutputType | null
    _min: WebConfigMinAggregateOutputType | null
    _max: WebConfigMaxAggregateOutputType | null
  }

  export type WebConfigMinAggregateOutputType = {
    id: string | null
    name: string | null
    value: string | null
    createdAt: Date | null
    updatedAt: Date | null
  }

  export type WebConfigMaxAggregateOutputType = {
    id: string | null
    name: string | null
    value: string | null
    createdAt: Date | null
    updatedAt: Date | null
  }

  export type WebConfigCountAggregateOutputType = {
    id: number
    name: number
    value: number
    createdAt: number
    updatedAt: number
    _all: number
  }


  export type WebConfigMinAggregateInputType = {
    id?: true
    name?: true
    value?: true
    createdAt?: true
    updatedAt?: true
  }

  export type WebConfigMaxAggregateInputType = {
    id?: true
    name?: true
    value?: true
    createdAt?: true
    updatedAt?: true
  }

  export type WebConfigCountAggregateInputType = {
    id?: true
    name?: true
    value?: true
    createdAt?: true
    updatedAt?: true
    _all?: true
  }

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

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




  export type WebConfigGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: WebConfigWhereInput
    orderBy?: WebConfigOrderByWithAggregationInput | WebConfigOrderByWithAggregationInput[]
    by: WebConfigScalarFieldEnum[] | WebConfigScalarFieldEnum
    having?: WebConfigScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: WebConfigCountAggregateInputType | true
    _min?: WebConfigMinAggregateInputType
    _max?: WebConfigMaxAggregateInputType
  }

  export type WebConfigGroupByOutputType = {
    id: string
    name: string
    value: string
    createdAt: Date
    updatedAt: Date
    _count: WebConfigCountAggregateOutputType | null
    _min: WebConfigMinAggregateOutputType | null
    _max: WebConfigMaxAggregateOutputType | null
  }

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


  export type WebConfigSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
    value?: boolean
    createdAt?: boolean
    updatedAt?: boolean
  }, ExtArgs["result"]["webConfig"]>

  export type WebConfigSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
    value?: boolean
    createdAt?: boolean
    updatedAt?: boolean
  }, ExtArgs["result"]["webConfig"]>

  export type WebConfigSelectScalar = {
    id?: boolean
    name?: boolean
    value?: boolean
    createdAt?: boolean
    updatedAt?: boolean
  }


  export type $WebConfigPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "WebConfig"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: string
      name: string
      value: string
      createdAt: Date
      updatedAt: Date
    }, ExtArgs["result"]["webConfig"]>
    composites: {}
  }

  type WebConfigGetPayload<S extends boolean | null | undefined | WebConfigDefaultArgs> = $Result.GetResult<Prisma.$WebConfigPayload, S>

  type WebConfigCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<WebConfigFindManyArgs, 'select' | 'include' | 'distinct'> & {
      select?: WebConfigCountAggregateInputType | true
    }

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

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

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

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

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

    /**
     * Create a WebConfig.
     * @param {WebConfigCreateArgs} args - Arguments to create a WebConfig.
     * @example
     * // Create one WebConfig
     * const WebConfig = await prisma.webConfig.create({
     *   data: {
     *     // ... data to create a WebConfig
     *   }
     * })
     * 
     */
    create<T extends WebConfigCreateArgs>(args: SelectSubset<T, WebConfigCreateArgs<ExtArgs>>): Prisma__WebConfigClient<$Result.GetResult<Prisma.$WebConfigPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

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

    /**
     * Delete a WebConfig.
     * @param {WebConfigDeleteArgs} args - Arguments to delete one WebConfig.
     * @example
     * // Delete one WebConfig
     * const WebConfig = await prisma.webConfig.delete({
     *   where: {
     *     // ... filter to delete one WebConfig
     *   }
     * })
     * 
     */
    delete<T extends WebConfigDeleteArgs>(args: SelectSubset<T, WebConfigDeleteArgs<ExtArgs>>): Prisma__WebConfigClient<$Result.GetResult<Prisma.$WebConfigPayload<ExtArgs>, T, "delete">, never, ExtArgs>

    /**
     * Update one WebConfig.
     * @param {WebConfigUpdateArgs} args - Arguments to update one WebConfig.
     * @example
     * // Update one WebConfig
     * const webConfig = await prisma.webConfig.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends WebConfigUpdateArgs>(args: SelectSubset<T, WebConfigUpdateArgs<ExtArgs>>): Prisma__WebConfigClient<$Result.GetResult<Prisma.$WebConfigPayload<ExtArgs>, T, "update">, never, ExtArgs>

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

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

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for WebConfig.
   * 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__WebConfigClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
    /**
     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
     * resolved value cannot be modified from the callback.
     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
     * @returns A Promise for the completion of the callback.
     */
    finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
  }




  /**
   * Fields of the WebConfig model
   */ 
  interface WebConfigFieldRefs {
    readonly id: FieldRef<"WebConfig", 'String'>
    readonly name: FieldRef<"WebConfig", 'String'>
    readonly value: FieldRef<"WebConfig", 'String'>
    readonly createdAt: FieldRef<"WebConfig", 'DateTime'>
    readonly updatedAt: FieldRef<"WebConfig", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * WebConfig findUnique
   */
  export type WebConfigFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the WebConfig
     */
    select?: WebConfigSelect<ExtArgs> | null
    /**
     * Filter, which WebConfig to fetch.
     */
    where: WebConfigWhereUniqueInput
  }

  /**
   * WebConfig findUniqueOrThrow
   */
  export type WebConfigFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the WebConfig
     */
    select?: WebConfigSelect<ExtArgs> | null
    /**
     * Filter, which WebConfig to fetch.
     */
    where: WebConfigWhereUniqueInput
  }

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

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

  /**
   * WebConfig findMany
   */
  export type WebConfigFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the WebConfig
     */
    select?: WebConfigSelect<ExtArgs> | null
    /**
     * Filter, which WebConfigs to fetch.
     */
    where?: WebConfigWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of WebConfigs to fetch.
     */
    orderBy?: WebConfigOrderByWithRelationInput | WebConfigOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing WebConfigs.
     */
    cursor?: WebConfigWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` WebConfigs 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` WebConfigs.
     */
    skip?: number
    distinct?: WebConfigScalarFieldEnum | WebConfigScalarFieldEnum[]
  }

  /**
   * WebConfig create
   */
  export type WebConfigCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the WebConfig
     */
    select?: WebConfigSelect<ExtArgs> | null
    /**
     * The data needed to create a WebConfig.
     */
    data: XOR<WebConfigCreateInput, WebConfigUncheckedCreateInput>
  }

  /**
   * WebConfig createMany
   */
  export type WebConfigCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many WebConfigs.
     */
    data: WebConfigCreateManyInput | WebConfigCreateManyInput[]
  }

  /**
   * WebConfig createManyAndReturn
   */
  export type WebConfigCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the WebConfig
     */
    select?: WebConfigSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many WebConfigs.
     */
    data: WebConfigCreateManyInput | WebConfigCreateManyInput[]
  }

  /**
   * WebConfig update
   */
  export type WebConfigUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the WebConfig
     */
    select?: WebConfigSelect<ExtArgs> | null
    /**
     * The data needed to update a WebConfig.
     */
    data: XOR<WebConfigUpdateInput, WebConfigUncheckedUpdateInput>
    /**
     * Choose, which WebConfig to update.
     */
    where: WebConfigWhereUniqueInput
  }

  /**
   * WebConfig updateMany
   */
  export type WebConfigUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update WebConfigs.
     */
    data: XOR<WebConfigUpdateManyMutationInput, WebConfigUncheckedUpdateManyInput>
    /**
     * Filter which WebConfigs to update
     */
    where?: WebConfigWhereInput
  }

  /**
   * WebConfig upsert
   */
  export type WebConfigUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the WebConfig
     */
    select?: WebConfigSelect<ExtArgs> | null
    /**
     * The filter to search for the WebConfig to update in case it exists.
     */
    where: WebConfigWhereUniqueInput
    /**
     * In case the WebConfig found by the `where` argument doesn't exist, create a new WebConfig with this data.
     */
    create: XOR<WebConfigCreateInput, WebConfigUncheckedCreateInput>
    /**
     * In case the WebConfig was found with the provided `where` argument, update it with this data.
     */
    update: XOR<WebConfigUpdateInput, WebConfigUncheckedUpdateInput>
  }

  /**
   * WebConfig delete
   */
  export type WebConfigDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the WebConfig
     */
    select?: WebConfigSelect<ExtArgs> | null
    /**
     * Filter which WebConfig to delete.
     */
    where: WebConfigWhereUniqueInput
  }

  /**
   * WebConfig deleteMany
   */
  export type WebConfigDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which WebConfigs to delete
     */
    where?: WebConfigWhereInput
  }

  /**
   * WebConfig without action
   */
  export type WebConfigDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the WebConfig
     */
    select?: WebConfigSelect<ExtArgs> | null
  }


  /**
   * Model LocatorEtalon
   */

  export type AggregateLocatorEtalon = {
    _count: LocatorEtalonCountAggregateOutputType | null
    _min: LocatorEtalonMinAggregateOutputType | null
    _max: LocatorEtalonMaxAggregateOutputType | null
  }

  export type LocatorEtalonMinAggregateOutputType = {
    id: string | null
    selector: string | null
    strategy: string | null
    attributes: string | null
    nodeName: string | null
    lastSeen: Date | null
    createdAt: Date | null
    updatedAt: Date | null
  }

  export type LocatorEtalonMaxAggregateOutputType = {
    id: string | null
    selector: string | null
    strategy: string | null
    attributes: string | null
    nodeName: string | null
    lastSeen: Date | null
    createdAt: Date | null
    updatedAt: Date | null
  }

  export type LocatorEtalonCountAggregateOutputType = {
    id: number
    selector: number
    strategy: number
    attributes: number
    nodeName: number
    lastSeen: number
    createdAt: number
    updatedAt: number
    _all: number
  }


  export type LocatorEtalonMinAggregateInputType = {
    id?: true
    selector?: true
    strategy?: true
    attributes?: true
    nodeName?: true
    lastSeen?: true
    createdAt?: true
    updatedAt?: true
  }

  export type LocatorEtalonMaxAggregateInputType = {
    id?: true
    selector?: true
    strategy?: true
    attributes?: true
    nodeName?: true
    lastSeen?: true
    createdAt?: true
    updatedAt?: true
  }

  export type LocatorEtalonCountAggregateInputType = {
    id?: true
    selector?: true
    strategy?: true
    attributes?: true
    nodeName?: true
    lastSeen?: true
    createdAt?: true
    updatedAt?: true
    _all?: true
  }

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

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




  export type LocatorEtalonGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: LocatorEtalonWhereInput
    orderBy?: LocatorEtalonOrderByWithAggregationInput | LocatorEtalonOrderByWithAggregationInput[]
    by: LocatorEtalonScalarFieldEnum[] | LocatorEtalonScalarFieldEnum
    having?: LocatorEtalonScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: LocatorEtalonCountAggregateInputType | true
    _min?: LocatorEtalonMinAggregateInputType
    _max?: LocatorEtalonMaxAggregateInputType
  }

  export type LocatorEtalonGroupByOutputType = {
    id: string
    selector: string
    strategy: string
    attributes: string
    nodeName: string
    lastSeen: Date
    createdAt: Date
    updatedAt: Date
    _count: LocatorEtalonCountAggregateOutputType | null
    _min: LocatorEtalonMinAggregateOutputType | null
    _max: LocatorEtalonMaxAggregateOutputType | null
  }

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


  export type LocatorEtalonSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    selector?: boolean
    strategy?: boolean
    attributes?: boolean
    nodeName?: boolean
    lastSeen?: boolean
    createdAt?: boolean
    updatedAt?: boolean
  }, ExtArgs["result"]["locatorEtalon"]>

  export type LocatorEtalonSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    selector?: boolean
    strategy?: boolean
    attributes?: boolean
    nodeName?: boolean
    lastSeen?: boolean
    createdAt?: boolean
    updatedAt?: boolean
  }, ExtArgs["result"]["locatorEtalon"]>

  export type LocatorEtalonSelectScalar = {
    id?: boolean
    selector?: boolean
    strategy?: boolean
    attributes?: boolean
    nodeName?: boolean
    lastSeen?: boolean
    createdAt?: boolean
    updatedAt?: boolean
  }


  export type $LocatorEtalonPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "LocatorEtalon"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: string
      selector: string
      strategy: string
      attributes: string
      nodeName: string
      lastSeen: Date
      createdAt: Date
      updatedAt: Date
    }, ExtArgs["result"]["locatorEtalon"]>
    composites: {}
  }

  type LocatorEtalonGetPayload<S extends boolean | null | undefined | LocatorEtalonDefaultArgs> = $Result.GetResult<Prisma.$LocatorEtalonPayload, S>

  type LocatorEtalonCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<LocatorEtalonFindManyArgs, 'select' | 'include' | 'distinct'> & {
      select?: LocatorEtalonCountAggregateInputType | true
    }

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

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

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

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

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

    /**
     * Create a LocatorEtalon.
     * @param {LocatorEtalonCreateArgs} args - Arguments to create a LocatorEtalon.
     * @example
     * // Create one LocatorEtalon
     * const LocatorEtalon = await prisma.locatorEtalon.create({
     *   data: {
     *     // ... data to create a LocatorEtalon
     *   }
     * })
     * 
     */
    create<T extends LocatorEtalonCreateArgs>(args: SelectSubset<T, LocatorEtalonCreateArgs<ExtArgs>>): Prisma__LocatorEtalonClient<$Result.GetResult<Prisma.$LocatorEtalonPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

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

    /**
     * Delete a LocatorEtalon.
     * @param {LocatorEtalonDeleteArgs} args - Arguments to delete one LocatorEtalon.
     * @example
     * // Delete one LocatorEtalon
     * const LocatorEtalon = await prisma.locatorEtalon.delete({
     *   where: {
     *     // ... filter to delete one LocatorEtalon
     *   }
     * })
     * 
     */
    delete<T extends LocatorEtalonDeleteArgs>(args: SelectSubset<T, LocatorEtalonDeleteArgs<ExtArgs>>): Prisma__LocatorEtalonClient<$Result.GetResult<Prisma.$LocatorEtalonPayload<ExtArgs>, T, "delete">, never, ExtArgs>

    /**
     * Update one LocatorEtalon.
     * @param {LocatorEtalonUpdateArgs} args - Arguments to update one LocatorEtalon.
     * @example
     * // Update one LocatorEtalon
     * const locatorEtalon = await prisma.locatorEtalon.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends LocatorEtalonUpdateArgs>(args: SelectSubset<T, LocatorEtalonUpdateArgs<ExtArgs>>): Prisma__LocatorEtalonClient<$Result.GetResult<Prisma.$LocatorEtalonPayload<ExtArgs>, T, "update">, never, ExtArgs>

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

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

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for LocatorEtalon.
   * 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__LocatorEtalonClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
    /**
     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
     * resolved value cannot be modified from the callback.
     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
     * @returns A Promise for the completion of the callback.
     */
    finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
  }




  /**
   * Fields of the LocatorEtalon model
   */ 
  interface LocatorEtalonFieldRefs {
    readonly id: FieldRef<"LocatorEtalon", 'String'>
    readonly selector: FieldRef<"LocatorEtalon", 'String'>
    readonly strategy: FieldRef<"LocatorEtalon", 'String'>
    readonly attributes: FieldRef<"LocatorEtalon", 'String'>
    readonly nodeName: FieldRef<"LocatorEtalon", 'String'>
    readonly lastSeen: FieldRef<"LocatorEtalon", 'DateTime'>
    readonly createdAt: FieldRef<"LocatorEtalon", 'DateTime'>
    readonly updatedAt: FieldRef<"LocatorEtalon", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * LocatorEtalon findUnique
   */
  export type LocatorEtalonFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the LocatorEtalon
     */
    select?: LocatorEtalonSelect<ExtArgs> | null
    /**
     * Filter, which LocatorEtalon to fetch.
     */
    where: LocatorEtalonWhereUniqueInput
  }

  /**
   * LocatorEtalon findUniqueOrThrow
   */
  export type LocatorEtalonFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the LocatorEtalon
     */
    select?: LocatorEtalonSelect<ExtArgs> | null
    /**
     * Filter, which LocatorEtalon to fetch.
     */
    where: LocatorEtalonWhereUniqueInput
  }

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

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

  /**
   * LocatorEtalon findMany
   */
  export type LocatorEtalonFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the LocatorEtalon
     */
    select?: LocatorEtalonSelect<ExtArgs> | null
    /**
     * Filter, which LocatorEtalons to fetch.
     */
    where?: LocatorEtalonWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of LocatorEtalons to fetch.
     */
    orderBy?: LocatorEtalonOrderByWithRelationInput | LocatorEtalonOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing LocatorEtalons.
     */
    cursor?: LocatorEtalonWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` LocatorEtalons 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` LocatorEtalons.
     */
    skip?: number
    distinct?: LocatorEtalonScalarFieldEnum | LocatorEtalonScalarFieldEnum[]
  }

  /**
   * LocatorEtalon create
   */
  export type LocatorEtalonCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the LocatorEtalon
     */
    select?: LocatorEtalonSelect<ExtArgs> | null
    /**
     * The data needed to create a LocatorEtalon.
     */
    data: XOR<LocatorEtalonCreateInput, LocatorEtalonUncheckedCreateInput>
  }

  /**
   * LocatorEtalon createMany
   */
  export type LocatorEtalonCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many LocatorEtalons.
     */
    data: LocatorEtalonCreateManyInput | LocatorEtalonCreateManyInput[]
  }

  /**
   * LocatorEtalon createManyAndReturn
   */
  export type LocatorEtalonCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the LocatorEtalon
     */
    select?: LocatorEtalonSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many LocatorEtalons.
     */
    data: LocatorEtalonCreateManyInput | LocatorEtalonCreateManyInput[]
  }

  /**
   * LocatorEtalon update
   */
  export type LocatorEtalonUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the LocatorEtalon
     */
    select?: LocatorEtalonSelect<ExtArgs> | null
    /**
     * The data needed to update a LocatorEtalon.
     */
    data: XOR<LocatorEtalonUpdateInput, LocatorEtalonUncheckedUpdateInput>
    /**
     * Choose, which LocatorEtalon to update.
     */
    where: LocatorEtalonWhereUniqueInput
  }

  /**
   * LocatorEtalon updateMany
   */
  export type LocatorEtalonUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update LocatorEtalons.
     */
    data: XOR<LocatorEtalonUpdateManyMutationInput, LocatorEtalonUncheckedUpdateManyInput>
    /**
     * Filter which LocatorEtalons to update
     */
    where?: LocatorEtalonWhereInput
  }

  /**
   * LocatorEtalon upsert
   */
  export type LocatorEtalonUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the LocatorEtalon
     */
    select?: LocatorEtalonSelect<ExtArgs> | null
    /**
     * The filter to search for the LocatorEtalon to update in case it exists.
     */
    where: LocatorEtalonWhereUniqueInput
    /**
     * In case the LocatorEtalon found by the `where` argument doesn't exist, create a new LocatorEtalon with this data.
     */
    create: XOR<LocatorEtalonCreateInput, LocatorEtalonUncheckedCreateInput>
    /**
     * In case the LocatorEtalon was found with the provided `where` argument, update it with this data.
     */
    update: XOR<LocatorEtalonUpdateInput, LocatorEtalonUncheckedUpdateInput>
  }

  /**
   * LocatorEtalon delete
   */
  export type LocatorEtalonDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the LocatorEtalon
     */
    select?: LocatorEtalonSelect<ExtArgs> | null
    /**
     * Filter which LocatorEtalon to delete.
     */
    where: LocatorEtalonWhereUniqueInput
  }

  /**
   * LocatorEtalon deleteMany
   */
  export type LocatorEtalonDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which LocatorEtalons to delete
     */
    where?: LocatorEtalonWhereInput
  }

  /**
   * LocatorEtalon without action
   */
  export type LocatorEtalonDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the LocatorEtalon
     */
    select?: LocatorEtalonSelect<ExtArgs> | null
  }


  /**
   * Model PortLease
   */

  export type AggregatePortLease = {
    _count: PortLeaseCountAggregateOutputType | null
    _avg: PortLeaseAvgAggregateOutputType | null
    _sum: PortLeaseSumAggregateOutputType | null
    _min: PortLeaseMinAggregateOutputType | null
    _max: PortLeaseMaxAggregateOutputType | null
  }

  export type PortLeaseAvgAggregateOutputType = {
    port: number | null
    leasedToPid: number | null
    leasedAt: number | null
    expiresAt: number | null
  }

  export type PortLeaseSumAggregateOutputType = {
    port: number | null
    leasedToPid: number | null
    leasedAt: number | null
    expiresAt: number | null
  }

  export type PortLeaseMinAggregateOutputType = {
    port: number | null
    purpose: string | null
    leasedToUdid: string | null
    leasedToHost: string | null
    leaseId: string | null
    leasedToPid: number | null
    leasedAt: number | null
    expiresAt: number | null
  }

  export type PortLeaseMaxAggregateOutputType = {
    port: number | null
    purpose: string | null
    leasedToUdid: string | null
    leasedToHost: string | null
    leaseId: string | null
    leasedToPid: number | null
    leasedAt: number | null
    expiresAt: number | null
  }

  export type PortLeaseCountAggregateOutputType = {
    port: number
    purpose: number
    leasedToUdid: number
    leasedToHost: number
    leaseId: number
    leasedToPid: number
    leasedAt: number
    expiresAt: number
    _all: number
  }


  export type PortLeaseAvgAggregateInputType = {
    port?: true
    leasedToPid?: true
    leasedAt?: true
    expiresAt?: true
  }

  export type PortLeaseSumAggregateInputType = {
    port?: true
    leasedToPid?: true
    leasedAt?: true
    expiresAt?: true
  }

  export type PortLeaseMinAggregateInputType = {
    port?: true
    purpose?: true
    leasedToUdid?: true
    leasedToHost?: true
    leaseId?: true
    leasedToPid?: true
    leasedAt?: true
    expiresAt?: true
  }

  export type PortLeaseMaxAggregateInputType = {
    port?: true
    purpose?: true
    leasedToUdid?: true
    leasedToHost?: true
    leaseId?: true
    leasedToPid?: true
    leasedAt?: true
    expiresAt?: true
  }

  export type PortLeaseCountAggregateInputType = {
    port?: true
    purpose?: true
    leasedToUdid?: true
    leasedToHost?: true
    leaseId?: true
    leasedToPid?: true
    leasedAt?: true
    expiresAt?: true
    _all?: true
  }

  export type PortLeaseAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which PortLease to aggregate.
     */
    where?: PortLeaseWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of PortLeases to fetch.
     */
    orderBy?: PortLeaseOrderByWithRelationInput | PortLeaseOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: PortLeaseWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` PortLeases 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` PortLeases.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned PortLeases
    **/
    _count?: true | PortLeaseCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: PortLeaseAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: PortLeaseSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: PortLeaseMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: PortLeaseMaxAggregateInputType
  }

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




  export type PortLeaseGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: PortLeaseWhereInput
    orderBy?: PortLeaseOrderByWithAggregationInput | PortLeaseOrderByWithAggregationInput[]
    by: PortLeaseScalarFieldEnum[] | PortLeaseScalarFieldEnum
    having?: PortLeaseScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: PortLeaseCountAggregateInputType | true
    _avg?: PortLeaseAvgAggregateInputType
    _sum?: PortLeaseSumAggregateInputType
    _min?: PortLeaseMinAggregateInputType
    _max?: PortLeaseMaxAggregateInputType
  }

  export type PortLeaseGroupByOutputType = {
    port: number
    purpose: string
    leasedToUdid: string
    leasedToHost: string
    leaseId: string | null
    leasedToPid: number | null
    leasedAt: number
    expiresAt: number
    _count: PortLeaseCountAggregateOutputType | null
    _avg: PortLeaseAvgAggregateOutputType | null
    _sum: PortLeaseSumAggregateOutputType | null
    _min: PortLeaseMinAggregateOutputType | null
    _max: PortLeaseMaxAggregateOutputType | null
  }

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


  export type PortLeaseSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    port?: boolean
    purpose?: boolean
    leasedToUdid?: boolean
    leasedToHost?: boolean
    leaseId?: boolean
    leasedToPid?: boolean
    leasedAt?: boolean
    expiresAt?: boolean
  }, ExtArgs["result"]["portLease"]>

  export type PortLeaseSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    port?: boolean
    purpose?: boolean
    leasedToUdid?: boolean
    leasedToHost?: boolean
    leaseId?: boolean
    leasedToPid?: boolean
    leasedAt?: boolean
    expiresAt?: boolean
  }, ExtArgs["result"]["portLease"]>

  export type PortLeaseSelectScalar = {
    port?: boolean
    purpose?: boolean
    leasedToUdid?: boolean
    leasedToHost?: boolean
    leaseId?: boolean
    leasedToPid?: boolean
    leasedAt?: boolean
    expiresAt?: boolean
  }


  export type $PortLeasePayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "PortLease"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      port: number
      purpose: string
      leasedToUdid: string
      leasedToHost: string
      leaseId: string | null
      leasedToPid: number | null
      leasedAt: number
      expiresAt: number
    }, ExtArgs["result"]["portLease"]>
    composites: {}
  }

  type PortLeaseGetPayload<S extends boolean | null | undefined | PortLeaseDefaultArgs> = $Result.GetResult<Prisma.$PortLeasePayload, S>

  type PortLeaseCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<PortLeaseFindManyArgs, 'select' | 'include' | 'distinct'> & {
      select?: PortLeaseCountAggregateInputType | true
    }

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

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

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

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

    /**
     * Find zero or more PortLeases 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 {PortLeaseFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all PortLeases
     * const portLeases = await prisma.portLease.findMany()
     * 
     * // Get first 10 PortLeases
     * const portLeases = await prisma.portLease.findMany({ take: 10 })
     * 
     * // Only select the `port`
     * const portLeaseWithPortOnly = await prisma.portLease.findMany({ select: { port: true } })
     * 
     */
    findMany<T extends PortLeaseFindManyArgs>(args?: SelectSubset<T, PortLeaseFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$PortLeasePayload<ExtArgs>, T, "findMany">>

    /**
     * Create a PortLease.
     * @param {PortLeaseCreateArgs} args - Arguments to create a PortLease.
     * @example
     * // Create one PortLease
     * const PortLease = await prisma.portLease.create({
     *   data: {
     *     // ... data to create a PortLease
     *   }
     * })
     * 
     */
    create<T extends PortLeaseCreateArgs>(args: SelectSubset<T, PortLeaseCreateArgs<ExtArgs>>): Prisma__PortLeaseClient<$Result.GetResult<Prisma.$PortLeasePayload<ExtArgs>, T, "create">, never, ExtArgs>

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

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

    /**
     * Delete a PortLease.
     * @param {PortLeaseDeleteArgs} args - Arguments to delete one PortLease.
     * @example
     * // Delete one PortLease
     * const PortLease = await prisma.portLease.delete({
     *   where: {
     *     // ... filter to delete one PortLease
     *   }
     * })
     * 
     */
    delete<T extends PortLeaseDeleteArgs>(args: SelectSubset<T, PortLeaseDeleteArgs<ExtArgs>>): Prisma__PortLeaseClient<$Result.GetResult<Prisma.$PortLeasePayload<ExtArgs>, T, "delete">, never, ExtArgs>

    /**
     * Update one PortLease.
     * @param {PortLeaseUpdateArgs} args - Arguments to update one PortLease.
     * @example
     * // Update one PortLease
     * const portLease = await prisma.portLease.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends PortLeaseUpdateArgs>(args: SelectSubset<T, PortLeaseUpdateArgs<ExtArgs>>): Prisma__PortLeaseClient<$Result.GetResult<Prisma.$PortLeasePayload<ExtArgs>, T, "update">, never, ExtArgs>

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

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

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for PortLease.
   * 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__PortLeaseClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
    /**
     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
     * resolved value cannot be modified from the callback.
     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
     * @returns A Promise for the completion of the callback.
     */
    finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
  }




  /**
   * Fields of the PortLease model
   */ 
  interface PortLeaseFieldRefs {
    readonly port: FieldRef<"PortLease", 'Int'>
    readonly purpose: FieldRef<"PortLease", 'String'>
    readonly leasedToUdid: FieldRef<"PortLease", 'String'>
    readonly leasedToHost: FieldRef<"PortLease", 'String'>
    readonly leaseId: FieldRef<"PortLease", 'String'>
    readonly leasedToPid: FieldRef<"PortLease", 'Int'>
    readonly leasedAt: FieldRef<"PortLease", 'Float'>
    readonly expiresAt: FieldRef<"PortLease", 'Float'>
  }
    

  // Custom InputTypes
  /**
   * PortLease findUnique
   */
  export type PortLeaseFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PortLease
     */
    select?: PortLeaseSelect<ExtArgs> | null
    /**
     * Filter, which PortLease to fetch.
     */
    where: PortLeaseWhereUniqueInput
  }

  /**
   * PortLease findUniqueOrThrow
   */
  export type PortLeaseFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PortLease
     */
    select?: PortLeaseSelect<ExtArgs> | null
    /**
     * Filter, which PortLease to fetch.
     */
    where: PortLeaseWhereUniqueInput
  }

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

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

  /**
   * PortLease findMany
   */
  export type PortLeaseFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PortLease
     */
    select?: PortLeaseSelect<ExtArgs> | null
    /**
     * Filter, which PortLeases to fetch.
     */
    where?: PortLeaseWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of PortLeases to fetch.
     */
    orderBy?: PortLeaseOrderByWithRelationInput | PortLeaseOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing PortLeases.
     */
    cursor?: PortLeaseWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` PortLeases 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` PortLeases.
     */
    skip?: number
    distinct?: PortLeaseScalarFieldEnum | PortLeaseScalarFieldEnum[]
  }

  /**
   * PortLease create
   */
  export type PortLeaseCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PortLease
     */
    select?: PortLeaseSelect<ExtArgs> | null
    /**
     * The data needed to create a PortLease.
     */
    data: XOR<PortLeaseCreateInput, PortLeaseUncheckedCreateInput>
  }

  /**
   * PortLease createMany
   */
  export type PortLeaseCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many PortLeases.
     */
    data: PortLeaseCreateManyInput | PortLeaseCreateManyInput[]
  }

  /**
   * PortLease createManyAndReturn
   */
  export type PortLeaseCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PortLease
     */
    select?: PortLeaseSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many PortLeases.
     */
    data: PortLeaseCreateManyInput | PortLeaseCreateManyInput[]
  }

  /**
   * PortLease update
   */
  export type PortLeaseUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PortLease
     */
    select?: PortLeaseSelect<ExtArgs> | null
    /**
     * The data needed to update a PortLease.
     */
    data: XOR<PortLeaseUpdateInput, PortLeaseUncheckedUpdateInput>
    /**
     * Choose, which PortLease to update.
     */
    where: PortLeaseWhereUniqueInput
  }

  /**
   * PortLease updateMany
   */
  export type PortLeaseUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update PortLeases.
     */
    data: XOR<PortLeaseUpdateManyMutationInput, PortLeaseUncheckedUpdateManyInput>
    /**
     * Filter which PortLeases to update
     */
    where?: PortLeaseWhereInput
  }

  /**
   * PortLease upsert
   */
  export type PortLeaseUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PortLease
     */
    select?: PortLeaseSelect<ExtArgs> | null
    /**
     * The filter to search for the PortLease to update in case it exists.
     */
    where: PortLeaseWhereUniqueInput
    /**
     * In case the PortLease found by the `where` argument doesn't exist, create a new PortLease with this data.
     */
    create: XOR<PortLeaseCreateInput, PortLeaseUncheckedCreateInput>
    /**
     * In case the PortLease was found with the provided `where` argument, update it with this data.
     */
    update: XOR<PortLeaseUpdateInput, PortLeaseUncheckedUpdateInput>
  }

  /**
   * PortLease delete
   */
  export type PortLeaseDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PortLease
     */
    select?: PortLeaseSelect<ExtArgs> | null
    /**
     * Filter which PortLease to delete.
     */
    where: PortLeaseWhereUniqueInput
  }

  /**
   * PortLease deleteMany
   */
  export type PortLeaseDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which PortLeases to delete
     */
    where?: PortLeaseWhereInput
  }

  /**
   * PortLease without action
   */
  export type PortLeaseDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PortLease
     */
    select?: PortLeaseSelect<ExtArgs> | null
  }


  /**
   * Model Lease
   */

  export type AggregateLease = {
    _count: LeaseCountAggregateOutputType | null
    _avg: LeaseAvgAggregateOutputType | null
    _sum: LeaseSumAggregateOutputType | null
    _min: LeaseMinAggregateOutputType | null
    _max: LeaseMaxAggregateOutputType | null
  }

  export type LeaseAvgAggregateOutputType = {
    expiresAt: number | null
    heartbeatSeconds: number | null
    lastHeartbeatAt: number | null
  }

  export type LeaseSumAggregateOutputType = {
    expiresAt: number | null
    heartbeatSeconds: number | null
    lastHeartbeatAt: number | null
  }

  export type LeaseMinAggregateOutputType = {
    id: string | null
    tokenHash: string | null
    deviceUdid: string | null
    deviceHost: string | null
    actorId: string | null
    teamId: string | null
    buildId: string | null
    reason: string | null
    status: string | null
    createdAt: Date | null
    expiresAt: number | null
    heartbeatSeconds: number | null
    lastHeartbeatAt: number | null
    allocatedPorts: string | null
    capabilityBag: string | null
  }

  export type LeaseMaxAggregateOutputType = {
    id: string | null
    tokenHash: string | null
    deviceUdid: string | null
    deviceHost: string | null
    actorId: string | null
    teamId: string | null
    buildId: string | null
    reason: string | null
    status: string | null
    createdAt: Date | null
    expiresAt: number | null
    heartbeatSeconds: number | null
    lastHeartbeatAt: number | null
    allocatedPorts: string | null
    capabilityBag: string | null
  }

  export type LeaseCountAggregateOutputType = {
    id: number
    tokenHash: number
    deviceUdid: number
    deviceHost: number
    actorId: number
    teamId: number
    buildId: number
    reason: number
    status: number
    createdAt: number
    expiresAt: number
    heartbeatSeconds: number
    lastHeartbeatAt: number
    allocatedPorts: number
    capabilityBag: number
    _all: number
  }


  export type LeaseAvgAggregateInputType = {
    expiresAt?: true
    heartbeatSeconds?: true
    lastHeartbeatAt?: true
  }

  export type LeaseSumAggregateInputType = {
    expiresAt?: true
    heartbeatSeconds?: true
    lastHeartbeatAt?: true
  }

  export type LeaseMinAggregateInputType = {
    id?: true
    tokenHash?: true
    deviceUdid?: true
    deviceHost?: true
    actorId?: true
    teamId?: true
    buildId?: true
    reason?: true
    status?: true
    createdAt?: true
    expiresAt?: true
    heartbeatSeconds?: true
    lastHeartbeatAt?: true
    allocatedPorts?: true
    capabilityBag?: true
  }

  export type LeaseMaxAggregateInputType = {
    id?: true
    tokenHash?: true
    deviceUdid?: true
    deviceHost?: true
    actorId?: true
    teamId?: true
    buildId?: true
    reason?: true
    status?: true
    createdAt?: true
    expiresAt?: true
    heartbeatSeconds?: true
    lastHeartbeatAt?: true
    allocatedPorts?: true
    capabilityBag?: true
  }

  export type LeaseCountAggregateInputType = {
    id?: true
    tokenHash?: true
    deviceUdid?: true
    deviceHost?: true
    actorId?: true
    teamId?: true
    buildId?: true
    reason?: true
    status?: true
    createdAt?: true
    expiresAt?: true
    heartbeatSeconds?: true
    lastHeartbeatAt?: true
    allocatedPorts?: true
    capabilityBag?: true
    _all?: true
  }

  export type LeaseAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Lease to aggregate.
     */
    where?: LeaseWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Leases to fetch.
     */
    orderBy?: LeaseOrderByWithRelationInput | LeaseOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: LeaseWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Leases 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` Leases.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned Leases
    **/
    _count?: true | LeaseCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: LeaseAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: LeaseSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: LeaseMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: LeaseMaxAggregateInputType
  }

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




  export type LeaseGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: LeaseWhereInput
    orderBy?: LeaseOrderByWithAggregationInput | LeaseOrderByWithAggregationInput[]
    by: LeaseScalarFieldEnum[] | LeaseScalarFieldEnum
    having?: LeaseScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: LeaseCountAggregateInputType | true
    _avg?: LeaseAvgAggregateInputType
    _sum?: LeaseSumAggregateInputType
    _min?: LeaseMinAggregateInputType
    _max?: LeaseMaxAggregateInputType
  }

  export type LeaseGroupByOutputType = {
    id: string
    tokenHash: string
    deviceUdid: string
    deviceHost: string
    actorId: string
    teamId: string | null
    buildId: string | null
    reason: string | null
    status: string
    createdAt: Date
    expiresAt: number
    heartbeatSeconds: number
    lastHeartbeatAt: number
    allocatedPorts: string
    capabilityBag: string
    _count: LeaseCountAggregateOutputType | null
    _avg: LeaseAvgAggregateOutputType | null
    _sum: LeaseSumAggregateOutputType | null
    _min: LeaseMinAggregateOutputType | null
    _max: LeaseMaxAggregateOutputType | null
  }

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


  export type LeaseSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    tokenHash?: boolean
    deviceUdid?: boolean
    deviceHost?: boolean
    actorId?: boolean
    teamId?: boolean
    buildId?: boolean
    reason?: boolean
    status?: boolean
    createdAt?: boolean
    expiresAt?: boolean
    heartbeatSeconds?: boolean
    lastHeartbeatAt?: boolean
    allocatedPorts?: boolean
    capabilityBag?: boolean
  }, ExtArgs["result"]["lease"]>

  export type LeaseSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    tokenHash?: boolean
    deviceUdid?: boolean
    deviceHost?: boolean
    actorId?: boolean
    teamId?: boolean
    buildId?: boolean
    reason?: boolean
    status?: boolean
    createdAt?: boolean
    expiresAt?: boolean
    heartbeatSeconds?: boolean
    lastHeartbeatAt?: boolean
    allocatedPorts?: boolean
    capabilityBag?: boolean
  }, ExtArgs["result"]["lease"]>

  export type LeaseSelectScalar = {
    id?: boolean
    tokenHash?: boolean
    deviceUdid?: boolean
    deviceHost?: boolean
    actorId?: boolean
    teamId?: boolean
    buildId?: boolean
    reason?: boolean
    status?: boolean
    createdAt?: boolean
    expiresAt?: boolean
    heartbeatSeconds?: boolean
    lastHeartbeatAt?: boolean
    allocatedPorts?: boolean
    capabilityBag?: boolean
  }


  export type $LeasePayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Lease"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: string
      tokenHash: string
      deviceUdid: string
      deviceHost: string
      actorId: string
      teamId: string | null
      buildId: string | null
      reason: string | null
      status: string
      createdAt: Date
      expiresAt: number
      heartbeatSeconds: number
      lastHeartbeatAt: number
      allocatedPorts: string
      capabilityBag: string
    }, ExtArgs["result"]["lease"]>
    composites: {}
  }

  type LeaseGetPayload<S extends boolean | null | undefined | LeaseDefaultArgs> = $Result.GetResult<Prisma.$LeasePayload, S>

  type LeaseCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<LeaseFindManyArgs, 'select' | 'include' | 'distinct'> & {
      select?: LeaseCountAggregateInputType | true
    }

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

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

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

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

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

    /**
     * Create a Lease.
     * @param {LeaseCreateArgs} args - Arguments to create a Lease.
     * @example
     * // Create one Lease
     * const Lease = await prisma.lease.create({
     *   data: {
     *     // ... data to create a Lease
     *   }
     * })
     * 
     */
    create<T extends LeaseCreateArgs>(args: SelectSubset<T, LeaseCreateArgs<ExtArgs>>): Prisma__LeaseClient<$Result.GetResult<Prisma.$LeasePayload<ExtArgs>, T, "create">, never, ExtArgs>

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

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

    /**
     * Delete a Lease.
     * @param {LeaseDeleteArgs} args - Arguments to delete one Lease.
     * @example
     * // Delete one Lease
     * const Lease = await prisma.lease.delete({
     *   where: {
     *     // ... filter to delete one Lease
     *   }
     * })
     * 
     */
    delete<T extends LeaseDeleteArgs>(args: SelectSubset<T, LeaseDeleteArgs<ExtArgs>>): Prisma__LeaseClient<$Result.GetResult<Prisma.$LeasePayload<ExtArgs>, T, "delete">, never, ExtArgs>

    /**
     * Update one Lease.
     * @param {LeaseUpdateArgs} args - Arguments to update one Lease.
     * @example
     * // Update one Lease
     * const lease = await prisma.lease.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends LeaseUpdateArgs>(args: SelectSubset<T, LeaseUpdateArgs<ExtArgs>>): Prisma__LeaseClient<$Result.GetResult<Prisma.$LeasePayload<ExtArgs>, T, "update">, never, ExtArgs>

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

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

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for Lease.
   * 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__LeaseClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
    /**
     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
     * resolved value cannot be modified from the callback.
     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
     * @returns A Promise for the completion of the callback.
     */
    finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
  }




  /**
   * Fields of the Lease model
   */ 
  interface LeaseFieldRefs {
    readonly id: FieldRef<"Lease", 'String'>
    readonly tokenHash: FieldRef<"Lease", 'String'>
    readonly deviceUdid: FieldRef<"Lease", 'String'>
    readonly deviceHost: FieldRef<"Lease", 'String'>
    readonly actorId: FieldRef<"Lease", 'String'>
    readonly teamId: FieldRef<"Lease", 'String'>
    readonly buildId: FieldRef<"Lease", 'String'>
    readonly reason: FieldRef<"Lease", 'String'>
    readonly status: FieldRef<"Lease", 'String'>
    readonly createdAt: FieldRef<"Lease", 'DateTime'>
    readonly expiresAt: FieldRef<"Lease", 'Float'>
    readonly heartbeatSeconds: FieldRef<"Lease", 'Int'>
    readonly lastHeartbeatAt: FieldRef<"Lease", 'Float'>
    readonly allocatedPorts: FieldRef<"Lease", 'String'>
    readonly capabilityBag: FieldRef<"Lease", 'String'>
  }
    

  // Custom InputTypes
  /**
   * Lease findUnique
   */
  export type LeaseFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Lease
     */
    select?: LeaseSelect<ExtArgs> | null
    /**
     * Filter, which Lease to fetch.
     */
    where: LeaseWhereUniqueInput
  }

  /**
   * Lease findUniqueOrThrow
   */
  export type LeaseFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Lease
     */
    select?: LeaseSelect<ExtArgs> | null
    /**
     * Filter, which Lease to fetch.
     */
    where: LeaseWhereUniqueInput
  }

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

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

  /**
   * Lease findMany
   */
  export type LeaseFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Lease
     */
    select?: LeaseSelect<ExtArgs> | null
    /**
     * Filter, which Leases to fetch.
     */
    where?: LeaseWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Leases to fetch.
     */
    orderBy?: LeaseOrderByWithRelationInput | LeaseOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing Leases.
     */
    cursor?: LeaseWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Leases 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` Leases.
     */
    skip?: number
    distinct?: LeaseScalarFieldEnum | LeaseScalarFieldEnum[]
  }

  /**
   * Lease create
   */
  export type LeaseCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Lease
     */
    select?: LeaseSelect<ExtArgs> | null
    /**
     * The data needed to create a Lease.
     */
    data: XOR<LeaseCreateInput, LeaseUncheckedCreateInput>
  }

  /**
   * Lease createMany
   */
  export type LeaseCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many Leases.
     */
    data: LeaseCreateManyInput | LeaseCreateManyInput[]
  }

  /**
   * Lease createManyAndReturn
   */
  export type LeaseCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Lease
     */
    select?: LeaseSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many Leases.
     */
    data: LeaseCreateManyInput | LeaseCreateManyInput[]
  }

  /**
   * Lease update
   */
  export type LeaseUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Lease
     */
    select?: LeaseSelect<ExtArgs> | null
    /**
     * The data needed to update a Lease.
     */
    data: XOR<LeaseUpdateInput, LeaseUncheckedUpdateInput>
    /**
     * Choose, which Lease to update.
     */
    where: LeaseWhereUniqueInput
  }

  /**
   * Lease updateMany
   */
  export type LeaseUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Leases.
     */
    data: XOR<LeaseUpdateManyMutationInput, LeaseUncheckedUpdateManyInput>
    /**
     * Filter which Leases to update
     */
    where?: LeaseWhereInput
  }

  /**
   * Lease upsert
   */
  export type LeaseUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Lease
     */
    select?: LeaseSelect<ExtArgs> | null
    /**
     * The filter to search for the Lease to update in case it exists.
     */
    where: LeaseWhereUniqueInput
    /**
     * In case the Lease found by the `where` argument doesn't exist, create a new Lease with this data.
     */
    create: XOR<LeaseCreateInput, LeaseUncheckedCreateInput>
    /**
     * In case the Lease was found with the provided `where` argument, update it with this data.
     */
    update: XOR<LeaseUpdateInput, LeaseUncheckedUpdateInput>
  }

  /**
   * Lease delete
   */
  export type LeaseDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Lease
     */
    select?: LeaseSelect<ExtArgs> | null
    /**
     * Filter which Lease to delete.
     */
    where: LeaseWhereUniqueInput
  }

  /**
   * Lease deleteMany
   */
  export type LeaseDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Leases to delete
     */
    where?: LeaseWhereInput
  }

  /**
   * Lease without action
   */
  export type LeaseDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Lease
     */
    select?: LeaseSelect<ExtArgs> | null
  }


  /**
   * Model ApiKey
   */

  export type AggregateApiKey = {
    _count: ApiKeyCountAggregateOutputType | null
    _avg: ApiKeyAvgAggregateOutputType | null
    _sum: ApiKeySumAggregateOutputType | null
    _min: ApiKeyMinAggregateOutputType | null
    _max: ApiKeyMaxAggregateOutputType | null
  }

  export type ApiKeyAvgAggregateOutputType = {
    rateLimit: number | null
  }

  export type ApiKeySumAggregateOutputType = {
    rateLimit: number | null
  }

  export type ApiKeyMinAggregateOutputType = {
    id: string | null
    name: string | null
    keyHash: string | null
    scopes: string | null
    rateLimit: number | null
    createdAt: Date | null
    revokedAt: Date | null
    lastUsedAt: Date | null
    expiresAt: Date | null
    teamId: string | null
    role: string | null
    userId: string | null
  }

  export type ApiKeyMaxAggregateOutputType = {
    id: string | null
    name: string | null
    keyHash: string | null
    scopes: string | null
    rateLimit: number | null
    createdAt: Date | null
    revokedAt: Date | null
    lastUsedAt: Date | null
    expiresAt: Date | null
    teamId: string | null
    role: string | null
    userId: string | null
  }

  export type ApiKeyCountAggregateOutputType = {
    id: number
    name: number
    keyHash: number
    scopes: number
    rateLimit: number
    createdAt: number
    revokedAt: number
    lastUsedAt: number
    expiresAt: number
    teamId: number
    role: number
    userId: number
    _all: number
  }


  export type ApiKeyAvgAggregateInputType = {
    rateLimit?: true
  }

  export type ApiKeySumAggregateInputType = {
    rateLimit?: true
  }

  export type ApiKeyMinAggregateInputType = {
    id?: true
    name?: true
    keyHash?: true
    scopes?: true
    rateLimit?: true
    createdAt?: true
    revokedAt?: true
    lastUsedAt?: true
    expiresAt?: true
    teamId?: true
    role?: true
    userId?: true
  }

  export type ApiKeyMaxAggregateInputType = {
    id?: true
    name?: true
    keyHash?: true
    scopes?: true
    rateLimit?: true
    createdAt?: true
    revokedAt?: true
    lastUsedAt?: true
    expiresAt?: true
    teamId?: true
    role?: true
    userId?: true
  }

  export type ApiKeyCountAggregateInputType = {
    id?: true
    name?: true
    keyHash?: true
    scopes?: true
    rateLimit?: true
    createdAt?: true
    revokedAt?: true
    lastUsedAt?: true
    expiresAt?: true
    teamId?: true
    role?: true
    userId?: true
    _all?: true
  }

  export type ApiKeyAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which ApiKey to aggregate.
     */
    where?: ApiKeyWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of ApiKeys to fetch.
     */
    orderBy?: ApiKeyOrderByWithRelationInput | ApiKeyOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: ApiKeyWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` ApiKeys 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` ApiKeys.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned ApiKeys
    **/
    _count?: true | ApiKeyCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: ApiKeyAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: ApiKeySumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: ApiKeyMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: ApiKeyMaxAggregateInputType
  }

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




  export type ApiKeyGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: ApiKeyWhereInput
    orderBy?: ApiKeyOrderByWithAggregationInput | ApiKeyOrderByWithAggregationInput[]
    by: ApiKeyScalarFieldEnum[] | ApiKeyScalarFieldEnum
    having?: ApiKeyScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: ApiKeyCountAggregateInputType | true
    _avg?: ApiKeyAvgAggregateInputType
    _sum?: ApiKeySumAggregateInputType
    _min?: ApiKeyMinAggregateInputType
    _max?: ApiKeyMaxAggregateInputType
  }

  export type ApiKeyGroupByOutputType = {
    id: string
    name: string
    keyHash: string
    scopes: string
    rateLimit: number
    createdAt: Date
    revokedAt: Date | null
    lastUsedAt: Date | null
    expiresAt: Date | null
    teamId: string | null
    role: string
    userId: string
    _count: ApiKeyCountAggregateOutputType | null
    _avg: ApiKeyAvgAggregateOutputType | null
    _sum: ApiKeySumAggregateOutputType | null
    _min: ApiKeyMinAggregateOutputType | null
    _max: ApiKeyMaxAggregateOutputType | null
  }

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


  export type ApiKeySelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
    keyHash?: boolean
    scopes?: boolean
    rateLimit?: boolean
    createdAt?: boolean
    revokedAt?: boolean
    lastUsedAt?: boolean
    expiresAt?: boolean
    teamId?: boolean
    role?: boolean
    userId?: boolean
    team?: boolean | ApiKey$teamArgs<ExtArgs>
    user?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["apiKey"]>

  export type ApiKeySelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
    keyHash?: boolean
    scopes?: boolean
    rateLimit?: boolean
    createdAt?: boolean
    revokedAt?: boolean
    lastUsedAt?: boolean
    expiresAt?: boolean
    teamId?: boolean
    role?: boolean
    userId?: boolean
    team?: boolean | ApiKey$teamArgs<ExtArgs>
    user?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["apiKey"]>

  export type ApiKeySelectScalar = {
    id?: boolean
    name?: boolean
    keyHash?: boolean
    scopes?: boolean
    rateLimit?: boolean
    createdAt?: boolean
    revokedAt?: boolean
    lastUsedAt?: boolean
    expiresAt?: boolean
    teamId?: boolean
    role?: boolean
    userId?: boolean
  }

  export type ApiKeyInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    team?: boolean | ApiKey$teamArgs<ExtArgs>
    user?: boolean | UserDefaultArgs<ExtArgs>
  }
  export type ApiKeyIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    team?: boolean | ApiKey$teamArgs<ExtArgs>
    user?: boolean | UserDefaultArgs<ExtArgs>
  }

  export type $ApiKeyPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "ApiKey"
    objects: {
      team: Prisma.$TeamPayload<ExtArgs> | null
      user: Prisma.$UserPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      name: string
      keyHash: string
      scopes: string
      rateLimit: number
      createdAt: Date
      revokedAt: Date | null
      lastUsedAt: Date | null
      expiresAt: Date | null
      teamId: string | null
      role: string
      userId: string
    }, ExtArgs["result"]["apiKey"]>
    composites: {}
  }

  type ApiKeyGetPayload<S extends boolean | null | undefined | ApiKeyDefaultArgs> = $Result.GetResult<Prisma.$ApiKeyPayload, S>

  type ApiKeyCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<ApiKeyFindManyArgs, 'select' | 'include' | 'distinct'> & {
      select?: ApiKeyCountAggregateInputType | true
    }

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

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

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

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

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

    /**
     * Create a ApiKey.
     * @param {ApiKeyCreateArgs} args - Arguments to create a ApiKey.
     * @example
     * // Create one ApiKey
     * const ApiKey = await prisma.apiKey.create({
     *   data: {
     *     // ... data to create a ApiKey
     *   }
     * })
     * 
     */
    create<T extends ApiKeyCreateArgs>(args: SelectSubset<T, ApiKeyCreateArgs<ExtArgs>>): Prisma__ApiKeyClient<$Result.GetResult<Prisma.$ApiKeyPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

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

    /**
     * Delete a ApiKey.
     * @param {ApiKeyDeleteArgs} args - Arguments to delete one ApiKey.
     * @example
     * // Delete one ApiKey
     * const ApiKey = await prisma.apiKey.delete({
     *   where: {
     *     // ... filter to delete one ApiKey
     *   }
     * })
     * 
     */
    delete<T extends ApiKeyDeleteArgs>(args: SelectSubset<T, ApiKeyDeleteArgs<ExtArgs>>): Prisma__ApiKeyClient<$Result.GetResult<Prisma.$ApiKeyPayload<ExtArgs>, T, "delete">, never, ExtArgs>

    /**
     * Update one ApiKey.
     * @param {ApiKeyUpdateArgs} args - Arguments to update one ApiKey.
     * @example
     * // Update one ApiKey
     * const apiKey = await prisma.apiKey.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends ApiKeyUpdateArgs>(args: SelectSubset<T, ApiKeyUpdateArgs<ExtArgs>>): Prisma__ApiKeyClient<$Result.GetResult<Prisma.$ApiKeyPayload<ExtArgs>, T, "update">, never, ExtArgs>

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

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

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for ApiKey.
   * 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__ApiKeyClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    team<T extends ApiKey$teamArgs<ExtArgs> = {}>(args?: Subset<T, ApiKey$teamArgs<ExtArgs>>): Prisma__TeamClient<$Result.GetResult<Prisma.$TeamPayload<ExtArgs>, T, "findUniqueOrThrow"> | null, null, ExtArgs>
    user<T extends UserDefaultArgs<ExtArgs> = {}>(args?: Subset<T, UserDefaultArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findUniqueOrThrow"> | Null, Null, ExtArgs>
    /**
     * 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 ApiKey model
   */ 
  interface ApiKeyFieldRefs {
    readonly id: FieldRef<"ApiKey", 'String'>
    readonly name: FieldRef<"ApiKey", 'String'>
    readonly keyHash: FieldRef<"ApiKey", 'String'>
    readonly scopes: FieldRef<"ApiKey", 'String'>
    readonly rateLimit: FieldRef<"ApiKey", 'Int'>
    readonly createdAt: FieldRef<"ApiKey", 'DateTime'>
    readonly revokedAt: FieldRef<"ApiKey", 'DateTime'>
    readonly lastUsedAt: FieldRef<"ApiKey", 'DateTime'>
    readonly expiresAt: FieldRef<"ApiKey", 'DateTime'>
    readonly teamId: FieldRef<"ApiKey", 'String'>
    readonly role: FieldRef<"ApiKey", 'String'>
    readonly userId: FieldRef<"ApiKey", 'String'>
  }
    

  // Custom InputTypes
  /**
   * ApiKey findUnique
   */
  export type ApiKeyFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ApiKey
     */
    select?: ApiKeySelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ApiKeyInclude<ExtArgs> | null
    /**
     * Filter, which ApiKey to fetch.
     */
    where: ApiKeyWhereUniqueInput
  }

  /**
   * ApiKey findUniqueOrThrow
   */
  export type ApiKeyFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ApiKey
     */
    select?: ApiKeySelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ApiKeyInclude<ExtArgs> | null
    /**
     * Filter, which ApiKey to fetch.
     */
    where: ApiKeyWhereUniqueInput
  }

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

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

  /**
   * ApiKey findMany
   */
  export type ApiKeyFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ApiKey
     */
    select?: ApiKeySelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ApiKeyInclude<ExtArgs> | null
    /**
     * Filter, which ApiKeys to fetch.
     */
    where?: ApiKeyWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of ApiKeys to fetch.
     */
    orderBy?: ApiKeyOrderByWithRelationInput | ApiKeyOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing ApiKeys.
     */
    cursor?: ApiKeyWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` ApiKeys 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` ApiKeys.
     */
    skip?: number
    distinct?: ApiKeyScalarFieldEnum | ApiKeyScalarFieldEnum[]
  }

  /**
   * ApiKey create
   */
  export type ApiKeyCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ApiKey
     */
    select?: ApiKeySelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ApiKeyInclude<ExtArgs> | null
    /**
     * The data needed to create a ApiKey.
     */
    data: XOR<ApiKeyCreateInput, ApiKeyUncheckedCreateInput>
  }

  /**
   * ApiKey createMany
   */
  export type ApiKeyCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many ApiKeys.
     */
    data: ApiKeyCreateManyInput | ApiKeyCreateManyInput[]
  }

  /**
   * ApiKey createManyAndReturn
   */
  export type ApiKeyCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ApiKey
     */
    select?: ApiKeySelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many ApiKeys.
     */
    data: ApiKeyCreateManyInput | ApiKeyCreateManyInput[]
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ApiKeyIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * ApiKey update
   */
  export type ApiKeyUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ApiKey
     */
    select?: ApiKeySelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ApiKeyInclude<ExtArgs> | null
    /**
     * The data needed to update a ApiKey.
     */
    data: XOR<ApiKeyUpdateInput, ApiKeyUncheckedUpdateInput>
    /**
     * Choose, which ApiKey to update.
     */
    where: ApiKeyWhereUniqueInput
  }

  /**
   * ApiKey updateMany
   */
  export type ApiKeyUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update ApiKeys.
     */
    data: XOR<ApiKeyUpdateManyMutationInput, ApiKeyUncheckedUpdateManyInput>
    /**
     * Filter which ApiKeys to update
     */
    where?: ApiKeyWhereInput
  }

  /**
   * ApiKey upsert
   */
  export type ApiKeyUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ApiKey
     */
    select?: ApiKeySelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ApiKeyInclude<ExtArgs> | null
    /**
     * The filter to search for the ApiKey to update in case it exists.
     */
    where: ApiKeyWhereUniqueInput
    /**
     * In case the ApiKey found by the `where` argument doesn't exist, create a new ApiKey with this data.
     */
    create: XOR<ApiKeyCreateInput, ApiKeyUncheckedCreateInput>
    /**
     * In case the ApiKey was found with the provided `where` argument, update it with this data.
     */
    update: XOR<ApiKeyUpdateInput, ApiKeyUncheckedUpdateInput>
  }

  /**
   * ApiKey delete
   */
  export type ApiKeyDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ApiKey
     */
    select?: ApiKeySelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ApiKeyInclude<ExtArgs> | null
    /**
     * Filter which ApiKey to delete.
     */
    where: ApiKeyWhereUniqueInput
  }

  /**
   * ApiKey deleteMany
   */
  export type ApiKeyDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which ApiKeys to delete
     */
    where?: ApiKeyWhereInput
  }

  /**
   * ApiKey.team
   */
  export type ApiKey$teamArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Team
     */
    select?: TeamSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TeamInclude<ExtArgs> | null
    where?: TeamWhereInput
  }

  /**
   * ApiKey without action
   */
  export type ApiKeyDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ApiKey
     */
    select?: ApiKeySelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ApiKeyInclude<ExtArgs> | null
  }


  /**
   * Model Team
   */

  export type AggregateTeam = {
    _count: TeamCountAggregateOutputType | null
    _min: TeamMinAggregateOutputType | null
    _max: TeamMaxAggregateOutputType | null
  }

  export type TeamMinAggregateOutputType = {
    id: string | null
    name: string | null
    createdAt: Date | null
  }

  export type TeamMaxAggregateOutputType = {
    id: string | null
    name: string | null
    createdAt: Date | null
  }

  export type TeamCountAggregateOutputType = {
    id: number
    name: number
    createdAt: number
    _all: number
  }


  export type TeamMinAggregateInputType = {
    id?: true
    name?: true
    createdAt?: true
  }

  export type TeamMaxAggregateInputType = {
    id?: true
    name?: true
    createdAt?: true
  }

  export type TeamCountAggregateInputType = {
    id?: true
    name?: true
    createdAt?: true
    _all?: true
  }

  export type TeamAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Team to aggregate.
     */
    where?: TeamWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Teams to fetch.
     */
    orderBy?: TeamOrderByWithRelationInput | TeamOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: TeamWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Teams from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Teams.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned Teams
    **/
    _count?: true | TeamCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: TeamMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: TeamMaxAggregateInputType
  }

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




  export type TeamGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: TeamWhereInput
    orderBy?: TeamOrderByWithAggregationInput | TeamOrderByWithAggregationInput[]
    by: TeamScalarFieldEnum[] | TeamScalarFieldEnum
    having?: TeamScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: TeamCountAggregateInputType | true
    _min?: TeamMinAggregateInputType
    _max?: TeamMaxAggregateInputType
  }

  export type TeamGroupByOutputType = {
    id: string
    name: string
    createdAt: Date
    _count: TeamCountAggregateOutputType | null
    _min: TeamMinAggregateOutputType | null
    _max: TeamMaxAggregateOutputType | null
  }

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


  export type TeamSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
    createdAt?: boolean
    devices?: boolean | Team$devicesArgs<ExtArgs>
    apiKeys?: boolean | Team$apiKeysArgs<ExtArgs>
    members?: boolean | Team$membersArgs<ExtArgs>
    _count?: boolean | TeamCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["team"]>

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

  export type TeamSelectScalar = {
    id?: boolean
    name?: boolean
    createdAt?: boolean
  }

  export type TeamInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    devices?: boolean | Team$devicesArgs<ExtArgs>
    apiKeys?: boolean | Team$apiKeysArgs<ExtArgs>
    members?: boolean | Team$membersArgs<ExtArgs>
    _count?: boolean | TeamCountOutputTypeDefaultArgs<ExtArgs>
  }
  export type TeamIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {}

  export type $TeamPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Team"
    objects: {
      devices: Prisma.$DevicePayload<ExtArgs>[]
      apiKeys: Prisma.$ApiKeyPayload<ExtArgs>[]
      members: Prisma.$TeamMemberPayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      name: string
      createdAt: Date
    }, ExtArgs["result"]["team"]>
    composites: {}
  }

  type TeamGetPayload<S extends boolean | null | undefined | TeamDefaultArgs> = $Result.GetResult<Prisma.$TeamPayload, S>

  type TeamCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<TeamFindManyArgs, 'select' | 'include' | 'distinct'> & {
      select?: TeamCountAggregateInputType | true
    }

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

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

    /**
     * Find the first Team that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {TeamFindFirstArgs} args - Arguments to find a Team
     * @example
     * // Get one Team
     * const team = await prisma.team.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends TeamFindFirstArgs>(args?: SelectSubset<T, TeamFindFirstArgs<ExtArgs>>): Prisma__TeamClient<$Result.GetResult<Prisma.$TeamPayload<ExtArgs>, T, "findFirst"> | null, null, ExtArgs>

    /**
     * Find the first Team that matches the filter or
     * throw `PrismaKnownClientError` with `P2025` code if no matches were found.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {TeamFindFirstOrThrowArgs} args - Arguments to find a Team
     * @example
     * // Get one Team
     * const team = await prisma.team.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends TeamFindFirstOrThrowArgs>(args?: SelectSubset<T, TeamFindFirstOrThrowArgs<ExtArgs>>): Prisma__TeamClient<$Result.GetResult<Prisma.$TeamPayload<ExtArgs>, T, "findFirstOrThrow">, never, ExtArgs>

    /**
     * Find zero or more Teams that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {TeamFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all Teams
     * const teams = await prisma.team.findMany()
     * 
     * // Get first 10 Teams
     * const teams = await prisma.team.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const teamWithIdOnly = await prisma.team.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends TeamFindManyArgs>(args?: SelectSubset<T, TeamFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$TeamPayload<ExtArgs>, T, "findMany">>

    /**
     * Create a Team.
     * @param {TeamCreateArgs} args - Arguments to create a Team.
     * @example
     * // Create one Team
     * const Team = await prisma.team.create({
     *   data: {
     *     // ... data to create a Team
     *   }
     * })
     * 
     */
    create<T extends TeamCreateArgs>(args: SelectSubset<T, TeamCreateArgs<ExtArgs>>): Prisma__TeamClient<$Result.GetResult<Prisma.$TeamPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

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

    /**
     * Delete a Team.
     * @param {TeamDeleteArgs} args - Arguments to delete one Team.
     * @example
     * // Delete one Team
     * const Team = await prisma.team.delete({
     *   where: {
     *     // ... filter to delete one Team
     *   }
     * })
     * 
     */
    delete<T extends TeamDeleteArgs>(args: SelectSubset<T, TeamDeleteArgs<ExtArgs>>): Prisma__TeamClient<$Result.GetResult<Prisma.$TeamPayload<ExtArgs>, T, "delete">, never, ExtArgs>

    /**
     * Update one Team.
     * @param {TeamUpdateArgs} args - Arguments to update one Team.
     * @example
     * // Update one Team
     * const team = await prisma.team.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends TeamUpdateArgs>(args: SelectSubset<T, TeamUpdateArgs<ExtArgs>>): Prisma__TeamClient<$Result.GetResult<Prisma.$TeamPayload<ExtArgs>, T, "update">, never, ExtArgs>

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

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

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


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

    /**
     * Allows you to perform aggregations operations on a Team.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {TeamAggregateArgs} args - Select which aggregations you would like to apply and on what fields.
     * @example
     * // Ordered by age ascending
     * // Where email contains prisma.io
     * // Limited to the 10 users
     * const aggregations = await prisma.user.aggregate({
     *   _avg: {
     *     age: true,
     *   },
     *   where: {
     *     email: {
     *       contains: "prisma.io",
     *     },
     *   },
     *   orderBy: {
     *     age: "asc",
     *   },
     *   take: 10,
     * })
    **/
    aggregate<T extends TeamAggregateArgs>(args: Subset<T, TeamAggregateArgs>): Prisma.PrismaPromise<GetTeamAggregateType<T>>

    /**
     * Group by Team.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {TeamGroupByArgs} args - Group by arguments.
     * @example
     * // Group by city, order by createdAt, get count
     * const result = await prisma.user.groupBy({
     *   by: ['city', 'createdAt'],
     *   orderBy: {
     *     createdAt: true
     *   },
     *   _count: {
     *     _all: true
     *   },
     * })
     * 
    **/
    groupBy<
      T extends TeamGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: TeamGroupByArgs['orderBy'] }
        : { orderBy?: TeamGroupByArgs['orderBy'] },
      OrderFields extends ExcludeUnderscoreKeys<Keys<MaybeTupleToUnion<T['orderBy']>>>,
      ByFields extends MaybeTupleToUnion<T['by']>,
      ByValid extends Has<ByFields, OrderFields>,
      HavingFields extends GetHavingFields<T['having']>,
      HavingValid extends Has<ByFields, HavingFields>,
      ByEmpty extends T['by'] extends never[] ? True : False,
      InputErrors extends ByEmpty extends True
      ? `Error: "by" must not be empty.`
      : HavingValid extends False
      ? {
          [P in HavingFields]: P extends ByFields
            ? never
            : P extends string
            ? `Error: Field "${P}" used in "having" needs to be provided in "by".`
            : [
                Error,
                'Field ',
                P,
                ` in "having" needs to be provided in "by"`,
              ]
        }[HavingFields]
      : 'take' extends Keys<T>
      ? 'orderBy' extends Keys<T>
        ? ByValid extends True
          ? {}
          : {
              [P in OrderFields]: P extends ByFields
                ? never
                : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
            }[OrderFields]
        : 'Error: If you provide "take", you also need to provide "orderBy"'
      : 'skip' extends Keys<T>
      ? 'orderBy' extends Keys<T>
        ? ByValid extends True
          ? {}
          : {
              [P in OrderFields]: P extends ByFields
                ? never
                : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
            }[OrderFields]
        : 'Error: If you provide "skip", you also need to provide "orderBy"'
      : ByValid extends True
      ? {}
      : {
          [P in OrderFields]: P extends ByFields
            ? never
            : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
        }[OrderFields]
    >(args: SubsetIntersection<T, TeamGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetTeamGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the Team model
   */
  readonly fields: TeamFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for Team.
   * Why is this prefixed with `Prisma__`?
   * Because we want to prevent naming conflicts as mentioned in
   * https://github.com/prisma/prisma-client-js/issues/707
   */
  export interface Prisma__TeamClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    devices<T extends Team$devicesArgs<ExtArgs> = {}>(args?: Subset<T, Team$devicesArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$DevicePayload<ExtArgs>, T, "findMany"> | Null>
    apiKeys<T extends Team$apiKeysArgs<ExtArgs> = {}>(args?: Subset<T, Team$apiKeysArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ApiKeyPayload<ExtArgs>, T, "findMany"> | Null>
    members<T extends Team$membersArgs<ExtArgs> = {}>(args?: Subset<T, Team$membersArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$TeamMemberPayload<ExtArgs>, T, "findMany"> | Null>
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
    /**
     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
     * resolved value cannot be modified from the callback.
     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
     * @returns A Promise for the completion of the callback.
     */
    finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
  }




  /**
   * Fields of the Team model
   */ 
  interface TeamFieldRefs {
    readonly id: FieldRef<"Team", 'String'>
    readonly name: FieldRef<"Team", 'String'>
    readonly createdAt: FieldRef<"Team", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * Team findUnique
   */
  export type TeamFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Team
     */
    select?: TeamSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TeamInclude<ExtArgs> | null
    /**
     * Filter, which Team to fetch.
     */
    where: TeamWhereUniqueInput
  }

  /**
   * Team findUniqueOrThrow
   */
  export type TeamFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Team
     */
    select?: TeamSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TeamInclude<ExtArgs> | null
    /**
     * Filter, which Team to fetch.
     */
    where: TeamWhereUniqueInput
  }

  /**
   * Team findFirst
   */
  export type TeamFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Team
     */
    select?: TeamSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TeamInclude<ExtArgs> | null
    /**
     * Filter, which Team to fetch.
     */
    where?: TeamWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Teams to fetch.
     */
    orderBy?: TeamOrderByWithRelationInput | TeamOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Teams.
     */
    cursor?: TeamWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Teams from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Teams.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Teams.
     */
    distinct?: TeamScalarFieldEnum | TeamScalarFieldEnum[]
  }

  /**
   * Team findFirstOrThrow
   */
  export type TeamFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Team
     */
    select?: TeamSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TeamInclude<ExtArgs> | null
    /**
     * Filter, which Team to fetch.
     */
    where?: TeamWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Teams to fetch.
     */
    orderBy?: TeamOrderByWithRelationInput | TeamOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Teams.
     */
    cursor?: TeamWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Teams from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Teams.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Teams.
     */
    distinct?: TeamScalarFieldEnum | TeamScalarFieldEnum[]
  }

  /**
   * Team findMany
   */
  export type TeamFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Team
     */
    select?: TeamSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TeamInclude<ExtArgs> | null
    /**
     * Filter, which Teams to fetch.
     */
    where?: TeamWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Teams to fetch.
     */
    orderBy?: TeamOrderByWithRelationInput | TeamOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing Teams.
     */
    cursor?: TeamWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Teams from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Teams.
     */
    skip?: number
    distinct?: TeamScalarFieldEnum | TeamScalarFieldEnum[]
  }

  /**
   * Team create
   */
  export type TeamCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Team
     */
    select?: TeamSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TeamInclude<ExtArgs> | null
    /**
     * The data needed to create a Team.
     */
    data: XOR<TeamCreateInput, TeamUncheckedCreateInput>
  }

  /**
   * Team createMany
   */
  export type TeamCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many Teams.
     */
    data: TeamCreateManyInput | TeamCreateManyInput[]
  }

  /**
   * Team createManyAndReturn
   */
  export type TeamCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Team
     */
    select?: TeamSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many Teams.
     */
    data: TeamCreateManyInput | TeamCreateManyInput[]
  }

  /**
   * Team update
   */
  export type TeamUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Team
     */
    select?: TeamSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TeamInclude<ExtArgs> | null
    /**
     * The data needed to update a Team.
     */
    data: XOR<TeamUpdateInput, TeamUncheckedUpdateInput>
    /**
     * Choose, which Team to update.
     */
    where: TeamWhereUniqueInput
  }

  /**
   * Team updateMany
   */
  export type TeamUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Teams.
     */
    data: XOR<TeamUpdateManyMutationInput, TeamUncheckedUpdateManyInput>
    /**
     * Filter which Teams to update
     */
    where?: TeamWhereInput
  }

  /**
   * Team upsert
   */
  export type TeamUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Team
     */
    select?: TeamSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TeamInclude<ExtArgs> | null
    /**
     * The filter to search for the Team to update in case it exists.
     */
    where: TeamWhereUniqueInput
    /**
     * In case the Team found by the `where` argument doesn't exist, create a new Team with this data.
     */
    create: XOR<TeamCreateInput, TeamUncheckedCreateInput>
    /**
     * In case the Team was found with the provided `where` argument, update it with this data.
     */
    update: XOR<TeamUpdateInput, TeamUncheckedUpdateInput>
  }

  /**
   * Team delete
   */
  export type TeamDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Team
     */
    select?: TeamSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TeamInclude<ExtArgs> | null
    /**
     * Filter which Team to delete.
     */
    where: TeamWhereUniqueInput
  }

  /**
   * Team deleteMany
   */
  export type TeamDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Teams to delete
     */
    where?: TeamWhereInput
  }

  /**
   * Team.devices
   */
  export type Team$devicesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Device
     */
    select?: DeviceSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: DeviceInclude<ExtArgs> | null
    where?: DeviceWhereInput
    orderBy?: DeviceOrderByWithRelationInput | DeviceOrderByWithRelationInput[]
    cursor?: DeviceWhereUniqueInput
    take?: number
    skip?: number
    distinct?: DeviceScalarFieldEnum | DeviceScalarFieldEnum[]
  }

  /**
   * Team.apiKeys
   */
  export type Team$apiKeysArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ApiKey
     */
    select?: ApiKeySelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ApiKeyInclude<ExtArgs> | null
    where?: ApiKeyWhereInput
    orderBy?: ApiKeyOrderByWithRelationInput | ApiKeyOrderByWithRelationInput[]
    cursor?: ApiKeyWhereUniqueInput
    take?: number
    skip?: number
    distinct?: ApiKeyScalarFieldEnum | ApiKeyScalarFieldEnum[]
  }

  /**
   * Team.members
   */
  export type Team$membersArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TeamMember
     */
    select?: TeamMemberSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TeamMemberInclude<ExtArgs> | null
    where?: TeamMemberWhereInput
    orderBy?: TeamMemberOrderByWithRelationInput | TeamMemberOrderByWithRelationInput[]
    cursor?: TeamMemberWhereUniqueInput
    take?: number
    skip?: number
    distinct?: TeamMemberScalarFieldEnum | TeamMemberScalarFieldEnum[]
  }

  /**
   * Team without action
   */
  export type TeamDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Team
     */
    select?: TeamSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TeamInclude<ExtArgs> | null
  }


  /**
   * Model SelectorState
   */

  export type AggregateSelectorState = {
    _count: SelectorStateCountAggregateOutputType | null
    _avg: SelectorStateAvgAggregateOutputType | null
    _sum: SelectorStateSumAggregateOutputType | null
    _min: SelectorStateMinAggregateOutputType | null
    _max: SelectorStateMaxAggregateOutputType | null
  }

  export type SelectorStateAvgAggregateOutputType = {
    regression_count: number | null
    clean_builds_count: number | null
  }

  export type SelectorStateSumAggregateOutputType = {
    regression_count: number | null
    clean_builds_count: number | null
  }

  export type SelectorStateMinAggregateOutputType = {
    id: string | null
    original_strategy: string | null
    original_selector: string | null
    status: string | null
    fixed_at: Date | null
    fixed_by_api_key: string | null
    resolved_at: Date | null
    muted_at: Date | null
    muted_by_api_key: string | null
    regression_count: number | null
    clean_builds_count: number | null
    last_event_at: Date | null
    createdAt: Date | null
    updatedAt: Date | null
  }

  export type SelectorStateMaxAggregateOutputType = {
    id: string | null
    original_strategy: string | null
    original_selector: string | null
    status: string | null
    fixed_at: Date | null
    fixed_by_api_key: string | null
    resolved_at: Date | null
    muted_at: Date | null
    muted_by_api_key: string | null
    regression_count: number | null
    clean_builds_count: number | null
    last_event_at: Date | null
    createdAt: Date | null
    updatedAt: Date | null
  }

  export type SelectorStateCountAggregateOutputType = {
    id: number
    original_strategy: number
    original_selector: number
    status: number
    fixed_at: number
    fixed_by_api_key: number
    resolved_at: number
    muted_at: number
    muted_by_api_key: number
    regression_count: number
    clean_builds_count: number
    last_event_at: number
    createdAt: number
    updatedAt: number
    _all: number
  }


  export type SelectorStateAvgAggregateInputType = {
    regression_count?: true
    clean_builds_count?: true
  }

  export type SelectorStateSumAggregateInputType = {
    regression_count?: true
    clean_builds_count?: true
  }

  export type SelectorStateMinAggregateInputType = {
    id?: true
    original_strategy?: true
    original_selector?: true
    status?: true
    fixed_at?: true
    fixed_by_api_key?: true
    resolved_at?: true
    muted_at?: true
    muted_by_api_key?: true
    regression_count?: true
    clean_builds_count?: true
    last_event_at?: true
    createdAt?: true
    updatedAt?: true
  }

  export type SelectorStateMaxAggregateInputType = {
    id?: true
    original_strategy?: true
    original_selector?: true
    status?: true
    fixed_at?: true
    fixed_by_api_key?: true
    resolved_at?: true
    muted_at?: true
    muted_by_api_key?: true
    regression_count?: true
    clean_builds_count?: true
    last_event_at?: true
    createdAt?: true
    updatedAt?: true
  }

  export type SelectorStateCountAggregateInputType = {
    id?: true
    original_strategy?: true
    original_selector?: true
    status?: true
    fixed_at?: true
    fixed_by_api_key?: true
    resolved_at?: true
    muted_at?: true
    muted_by_api_key?: true
    regression_count?: true
    clean_builds_count?: true
    last_event_at?: true
    createdAt?: true
    updatedAt?: true
    _all?: true
  }

  export type SelectorStateAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which SelectorState to aggregate.
     */
    where?: SelectorStateWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of SelectorStates to fetch.
     */
    orderBy?: SelectorStateOrderByWithRelationInput | SelectorStateOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: SelectorStateWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` SelectorStates 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` SelectorStates.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned SelectorStates
    **/
    _count?: true | SelectorStateCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: SelectorStateAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: SelectorStateSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: SelectorStateMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: SelectorStateMaxAggregateInputType
  }

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




  export type SelectorStateGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: SelectorStateWhereInput
    orderBy?: SelectorStateOrderByWithAggregationInput | SelectorStateOrderByWithAggregationInput[]
    by: SelectorStateScalarFieldEnum[] | SelectorStateScalarFieldEnum
    having?: SelectorStateScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: SelectorStateCountAggregateInputType | true
    _avg?: SelectorStateAvgAggregateInputType
    _sum?: SelectorStateSumAggregateInputType
    _min?: SelectorStateMinAggregateInputType
    _max?: SelectorStateMaxAggregateInputType
  }

  export type SelectorStateGroupByOutputType = {
    id: string
    original_strategy: string
    original_selector: string
    status: string
    fixed_at: Date | null
    fixed_by_api_key: string | null
    resolved_at: Date | null
    muted_at: Date | null
    muted_by_api_key: string | null
    regression_count: number
    clean_builds_count: number
    last_event_at: Date
    createdAt: Date
    updatedAt: Date
    _count: SelectorStateCountAggregateOutputType | null
    _avg: SelectorStateAvgAggregateOutputType | null
    _sum: SelectorStateSumAggregateOutputType | null
    _min: SelectorStateMinAggregateOutputType | null
    _max: SelectorStateMaxAggregateOutputType | null
  }

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


  export type SelectorStateSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    original_strategy?: boolean
    original_selector?: boolean
    status?: boolean
    fixed_at?: boolean
    fixed_by_api_key?: boolean
    resolved_at?: boolean
    muted_at?: boolean
    muted_by_api_key?: boolean
    regression_count?: boolean
    clean_builds_count?: boolean
    last_event_at?: boolean
    createdAt?: boolean
    updatedAt?: boolean
  }, ExtArgs["result"]["selectorState"]>

  export type SelectorStateSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    original_strategy?: boolean
    original_selector?: boolean
    status?: boolean
    fixed_at?: boolean
    fixed_by_api_key?: boolean
    resolved_at?: boolean
    muted_at?: boolean
    muted_by_api_key?: boolean
    regression_count?: boolean
    clean_builds_count?: boolean
    last_event_at?: boolean
    createdAt?: boolean
    updatedAt?: boolean
  }, ExtArgs["result"]["selectorState"]>

  export type SelectorStateSelectScalar = {
    id?: boolean
    original_strategy?: boolean
    original_selector?: boolean
    status?: boolean
    fixed_at?: boolean
    fixed_by_api_key?: boolean
    resolved_at?: boolean
    muted_at?: boolean
    muted_by_api_key?: boolean
    regression_count?: boolean
    clean_builds_count?: boolean
    last_event_at?: boolean
    createdAt?: boolean
    updatedAt?: boolean
  }


  export type $SelectorStatePayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "SelectorState"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: string
      original_strategy: string
      original_selector: string
      status: string
      fixed_at: Date | null
      fixed_by_api_key: string | null
      resolved_at: Date | null
      muted_at: Date | null
      muted_by_api_key: string | null
      regression_count: number
      clean_builds_count: number
      last_event_at: Date
      createdAt: Date
      updatedAt: Date
    }, ExtArgs["result"]["selectorState"]>
    composites: {}
  }

  type SelectorStateGetPayload<S extends boolean | null | undefined | SelectorStateDefaultArgs> = $Result.GetResult<Prisma.$SelectorStatePayload, S>

  type SelectorStateCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<SelectorStateFindManyArgs, 'select' | 'include' | 'distinct'> & {
      select?: SelectorStateCountAggregateInputType | true
    }

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

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

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

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

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

    /**
     * Create a SelectorState.
     * @param {SelectorStateCreateArgs} args - Arguments to create a SelectorState.
     * @example
     * // Create one SelectorState
     * const SelectorState = await prisma.selectorState.create({
     *   data: {
     *     // ... data to create a SelectorState
     *   }
     * })
     * 
     */
    create<T extends SelectorStateCreateArgs>(args: SelectSubset<T, SelectorStateCreateArgs<ExtArgs>>): Prisma__SelectorStateClient<$Result.GetResult<Prisma.$SelectorStatePayload<ExtArgs>, T, "create">, never, ExtArgs>

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

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

    /**
     * Delete a SelectorState.
     * @param {SelectorStateDeleteArgs} args - Arguments to delete one SelectorState.
     * @example
     * // Delete one SelectorState
     * const SelectorState = await prisma.selectorState.delete({
     *   where: {
     *     // ... filter to delete one SelectorState
     *   }
     * })
     * 
     */
    delete<T extends SelectorStateDeleteArgs>(args: SelectSubset<T, SelectorStateDeleteArgs<ExtArgs>>): Prisma__SelectorStateClient<$Result.GetResult<Prisma.$SelectorStatePayload<ExtArgs>, T, "delete">, never, ExtArgs>

    /**
     * Update one SelectorState.
     * @param {SelectorStateUpdateArgs} args - Arguments to update one SelectorState.
     * @example
     * // Update one SelectorState
     * const selectorState = await prisma.selectorState.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends SelectorStateUpdateArgs>(args: SelectSubset<T, SelectorStateUpdateArgs<ExtArgs>>): Prisma__SelectorStateClient<$Result.GetResult<Prisma.$SelectorStatePayload<ExtArgs>, T, "update">, never, ExtArgs>

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

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

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for SelectorState.
   * 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__SelectorStateClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
    /**
     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
     * resolved value cannot be modified from the callback.
     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
     * @returns A Promise for the completion of the callback.
     */
    finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
  }




  /**
   * Fields of the SelectorState model
   */ 
  interface SelectorStateFieldRefs {
    readonly id: FieldRef<"SelectorState", 'String'>
    readonly original_strategy: FieldRef<"SelectorState", 'String'>
    readonly original_selector: FieldRef<"SelectorState", 'String'>
    readonly status: FieldRef<"SelectorState", 'String'>
    readonly fixed_at: FieldRef<"SelectorState", 'DateTime'>
    readonly fixed_by_api_key: FieldRef<"SelectorState", 'String'>
    readonly resolved_at: FieldRef<"SelectorState", 'DateTime'>
    readonly muted_at: FieldRef<"SelectorState", 'DateTime'>
    readonly muted_by_api_key: FieldRef<"SelectorState", 'String'>
    readonly regression_count: FieldRef<"SelectorState", 'Int'>
    readonly clean_builds_count: FieldRef<"SelectorState", 'Int'>
    readonly last_event_at: FieldRef<"SelectorState", 'DateTime'>
    readonly createdAt: FieldRef<"SelectorState", 'DateTime'>
    readonly updatedAt: FieldRef<"SelectorState", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * SelectorState findUnique
   */
  export type SelectorStateFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the SelectorState
     */
    select?: SelectorStateSelect<ExtArgs> | null
    /**
     * Filter, which SelectorState to fetch.
     */
    where: SelectorStateWhereUniqueInput
  }

  /**
   * SelectorState findUniqueOrThrow
   */
  export type SelectorStateFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the SelectorState
     */
    select?: SelectorStateSelect<ExtArgs> | null
    /**
     * Filter, which SelectorState to fetch.
     */
    where: SelectorStateWhereUniqueInput
  }

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

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

  /**
   * SelectorState findMany
   */
  export type SelectorStateFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the SelectorState
     */
    select?: SelectorStateSelect<ExtArgs> | null
    /**
     * Filter, which SelectorStates to fetch.
     */
    where?: SelectorStateWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of SelectorStates to fetch.
     */
    orderBy?: SelectorStateOrderByWithRelationInput | SelectorStateOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing SelectorStates.
     */
    cursor?: SelectorStateWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` SelectorStates 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` SelectorStates.
     */
    skip?: number
    distinct?: SelectorStateScalarFieldEnum | SelectorStateScalarFieldEnum[]
  }

  /**
   * SelectorState create
   */
  export type SelectorStateCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the SelectorState
     */
    select?: SelectorStateSelect<ExtArgs> | null
    /**
     * The data needed to create a SelectorState.
     */
    data: XOR<SelectorStateCreateInput, SelectorStateUncheckedCreateInput>
  }

  /**
   * SelectorState createMany
   */
  export type SelectorStateCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many SelectorStates.
     */
    data: SelectorStateCreateManyInput | SelectorStateCreateManyInput[]
  }

  /**
   * SelectorState createManyAndReturn
   */
  export type SelectorStateCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the SelectorState
     */
    select?: SelectorStateSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many SelectorStates.
     */
    data: SelectorStateCreateManyInput | SelectorStateCreateManyInput[]
  }

  /**
   * SelectorState update
   */
  export type SelectorStateUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the SelectorState
     */
    select?: SelectorStateSelect<ExtArgs> | null
    /**
     * The data needed to update a SelectorState.
     */
    data: XOR<SelectorStateUpdateInput, SelectorStateUncheckedUpdateInput>
    /**
     * Choose, which SelectorState to update.
     */
    where: SelectorStateWhereUniqueInput
  }

  /**
   * SelectorState updateMany
   */
  export type SelectorStateUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update SelectorStates.
     */
    data: XOR<SelectorStateUpdateManyMutationInput, SelectorStateUncheckedUpdateManyInput>
    /**
     * Filter which SelectorStates to update
     */
    where?: SelectorStateWhereInput
  }

  /**
   * SelectorState upsert
   */
  export type SelectorStateUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the SelectorState
     */
    select?: SelectorStateSelect<ExtArgs> | null
    /**
     * The filter to search for the SelectorState to update in case it exists.
     */
    where: SelectorStateWhereUniqueInput
    /**
     * In case the SelectorState found by the `where` argument doesn't exist, create a new SelectorState with this data.
     */
    create: XOR<SelectorStateCreateInput, SelectorStateUncheckedCreateInput>
    /**
     * In case the SelectorState was found with the provided `where` argument, update it with this data.
     */
    update: XOR<SelectorStateUpdateInput, SelectorStateUncheckedUpdateInput>
  }

  /**
   * SelectorState delete
   */
  export type SelectorStateDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the SelectorState
     */
    select?: SelectorStateSelect<ExtArgs> | null
    /**
     * Filter which SelectorState to delete.
     */
    where: SelectorStateWhereUniqueInput
  }

  /**
   * SelectorState deleteMany
   */
  export type SelectorStateDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which SelectorStates to delete
     */
    where?: SelectorStateWhereInput
  }

  /**
   * SelectorState without action
   */
  export type SelectorStateDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the SelectorState
     */
    select?: SelectorStateSelect<ExtArgs> | null
  }


  /**
   * Model Recording
   */

  export type AggregateRecording = {
    _count: RecordingCountAggregateOutputType | null
    _avg: RecordingAvgAggregateOutputType | null
    _sum: RecordingSumAggregateOutputType | null
    _min: RecordingMinAggregateOutputType | null
    _max: RecordingMaxAggregateOutputType | null
  }

  export type RecordingAvgAggregateOutputType = {
    duration_ms: number | null
    size_bytes: number | null
  }

  export type RecordingSumAggregateOutputType = {
    duration_ms: number | null
    size_bytes: number | null
  }

  export type RecordingMinAggregateOutputType = {
    id: string | null
    group_id: string | null
    device_udid: string | null
    device_host: string | null
    session_id: string | null
    started_at: Date | null
    ended_at: Date | null
    status: string | null
    file_path: string | null
    duration_ms: number | null
    size_bytes: number | null
    device_snapshot: string | null
    fail_reason: string | null
  }

  export type RecordingMaxAggregateOutputType = {
    id: string | null
    group_id: string | null
    device_udid: string | null
    device_host: string | null
    session_id: string | null
    started_at: Date | null
    ended_at: Date | null
    status: string | null
    file_path: string | null
    duration_ms: number | null
    size_bytes: number | null
    device_snapshot: string | null
    fail_reason: string | null
  }

  export type RecordingCountAggregateOutputType = {
    id: number
    group_id: number
    device_udid: number
    device_host: number
    session_id: number
    started_at: number
    ended_at: number
    status: number
    file_path: number
    duration_ms: number
    size_bytes: number
    device_snapshot: number
    fail_reason: number
    _all: number
  }


  export type RecordingAvgAggregateInputType = {
    duration_ms?: true
    size_bytes?: true
  }

  export type RecordingSumAggregateInputType = {
    duration_ms?: true
    size_bytes?: true
  }

  export type RecordingMinAggregateInputType = {
    id?: true
    group_id?: true
    device_udid?: true
    device_host?: true
    session_id?: true
    started_at?: true
    ended_at?: true
    status?: true
    file_path?: true
    duration_ms?: true
    size_bytes?: true
    device_snapshot?: true
    fail_reason?: true
  }

  export type RecordingMaxAggregateInputType = {
    id?: true
    group_id?: true
    device_udid?: true
    device_host?: true
    session_id?: true
    started_at?: true
    ended_at?: true
    status?: true
    file_path?: true
    duration_ms?: true
    size_bytes?: true
    device_snapshot?: true
    fail_reason?: true
  }

  export type RecordingCountAggregateInputType = {
    id?: true
    group_id?: true
    device_udid?: true
    device_host?: true
    session_id?: true
    started_at?: true
    ended_at?: true
    status?: true
    file_path?: true
    duration_ms?: true
    size_bytes?: true
    device_snapshot?: true
    fail_reason?: true
    _all?: true
  }

  export type RecordingAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Recording to aggregate.
     */
    where?: RecordingWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Recordings to fetch.
     */
    orderBy?: RecordingOrderByWithRelationInput | RecordingOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: RecordingWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Recordings 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` Recordings.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned Recordings
    **/
    _count?: true | RecordingCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: RecordingAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: RecordingSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: RecordingMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: RecordingMaxAggregateInputType
  }

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




  export type RecordingGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: RecordingWhereInput
    orderBy?: RecordingOrderByWithAggregationInput | RecordingOrderByWithAggregationInput[]
    by: RecordingScalarFieldEnum[] | RecordingScalarFieldEnum
    having?: RecordingScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: RecordingCountAggregateInputType | true
    _avg?: RecordingAvgAggregateInputType
    _sum?: RecordingSumAggregateInputType
    _min?: RecordingMinAggregateInputType
    _max?: RecordingMaxAggregateInputType
  }

  export type RecordingGroupByOutputType = {
    id: string
    group_id: string
    device_udid: string
    device_host: string
    session_id: string | null
    started_at: Date
    ended_at: Date | null
    status: string
    file_path: string
    duration_ms: number | null
    size_bytes: number | null
    device_snapshot: string | null
    fail_reason: string | null
    _count: RecordingCountAggregateOutputType | null
    _avg: RecordingAvgAggregateOutputType | null
    _sum: RecordingSumAggregateOutputType | null
    _min: RecordingMinAggregateOutputType | null
    _max: RecordingMaxAggregateOutputType | null
  }

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


  export type RecordingSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    group_id?: boolean
    device_udid?: boolean
    device_host?: boolean
    session_id?: boolean
    started_at?: boolean
    ended_at?: boolean
    status?: boolean
    file_path?: boolean
    duration_ms?: boolean
    size_bytes?: boolean
    device_snapshot?: boolean
    fail_reason?: boolean
    bookmarks?: boolean | Recording$bookmarksArgs<ExtArgs>
    annotations?: boolean | Recording$annotationsArgs<ExtArgs>
    Session?: boolean | Recording$SessionArgs<ExtArgs>
    _count?: boolean | RecordingCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["recording"]>

  export type RecordingSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    group_id?: boolean
    device_udid?: boolean
    device_host?: boolean
    session_id?: boolean
    started_at?: boolean
    ended_at?: boolean
    status?: boolean
    file_path?: boolean
    duration_ms?: boolean
    size_bytes?: boolean
    device_snapshot?: boolean
    fail_reason?: boolean
    Session?: boolean | Recording$SessionArgs<ExtArgs>
  }, ExtArgs["result"]["recording"]>

  export type RecordingSelectScalar = {
    id?: boolean
    group_id?: boolean
    device_udid?: boolean
    device_host?: boolean
    session_id?: boolean
    started_at?: boolean
    ended_at?: boolean
    status?: boolean
    file_path?: boolean
    duration_ms?: boolean
    size_bytes?: boolean
    device_snapshot?: boolean
    fail_reason?: boolean
  }

  export type RecordingInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    bookmarks?: boolean | Recording$bookmarksArgs<ExtArgs>
    annotations?: boolean | Recording$annotationsArgs<ExtArgs>
    Session?: boolean | Recording$SessionArgs<ExtArgs>
    _count?: boolean | RecordingCountOutputTypeDefaultArgs<ExtArgs>
  }
  export type RecordingIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    Session?: boolean | Recording$SessionArgs<ExtArgs>
  }

  export type $RecordingPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Recording"
    objects: {
      bookmarks: Prisma.$BookmarkPayload<ExtArgs>[]
      annotations: Prisma.$AnnotationPayload<ExtArgs>[]
      Session: Prisma.$SessionPayload<ExtArgs> | null
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      group_id: string
      device_udid: string
      device_host: string
      session_id: string | null
      started_at: Date
      ended_at: Date | null
      status: string
      file_path: string
      duration_ms: number | null
      size_bytes: number | null
      device_snapshot: string | null
      fail_reason: string | null
    }, ExtArgs["result"]["recording"]>
    composites: {}
  }

  type RecordingGetPayload<S extends boolean | null | undefined | RecordingDefaultArgs> = $Result.GetResult<Prisma.$RecordingPayload, S>

  type RecordingCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<RecordingFindManyArgs, 'select' | 'include' | 'distinct'> & {
      select?: RecordingCountAggregateInputType | true
    }

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

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

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

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

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

    /**
     * Create a Recording.
     * @param {RecordingCreateArgs} args - Arguments to create a Recording.
     * @example
     * // Create one Recording
     * const Recording = await prisma.recording.create({
     *   data: {
     *     // ... data to create a Recording
     *   }
     * })
     * 
     */
    create<T extends RecordingCreateArgs>(args: SelectSubset<T, RecordingCreateArgs<ExtArgs>>): Prisma__RecordingClient<$Result.GetResult<Prisma.$RecordingPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

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

    /**
     * Delete a Recording.
     * @param {RecordingDeleteArgs} args - Arguments to delete one Recording.
     * @example
     * // Delete one Recording
     * const Recording = await prisma.recording.delete({
     *   where: {
     *     // ... filter to delete one Recording
     *   }
     * })
     * 
     */
    delete<T extends RecordingDeleteArgs>(args: SelectSubset<T, RecordingDeleteArgs<ExtArgs>>): Prisma__RecordingClient<$Result.GetResult<Prisma.$RecordingPayload<ExtArgs>, T, "delete">, never, ExtArgs>

    /**
     * Update one Recording.
     * @param {RecordingUpdateArgs} args - Arguments to update one Recording.
     * @example
     * // Update one Recording
     * const recording = await prisma.recording.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends RecordingUpdateArgs>(args: SelectSubset<T, RecordingUpdateArgs<ExtArgs>>): Prisma__RecordingClient<$Result.GetResult<Prisma.$RecordingPayload<ExtArgs>, T, "update">, never, ExtArgs>

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

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

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for Recording.
   * 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__RecordingClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    bookmarks<T extends Recording$bookmarksArgs<ExtArgs> = {}>(args?: Subset<T, Recording$bookmarksArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$BookmarkPayload<ExtArgs>, T, "findMany"> | Null>
    annotations<T extends Recording$annotationsArgs<ExtArgs> = {}>(args?: Subset<T, Recording$annotationsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$AnnotationPayload<ExtArgs>, T, "findMany"> | Null>
    Session<T extends Recording$SessionArgs<ExtArgs> = {}>(args?: Subset<T, Recording$SessionArgs<ExtArgs>>): Prisma__SessionClient<$Result.GetResult<Prisma.$SessionPayload<ExtArgs>, T, "findUniqueOrThrow"> | null, null, ExtArgs>
    /**
     * 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 Recording model
   */ 
  interface RecordingFieldRefs {
    readonly id: FieldRef<"Recording", 'String'>
    readonly group_id: FieldRef<"Recording", 'String'>
    readonly device_udid: FieldRef<"Recording", 'String'>
    readonly device_host: FieldRef<"Recording", 'String'>
    readonly session_id: FieldRef<"Recording", 'String'>
    readonly started_at: FieldRef<"Recording", 'DateTime'>
    readonly ended_at: FieldRef<"Recording", 'DateTime'>
    readonly status: FieldRef<"Recording", 'String'>
    readonly file_path: FieldRef<"Recording", 'String'>
    readonly duration_ms: FieldRef<"Recording", 'Int'>
    readonly size_bytes: FieldRef<"Recording", 'Int'>
    readonly device_snapshot: FieldRef<"Recording", 'String'>
    readonly fail_reason: FieldRef<"Recording", 'String'>
  }
    

  // Custom InputTypes
  /**
   * Recording findUnique
   */
  export type RecordingFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Recording
     */
    select?: RecordingSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: RecordingInclude<ExtArgs> | null
    /**
     * Filter, which Recording to fetch.
     */
    where: RecordingWhereUniqueInput
  }

  /**
   * Recording findUniqueOrThrow
   */
  export type RecordingFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Recording
     */
    select?: RecordingSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: RecordingInclude<ExtArgs> | null
    /**
     * Filter, which Recording to fetch.
     */
    where: RecordingWhereUniqueInput
  }

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

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

  /**
   * Recording findMany
   */
  export type RecordingFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Recording
     */
    select?: RecordingSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: RecordingInclude<ExtArgs> | null
    /**
     * Filter, which Recordings to fetch.
     */
    where?: RecordingWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Recordings to fetch.
     */
    orderBy?: RecordingOrderByWithRelationInput | RecordingOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing Recordings.
     */
    cursor?: RecordingWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Recordings 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` Recordings.
     */
    skip?: number
    distinct?: RecordingScalarFieldEnum | RecordingScalarFieldEnum[]
  }

  /**
   * Recording create
   */
  export type RecordingCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Recording
     */
    select?: RecordingSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: RecordingInclude<ExtArgs> | null
    /**
     * The data needed to create a Recording.
     */
    data: XOR<RecordingCreateInput, RecordingUncheckedCreateInput>
  }

  /**
   * Recording createMany
   */
  export type RecordingCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many Recordings.
     */
    data: RecordingCreateManyInput | RecordingCreateManyInput[]
  }

  /**
   * Recording createManyAndReturn
   */
  export type RecordingCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Recording
     */
    select?: RecordingSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many Recordings.
     */
    data: RecordingCreateManyInput | RecordingCreateManyInput[]
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: RecordingIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * Recording update
   */
  export type RecordingUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Recording
     */
    select?: RecordingSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: RecordingInclude<ExtArgs> | null
    /**
     * The data needed to update a Recording.
     */
    data: XOR<RecordingUpdateInput, RecordingUncheckedUpdateInput>
    /**
     * Choose, which Recording to update.
     */
    where: RecordingWhereUniqueInput
  }

  /**
   * Recording updateMany
   */
  export type RecordingUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Recordings.
     */
    data: XOR<RecordingUpdateManyMutationInput, RecordingUncheckedUpdateManyInput>
    /**
     * Filter which Recordings to update
     */
    where?: RecordingWhereInput
  }

  /**
   * Recording upsert
   */
  export type RecordingUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Recording
     */
    select?: RecordingSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: RecordingInclude<ExtArgs> | null
    /**
     * The filter to search for the Recording to update in case it exists.
     */
    where: RecordingWhereUniqueInput
    /**
     * In case the Recording found by the `where` argument doesn't exist, create a new Recording with this data.
     */
    create: XOR<RecordingCreateInput, RecordingUncheckedCreateInput>
    /**
     * In case the Recording was found with the provided `where` argument, update it with this data.
     */
    update: XOR<RecordingUpdateInput, RecordingUncheckedUpdateInput>
  }

  /**
   * Recording delete
   */
  export type RecordingDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Recording
     */
    select?: RecordingSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: RecordingInclude<ExtArgs> | null
    /**
     * Filter which Recording to delete.
     */
    where: RecordingWhereUniqueInput
  }

  /**
   * Recording deleteMany
   */
  export type RecordingDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Recordings to delete
     */
    where?: RecordingWhereInput
  }

  /**
   * Recording.bookmarks
   */
  export type Recording$bookmarksArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Bookmark
     */
    select?: BookmarkSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: BookmarkInclude<ExtArgs> | null
    where?: BookmarkWhereInput
    orderBy?: BookmarkOrderByWithRelationInput | BookmarkOrderByWithRelationInput[]
    cursor?: BookmarkWhereUniqueInput
    take?: number
    skip?: number
    distinct?: BookmarkScalarFieldEnum | BookmarkScalarFieldEnum[]
  }

  /**
   * Recording.annotations
   */
  export type Recording$annotationsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Annotation
     */
    select?: AnnotationSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AnnotationInclude<ExtArgs> | null
    where?: AnnotationWhereInput
    orderBy?: AnnotationOrderByWithRelationInput | AnnotationOrderByWithRelationInput[]
    cursor?: AnnotationWhereUniqueInput
    take?: number
    skip?: number
    distinct?: AnnotationScalarFieldEnum | AnnotationScalarFieldEnum[]
  }

  /**
   * Recording.Session
   */
  export type Recording$SessionArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Session
     */
    select?: SessionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SessionInclude<ExtArgs> | null
    where?: SessionWhereInput
  }

  /**
   * Recording without action
   */
  export type RecordingDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Recording
     */
    select?: RecordingSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: RecordingInclude<ExtArgs> | null
  }


  /**
   * Model Bookmark
   */

  export type AggregateBookmark = {
    _count: BookmarkCountAggregateOutputType | null
    _avg: BookmarkAvgAggregateOutputType | null
    _sum: BookmarkSumAggregateOutputType | null
    _min: BookmarkMinAggregateOutputType | null
    _max: BookmarkMaxAggregateOutputType | null
  }

  export type BookmarkAvgAggregateOutputType = {
    timecode_ms: number | null
  }

  export type BookmarkSumAggregateOutputType = {
    timecode_ms: number | null
  }

  export type BookmarkMinAggregateOutputType = {
    id: string | null
    recording_id: string | null
    timecode_ms: number | null
    label: string | null
    note: string | null
    created_at: Date | null
  }

  export type BookmarkMaxAggregateOutputType = {
    id: string | null
    recording_id: string | null
    timecode_ms: number | null
    label: string | null
    note: string | null
    created_at: Date | null
  }

  export type BookmarkCountAggregateOutputType = {
    id: number
    recording_id: number
    timecode_ms: number
    label: number
    note: number
    created_at: number
    _all: number
  }


  export type BookmarkAvgAggregateInputType = {
    timecode_ms?: true
  }

  export type BookmarkSumAggregateInputType = {
    timecode_ms?: true
  }

  export type BookmarkMinAggregateInputType = {
    id?: true
    recording_id?: true
    timecode_ms?: true
    label?: true
    note?: true
    created_at?: true
  }

  export type BookmarkMaxAggregateInputType = {
    id?: true
    recording_id?: true
    timecode_ms?: true
    label?: true
    note?: true
    created_at?: true
  }

  export type BookmarkCountAggregateInputType = {
    id?: true
    recording_id?: true
    timecode_ms?: true
    label?: true
    note?: true
    created_at?: true
    _all?: true
  }

  export type BookmarkAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Bookmark to aggregate.
     */
    where?: BookmarkWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Bookmarks to fetch.
     */
    orderBy?: BookmarkOrderByWithRelationInput | BookmarkOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: BookmarkWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Bookmarks 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` Bookmarks.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned Bookmarks
    **/
    _count?: true | BookmarkCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: BookmarkAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: BookmarkSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: BookmarkMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: BookmarkMaxAggregateInputType
  }

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




  export type BookmarkGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: BookmarkWhereInput
    orderBy?: BookmarkOrderByWithAggregationInput | BookmarkOrderByWithAggregationInput[]
    by: BookmarkScalarFieldEnum[] | BookmarkScalarFieldEnum
    having?: BookmarkScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: BookmarkCountAggregateInputType | true
    _avg?: BookmarkAvgAggregateInputType
    _sum?: BookmarkSumAggregateInputType
    _min?: BookmarkMinAggregateInputType
    _max?: BookmarkMaxAggregateInputType
  }

  export type BookmarkGroupByOutputType = {
    id: string
    recording_id: string
    timecode_ms: number
    label: string
    note: string | null
    created_at: Date
    _count: BookmarkCountAggregateOutputType | null
    _avg: BookmarkAvgAggregateOutputType | null
    _sum: BookmarkSumAggregateOutputType | null
    _min: BookmarkMinAggregateOutputType | null
    _max: BookmarkMaxAggregateOutputType | null
  }

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


  export type BookmarkSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    recording_id?: boolean
    timecode_ms?: boolean
    label?: boolean
    note?: boolean
    created_at?: boolean
    Recording?: boolean | RecordingDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["bookmark"]>

  export type BookmarkSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    recording_id?: boolean
    timecode_ms?: boolean
    label?: boolean
    note?: boolean
    created_at?: boolean
    Recording?: boolean | RecordingDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["bookmark"]>

  export type BookmarkSelectScalar = {
    id?: boolean
    recording_id?: boolean
    timecode_ms?: boolean
    label?: boolean
    note?: boolean
    created_at?: boolean
  }

  export type BookmarkInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    Recording?: boolean | RecordingDefaultArgs<ExtArgs>
  }
  export type BookmarkIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    Recording?: boolean | RecordingDefaultArgs<ExtArgs>
  }

  export type $BookmarkPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Bookmark"
    objects: {
      Recording: Prisma.$RecordingPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      recording_id: string
      timecode_ms: number
      label: string
      note: string | null
      created_at: Date
    }, ExtArgs["result"]["bookmark"]>
    composites: {}
  }

  type BookmarkGetPayload<S extends boolean | null | undefined | BookmarkDefaultArgs> = $Result.GetResult<Prisma.$BookmarkPayload, S>

  type BookmarkCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<BookmarkFindManyArgs, 'select' | 'include' | 'distinct'> & {
      select?: BookmarkCountAggregateInputType | true
    }

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

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

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

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

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

    /**
     * Create a Bookmark.
     * @param {BookmarkCreateArgs} args - Arguments to create a Bookmark.
     * @example
     * // Create one Bookmark
     * const Bookmark = await prisma.bookmark.create({
     *   data: {
     *     // ... data to create a Bookmark
     *   }
     * })
     * 
     */
    create<T extends BookmarkCreateArgs>(args: SelectSubset<T, BookmarkCreateArgs<ExtArgs>>): Prisma__BookmarkClient<$Result.GetResult<Prisma.$BookmarkPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

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

    /**
     * Delete a Bookmark.
     * @param {BookmarkDeleteArgs} args - Arguments to delete one Bookmark.
     * @example
     * // Delete one Bookmark
     * const Bookmark = await prisma.bookmark.delete({
     *   where: {
     *     // ... filter to delete one Bookmark
     *   }
     * })
     * 
     */
    delete<T extends BookmarkDeleteArgs>(args: SelectSubset<T, BookmarkDeleteArgs<ExtArgs>>): Prisma__BookmarkClient<$Result.GetResult<Prisma.$BookmarkPayload<ExtArgs>, T, "delete">, never, ExtArgs>

    /**
     * Update one Bookmark.
     * @param {BookmarkUpdateArgs} args - Arguments to update one Bookmark.
     * @example
     * // Update one Bookmark
     * const bookmark = await prisma.bookmark.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends BookmarkUpdateArgs>(args: SelectSubset<T, BookmarkUpdateArgs<ExtArgs>>): Prisma__BookmarkClient<$Result.GetResult<Prisma.$BookmarkPayload<ExtArgs>, T, "update">, never, ExtArgs>

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

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

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for Bookmark.
   * 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__BookmarkClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    Recording<T extends RecordingDefaultArgs<ExtArgs> = {}>(args?: Subset<T, RecordingDefaultArgs<ExtArgs>>): Prisma__RecordingClient<$Result.GetResult<Prisma.$RecordingPayload<ExtArgs>, T, "findUniqueOrThrow"> | Null, Null, ExtArgs>
    /**
     * 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 Bookmark model
   */ 
  interface BookmarkFieldRefs {
    readonly id: FieldRef<"Bookmark", 'String'>
    readonly recording_id: FieldRef<"Bookmark", 'String'>
    readonly timecode_ms: FieldRef<"Bookmark", 'Int'>
    readonly label: FieldRef<"Bookmark", 'String'>
    readonly note: FieldRef<"Bookmark", 'String'>
    readonly created_at: FieldRef<"Bookmark", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * Bookmark findUnique
   */
  export type BookmarkFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Bookmark
     */
    select?: BookmarkSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: BookmarkInclude<ExtArgs> | null
    /**
     * Filter, which Bookmark to fetch.
     */
    where: BookmarkWhereUniqueInput
  }

  /**
   * Bookmark findUniqueOrThrow
   */
  export type BookmarkFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Bookmark
     */
    select?: BookmarkSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: BookmarkInclude<ExtArgs> | null
    /**
     * Filter, which Bookmark to fetch.
     */
    where: BookmarkWhereUniqueInput
  }

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

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

  /**
   * Bookmark findMany
   */
  export type BookmarkFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Bookmark
     */
    select?: BookmarkSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: BookmarkInclude<ExtArgs> | null
    /**
     * Filter, which Bookmarks to fetch.
     */
    where?: BookmarkWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Bookmarks to fetch.
     */
    orderBy?: BookmarkOrderByWithRelationInput | BookmarkOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing Bookmarks.
     */
    cursor?: BookmarkWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Bookmarks 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` Bookmarks.
     */
    skip?: number
    distinct?: BookmarkScalarFieldEnum | BookmarkScalarFieldEnum[]
  }

  /**
   * Bookmark create
   */
  export type BookmarkCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Bookmark
     */
    select?: BookmarkSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: BookmarkInclude<ExtArgs> | null
    /**
     * The data needed to create a Bookmark.
     */
    data: XOR<BookmarkCreateInput, BookmarkUncheckedCreateInput>
  }

  /**
   * Bookmark createMany
   */
  export type BookmarkCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many Bookmarks.
     */
    data: BookmarkCreateManyInput | BookmarkCreateManyInput[]
  }

  /**
   * Bookmark createManyAndReturn
   */
  export type BookmarkCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Bookmark
     */
    select?: BookmarkSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many Bookmarks.
     */
    data: BookmarkCreateManyInput | BookmarkCreateManyInput[]
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: BookmarkIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * Bookmark update
   */
  export type BookmarkUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Bookmark
     */
    select?: BookmarkSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: BookmarkInclude<ExtArgs> | null
    /**
     * The data needed to update a Bookmark.
     */
    data: XOR<BookmarkUpdateInput, BookmarkUncheckedUpdateInput>
    /**
     * Choose, which Bookmark to update.
     */
    where: BookmarkWhereUniqueInput
  }

  /**
   * Bookmark updateMany
   */
  export type BookmarkUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Bookmarks.
     */
    data: XOR<BookmarkUpdateManyMutationInput, BookmarkUncheckedUpdateManyInput>
    /**
     * Filter which Bookmarks to update
     */
    where?: BookmarkWhereInput
  }

  /**
   * Bookmark upsert
   */
  export type BookmarkUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Bookmark
     */
    select?: BookmarkSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: BookmarkInclude<ExtArgs> | null
    /**
     * The filter to search for the Bookmark to update in case it exists.
     */
    where: BookmarkWhereUniqueInput
    /**
     * In case the Bookmark found by the `where` argument doesn't exist, create a new Bookmark with this data.
     */
    create: XOR<BookmarkCreateInput, BookmarkUncheckedCreateInput>
    /**
     * In case the Bookmark was found with the provided `where` argument, update it with this data.
     */
    update: XOR<BookmarkUpdateInput, BookmarkUncheckedUpdateInput>
  }

  /**
   * Bookmark delete
   */
  export type BookmarkDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Bookmark
     */
    select?: BookmarkSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: BookmarkInclude<ExtArgs> | null
    /**
     * Filter which Bookmark to delete.
     */
    where: BookmarkWhereUniqueInput
  }

  /**
   * Bookmark deleteMany
   */
  export type BookmarkDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Bookmarks to delete
     */
    where?: BookmarkWhereInput
  }

  /**
   * Bookmark without action
   */
  export type BookmarkDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Bookmark
     */
    select?: BookmarkSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: BookmarkInclude<ExtArgs> | null
  }


  /**
   * Model Annotation
   */

  export type AggregateAnnotation = {
    _count: AnnotationCountAggregateOutputType | null
    _avg: AnnotationAvgAggregateOutputType | null
    _sum: AnnotationSumAggregateOutputType | null
    _min: AnnotationMinAggregateOutputType | null
    _max: AnnotationMaxAggregateOutputType | null
  }

  export type AnnotationAvgAggregateOutputType = {
    timecode_ms: number | null
  }

  export type AnnotationSumAggregateOutputType = {
    timecode_ms: number | null
  }

  export type AnnotationMinAggregateOutputType = {
    id: string | null
    recording_id: string | null
    timecode_ms: number | null
    shape: string | null
    geometry: string | null
    color: string | null
    text: string | null
    author: string | null
    created_at: Date | null
  }

  export type AnnotationMaxAggregateOutputType = {
    id: string | null
    recording_id: string | null
    timecode_ms: number | null
    shape: string | null
    geometry: string | null
    color: string | null
    text: string | null
    author: string | null
    created_at: Date | null
  }

  export type AnnotationCountAggregateOutputType = {
    id: number
    recording_id: number
    timecode_ms: number
    shape: number
    geometry: number
    color: number
    text: number
    author: number
    created_at: number
    _all: number
  }


  export type AnnotationAvgAggregateInputType = {
    timecode_ms?: true
  }

  export type AnnotationSumAggregateInputType = {
    timecode_ms?: true
  }

  export type AnnotationMinAggregateInputType = {
    id?: true
    recording_id?: true
    timecode_ms?: true
    shape?: true
    geometry?: true
    color?: true
    text?: true
    author?: true
    created_at?: true
  }

  export type AnnotationMaxAggregateInputType = {
    id?: true
    recording_id?: true
    timecode_ms?: true
    shape?: true
    geometry?: true
    color?: true
    text?: true
    author?: true
    created_at?: true
  }

  export type AnnotationCountAggregateInputType = {
    id?: true
    recording_id?: true
    timecode_ms?: true
    shape?: true
    geometry?: true
    color?: true
    text?: true
    author?: true
    created_at?: true
    _all?: true
  }

  export type AnnotationAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Annotation to aggregate.
     */
    where?: AnnotationWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Annotations to fetch.
     */
    orderBy?: AnnotationOrderByWithRelationInput | AnnotationOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: AnnotationWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Annotations 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` Annotations.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned Annotations
    **/
    _count?: true | AnnotationCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: AnnotationAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: AnnotationSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: AnnotationMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: AnnotationMaxAggregateInputType
  }

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




  export type AnnotationGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: AnnotationWhereInput
    orderBy?: AnnotationOrderByWithAggregationInput | AnnotationOrderByWithAggregationInput[]
    by: AnnotationScalarFieldEnum[] | AnnotationScalarFieldEnum
    having?: AnnotationScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: AnnotationCountAggregateInputType | true
    _avg?: AnnotationAvgAggregateInputType
    _sum?: AnnotationSumAggregateInputType
    _min?: AnnotationMinAggregateInputType
    _max?: AnnotationMaxAggregateInputType
  }

  export type AnnotationGroupByOutputType = {
    id: string
    recording_id: string
    timecode_ms: number
    shape: string
    geometry: string
    color: string
    text: string | null
    author: string | null
    created_at: Date
    _count: AnnotationCountAggregateOutputType | null
    _avg: AnnotationAvgAggregateOutputType | null
    _sum: AnnotationSumAggregateOutputType | null
    _min: AnnotationMinAggregateOutputType | null
    _max: AnnotationMaxAggregateOutputType | null
  }

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


  export type AnnotationSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    recording_id?: boolean
    timecode_ms?: boolean
    shape?: boolean
    geometry?: boolean
    color?: boolean
    text?: boolean
    author?: boolean
    created_at?: boolean
    Recording?: boolean | RecordingDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["annotation"]>

  export type AnnotationSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    recording_id?: boolean
    timecode_ms?: boolean
    shape?: boolean
    geometry?: boolean
    color?: boolean
    text?: boolean
    author?: boolean
    created_at?: boolean
    Recording?: boolean | RecordingDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["annotation"]>

  export type AnnotationSelectScalar = {
    id?: boolean
    recording_id?: boolean
    timecode_ms?: boolean
    shape?: boolean
    geometry?: boolean
    color?: boolean
    text?: boolean
    author?: boolean
    created_at?: boolean
  }

  export type AnnotationInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    Recording?: boolean | RecordingDefaultArgs<ExtArgs>
  }
  export type AnnotationIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    Recording?: boolean | RecordingDefaultArgs<ExtArgs>
  }

  export type $AnnotationPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Annotation"
    objects: {
      Recording: Prisma.$RecordingPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      recording_id: string
      timecode_ms: number
      shape: string
      geometry: string
      color: string
      text: string | null
      author: string | null
      created_at: Date
    }, ExtArgs["result"]["annotation"]>
    composites: {}
  }

  type AnnotationGetPayload<S extends boolean | null | undefined | AnnotationDefaultArgs> = $Result.GetResult<Prisma.$AnnotationPayload, S>

  type AnnotationCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<AnnotationFindManyArgs, 'select' | 'include' | 'distinct'> & {
      select?: AnnotationCountAggregateInputType | true
    }

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

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

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

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

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

    /**
     * Create a Annotation.
     * @param {AnnotationCreateArgs} args - Arguments to create a Annotation.
     * @example
     * // Create one Annotation
     * const Annotation = await prisma.annotation.create({
     *   data: {
     *     // ... data to create a Annotation
     *   }
     * })
     * 
     */
    create<T extends AnnotationCreateArgs>(args: SelectSubset<T, AnnotationCreateArgs<ExtArgs>>): Prisma__AnnotationClient<$Result.GetResult<Prisma.$AnnotationPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

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

    /**
     * Delete a Annotation.
     * @param {AnnotationDeleteArgs} args - Arguments to delete one Annotation.
     * @example
     * // Delete one Annotation
     * const Annotation = await prisma.annotation.delete({
     *   where: {
     *     // ... filter to delete one Annotation
     *   }
     * })
     * 
     */
    delete<T extends AnnotationDeleteArgs>(args: SelectSubset<T, AnnotationDeleteArgs<ExtArgs>>): Prisma__AnnotationClient<$Result.GetResult<Prisma.$AnnotationPayload<ExtArgs>, T, "delete">, never, ExtArgs>

    /**
     * Update one Annotation.
     * @param {AnnotationUpdateArgs} args - Arguments to update one Annotation.
     * @example
     * // Update one Annotation
     * const annotation = await prisma.annotation.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends AnnotationUpdateArgs>(args: SelectSubset<T, AnnotationUpdateArgs<ExtArgs>>): Prisma__AnnotationClient<$Result.GetResult<Prisma.$AnnotationPayload<ExtArgs>, T, "update">, never, ExtArgs>

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

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

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for Annotation.
   * 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__AnnotationClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    Recording<T extends RecordingDefaultArgs<ExtArgs> = {}>(args?: Subset<T, RecordingDefaultArgs<ExtArgs>>): Prisma__RecordingClient<$Result.GetResult<Prisma.$RecordingPayload<ExtArgs>, T, "findUniqueOrThrow"> | Null, Null, ExtArgs>
    /**
     * 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 Annotation model
   */ 
  interface AnnotationFieldRefs {
    readonly id: FieldRef<"Annotation", 'String'>
    readonly recording_id: FieldRef<"Annotation", 'String'>
    readonly timecode_ms: FieldRef<"Annotation", 'Int'>
    readonly shape: FieldRef<"Annotation", 'String'>
    readonly geometry: FieldRef<"Annotation", 'String'>
    readonly color: FieldRef<"Annotation", 'String'>
    readonly text: FieldRef<"Annotation", 'String'>
    readonly author: FieldRef<"Annotation", 'String'>
    readonly created_at: FieldRef<"Annotation", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * Annotation findUnique
   */
  export type AnnotationFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Annotation
     */
    select?: AnnotationSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AnnotationInclude<ExtArgs> | null
    /**
     * Filter, which Annotation to fetch.
     */
    where: AnnotationWhereUniqueInput
  }

  /**
   * Annotation findUniqueOrThrow
   */
  export type AnnotationFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Annotation
     */
    select?: AnnotationSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AnnotationInclude<ExtArgs> | null
    /**
     * Filter, which Annotation to fetch.
     */
    where: AnnotationWhereUniqueInput
  }

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

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

  /**
   * Annotation findMany
   */
  export type AnnotationFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Annotation
     */
    select?: AnnotationSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AnnotationInclude<ExtArgs> | null
    /**
     * Filter, which Annotations to fetch.
     */
    where?: AnnotationWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Annotations to fetch.
     */
    orderBy?: AnnotationOrderByWithRelationInput | AnnotationOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing Annotations.
     */
    cursor?: AnnotationWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Annotations 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` Annotations.
     */
    skip?: number
    distinct?: AnnotationScalarFieldEnum | AnnotationScalarFieldEnum[]
  }

  /**
   * Annotation create
   */
  export type AnnotationCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Annotation
     */
    select?: AnnotationSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AnnotationInclude<ExtArgs> | null
    /**
     * The data needed to create a Annotation.
     */
    data: XOR<AnnotationCreateInput, AnnotationUncheckedCreateInput>
  }

  /**
   * Annotation createMany
   */
  export type AnnotationCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many Annotations.
     */
    data: AnnotationCreateManyInput | AnnotationCreateManyInput[]
  }

  /**
   * Annotation createManyAndReturn
   */
  export type AnnotationCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Annotation
     */
    select?: AnnotationSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many Annotations.
     */
    data: AnnotationCreateManyInput | AnnotationCreateManyInput[]
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AnnotationIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * Annotation update
   */
  export type AnnotationUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Annotation
     */
    select?: AnnotationSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AnnotationInclude<ExtArgs> | null
    /**
     * The data needed to update a Annotation.
     */
    data: XOR<AnnotationUpdateInput, AnnotationUncheckedUpdateInput>
    /**
     * Choose, which Annotation to update.
     */
    where: AnnotationWhereUniqueInput
  }

  /**
   * Annotation updateMany
   */
  export type AnnotationUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Annotations.
     */
    data: XOR<AnnotationUpdateManyMutationInput, AnnotationUncheckedUpdateManyInput>
    /**
     * Filter which Annotations to update
     */
    where?: AnnotationWhereInput
  }

  /**
   * Annotation upsert
   */
  export type AnnotationUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Annotation
     */
    select?: AnnotationSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AnnotationInclude<ExtArgs> | null
    /**
     * The filter to search for the Annotation to update in case it exists.
     */
    where: AnnotationWhereUniqueInput
    /**
     * In case the Annotation found by the `where` argument doesn't exist, create a new Annotation with this data.
     */
    create: XOR<AnnotationCreateInput, AnnotationUncheckedCreateInput>
    /**
     * In case the Annotation was found with the provided `where` argument, update it with this data.
     */
    update: XOR<AnnotationUpdateInput, AnnotationUncheckedUpdateInput>
  }

  /**
   * Annotation delete
   */
  export type AnnotationDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Annotation
     */
    select?: AnnotationSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AnnotationInclude<ExtArgs> | null
    /**
     * Filter which Annotation to delete.
     */
    where: AnnotationWhereUniqueInput
  }

  /**
   * Annotation deleteMany
   */
  export type AnnotationDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Annotations to delete
     */
    where?: AnnotationWhereInput
  }

  /**
   * Annotation without action
   */
  export type AnnotationDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Annotation
     */
    select?: AnnotationSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AnnotationInclude<ExtArgs> | null
  }


  /**
   * Model User
   */

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

  export type UserMinAggregateOutputType = {
    id: string | null
    email: string | null
    name: string | null
    passwordHash: string | null
    accessKey: string | null
    role: string | null
    status: string | null
    createdAt: Date | null
    updatedAt: Date | null
    lastLoginAt: Date | null
    passwordChangedAt: Date | null
  }

  export type UserMaxAggregateOutputType = {
    id: string | null
    email: string | null
    name: string | null
    passwordHash: string | null
    accessKey: string | null
    role: string | null
    status: string | null
    createdAt: Date | null
    updatedAt: Date | null
    lastLoginAt: Date | null
    passwordChangedAt: Date | null
  }

  export type UserCountAggregateOutputType = {
    id: number
    email: number
    name: number
    passwordHash: number
    accessKey: number
    role: number
    status: number
    createdAt: number
    updatedAt: number
    lastLoginAt: number
    passwordChangedAt: number
    _all: number
  }


  export type UserMinAggregateInputType = {
    id?: true
    email?: true
    name?: true
    passwordHash?: true
    accessKey?: true
    role?: true
    status?: true
    createdAt?: true
    updatedAt?: true
    lastLoginAt?: true
    passwordChangedAt?: true
  }

  export type UserMaxAggregateInputType = {
    id?: true
    email?: true
    name?: true
    passwordHash?: true
    accessKey?: true
    role?: true
    status?: true
    createdAt?: true
    updatedAt?: true
    lastLoginAt?: true
    passwordChangedAt?: true
  }

  export type UserCountAggregateInputType = {
    id?: true
    email?: true
    name?: true
    passwordHash?: true
    accessKey?: true
    role?: true
    status?: true
    createdAt?: true
    updatedAt?: true
    lastLoginAt?: true
    passwordChangedAt?: true
    _all?: true
  }

  export type UserAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which User to aggregate.
     */
    where?: UserWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Users to fetch.
     */
    orderBy?: UserOrderByWithRelationInput | UserOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: UserWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Users from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Users.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned Users
    **/
    _count?: true | UserCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: UserMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: UserMaxAggregateInputType
  }

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




  export type UserGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: UserWhereInput
    orderBy?: UserOrderByWithAggregationInput | UserOrderByWithAggregationInput[]
    by: UserScalarFieldEnum[] | UserScalarFieldEnum
    having?: UserScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: UserCountAggregateInputType | true
    _min?: UserMinAggregateInputType
    _max?: UserMaxAggregateInputType
  }

  export type UserGroupByOutputType = {
    id: string
    email: string
    name: string
    passwordHash: string
    accessKey: string
    role: string
    status: string
    createdAt: Date
    updatedAt: Date
    lastLoginAt: Date | null
    passwordChangedAt: Date | null
    _count: UserCountAggregateOutputType | null
    _min: UserMinAggregateOutputType | null
    _max: UserMaxAggregateOutputType | null
  }

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


  export type UserSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    email?: boolean
    name?: boolean
    passwordHash?: boolean
    accessKey?: boolean
    role?: boolean
    status?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    lastLoginAt?: boolean
    passwordChangedAt?: boolean
    apiKeys?: boolean | User$apiKeysArgs<ExtArgs>
    sessions?: boolean | User$sessionsArgs<ExtArgs>
    passwordResetTokens?: boolean | User$passwordResetTokensArgs<ExtArgs>
    teamMemberships?: boolean | User$teamMembershipsArgs<ExtArgs>
    _count?: boolean | UserCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["user"]>

  export type UserSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    email?: boolean
    name?: boolean
    passwordHash?: boolean
    accessKey?: boolean
    role?: boolean
    status?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    lastLoginAt?: boolean
    passwordChangedAt?: boolean
  }, ExtArgs["result"]["user"]>

  export type UserSelectScalar = {
    id?: boolean
    email?: boolean
    name?: boolean
    passwordHash?: boolean
    accessKey?: boolean
    role?: boolean
    status?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    lastLoginAt?: boolean
    passwordChangedAt?: boolean
  }

  export type UserInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    apiKeys?: boolean | User$apiKeysArgs<ExtArgs>
    sessions?: boolean | User$sessionsArgs<ExtArgs>
    passwordResetTokens?: boolean | User$passwordResetTokensArgs<ExtArgs>
    teamMemberships?: boolean | User$teamMembershipsArgs<ExtArgs>
    _count?: boolean | UserCountOutputTypeDefaultArgs<ExtArgs>
  }
  export type UserIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {}

  export type $UserPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "User"
    objects: {
      apiKeys: Prisma.$ApiKeyPayload<ExtArgs>[]
      sessions: Prisma.$UserSessionPayload<ExtArgs>[]
      passwordResetTokens: Prisma.$PasswordResetTokenPayload<ExtArgs>[]
      teamMemberships: Prisma.$TeamMemberPayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      email: string
      name: string
      passwordHash: string
      accessKey: string
      role: string
      status: string
      createdAt: Date
      updatedAt: Date
      lastLoginAt: Date | null
      passwordChangedAt: Date | null
    }, ExtArgs["result"]["user"]>
    composites: {}
  }

  type UserGetPayload<S extends boolean | null | undefined | UserDefaultArgs> = $Result.GetResult<Prisma.$UserPayload, S>

  type UserCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<UserFindManyArgs, 'select' | 'include' | 'distinct'> & {
      select?: UserCountAggregateInputType | true
    }

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

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

    /**
     * Find the first User that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {UserFindFirstArgs} args - Arguments to find a User
     * @example
     * // Get one User
     * const user = await prisma.user.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends UserFindFirstArgs>(args?: SelectSubset<T, UserFindFirstArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findFirst"> | null, null, ExtArgs>

    /**
     * Find the first User that matches the filter or
     * throw `PrismaKnownClientError` with `P2025` code if no matches were found.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {UserFindFirstOrThrowArgs} args - Arguments to find a User
     * @example
     * // Get one User
     * const user = await prisma.user.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends UserFindFirstOrThrowArgs>(args?: SelectSubset<T, UserFindFirstOrThrowArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findFirstOrThrow">, never, ExtArgs>

    /**
     * Find zero or more Users that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {UserFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all Users
     * const users = await prisma.user.findMany()
     * 
     * // Get first 10 Users
     * const users = await prisma.user.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const userWithIdOnly = await prisma.user.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends UserFindManyArgs>(args?: SelectSubset<T, UserFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findMany">>

    /**
     * Create a User.
     * @param {UserCreateArgs} args - Arguments to create a User.
     * @example
     * // Create one User
     * const User = await prisma.user.create({
     *   data: {
     *     // ... data to create a User
     *   }
     * })
     * 
     */
    create<T extends UserCreateArgs>(args: SelectSubset<T, UserCreateArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

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

    /**
     * Delete a User.
     * @param {UserDeleteArgs} args - Arguments to delete one User.
     * @example
     * // Delete one User
     * const User = await prisma.user.delete({
     *   where: {
     *     // ... filter to delete one User
     *   }
     * })
     * 
     */
    delete<T extends UserDeleteArgs>(args: SelectSubset<T, UserDeleteArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "delete">, never, ExtArgs>

    /**
     * Update one User.
     * @param {UserUpdateArgs} args - Arguments to update one User.
     * @example
     * // Update one User
     * const user = await prisma.user.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends UserUpdateArgs>(args: SelectSubset<T, UserUpdateArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "update">, never, ExtArgs>

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

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

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


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

    /**
     * Allows you to perform aggregations operations on a User.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {UserAggregateArgs} args - Select which aggregations you would like to apply and on what fields.
     * @example
     * // Ordered by age ascending
     * // Where email contains prisma.io
     * // Limited to the 10 users
     * const aggregations = await prisma.user.aggregate({
     *   _avg: {
     *     age: true,
     *   },
     *   where: {
     *     email: {
     *       contains: "prisma.io",
     *     },
     *   },
     *   orderBy: {
     *     age: "asc",
     *   },
     *   take: 10,
     * })
    **/
    aggregate<T extends UserAggregateArgs>(args: Subset<T, UserAggregateArgs>): Prisma.PrismaPromise<GetUserAggregateType<T>>

    /**
     * Group by User.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {UserGroupByArgs} args - Group by arguments.
     * @example
     * // Group by city, order by createdAt, get count
     * const result = await prisma.user.groupBy({
     *   by: ['city', 'createdAt'],
     *   orderBy: {
     *     createdAt: true
     *   },
     *   _count: {
     *     _all: true
     *   },
     * })
     * 
    **/
    groupBy<
      T extends UserGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: UserGroupByArgs['orderBy'] }
        : { orderBy?: UserGroupByArgs['orderBy'] },
      OrderFields extends ExcludeUnderscoreKeys<Keys<MaybeTupleToUnion<T['orderBy']>>>,
      ByFields extends MaybeTupleToUnion<T['by']>,
      ByValid extends Has<ByFields, OrderFields>,
      HavingFields extends GetHavingFields<T['having']>,
      HavingValid extends Has<ByFields, HavingFields>,
      ByEmpty extends T['by'] extends never[] ? True : False,
      InputErrors extends ByEmpty extends True
      ? `Error: "by" must not be empty.`
      : HavingValid extends False
      ? {
          [P in HavingFields]: P extends ByFields
            ? never
            : P extends string
            ? `Error: Field "${P}" used in "having" needs to be provided in "by".`
            : [
                Error,
                'Field ',
                P,
                ` in "having" needs to be provided in "by"`,
              ]
        }[HavingFields]
      : 'take' extends Keys<T>
      ? 'orderBy' extends Keys<T>
        ? ByValid extends True
          ? {}
          : {
              [P in OrderFields]: P extends ByFields
                ? never
                : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
            }[OrderFields]
        : 'Error: If you provide "take", you also need to provide "orderBy"'
      : 'skip' extends Keys<T>
      ? 'orderBy' extends Keys<T>
        ? ByValid extends True
          ? {}
          : {
              [P in OrderFields]: P extends ByFields
                ? never
                : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
            }[OrderFields]
        : 'Error: If you provide "skip", you also need to provide "orderBy"'
      : ByValid extends True
      ? {}
      : {
          [P in OrderFields]: P extends ByFields
            ? never
            : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
        }[OrderFields]
    >(args: SubsetIntersection<T, UserGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetUserGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the User model
   */
  readonly fields: UserFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for User.
   * Why is this prefixed with `Prisma__`?
   * Because we want to prevent naming conflicts as mentioned in
   * https://github.com/prisma/prisma-client-js/issues/707
   */
  export interface Prisma__UserClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    apiKeys<T extends User$apiKeysArgs<ExtArgs> = {}>(args?: Subset<T, User$apiKeysArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ApiKeyPayload<ExtArgs>, T, "findMany"> | Null>
    sessions<T extends User$sessionsArgs<ExtArgs> = {}>(args?: Subset<T, User$sessionsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$UserSessionPayload<ExtArgs>, T, "findMany"> | Null>
    passwordResetTokens<T extends User$passwordResetTokensArgs<ExtArgs> = {}>(args?: Subset<T, User$passwordResetTokensArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$PasswordResetTokenPayload<ExtArgs>, T, "findMany"> | Null>
    teamMemberships<T extends User$teamMembershipsArgs<ExtArgs> = {}>(args?: Subset<T, User$teamMembershipsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$TeamMemberPayload<ExtArgs>, T, "findMany"> | Null>
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
    /**
     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
     * resolved value cannot be modified from the callback.
     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
     * @returns A Promise for the completion of the callback.
     */
    finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
  }




  /**
   * Fields of the User model
   */ 
  interface UserFieldRefs {
    readonly id: FieldRef<"User", 'String'>
    readonly email: FieldRef<"User", 'String'>
    readonly name: FieldRef<"User", 'String'>
    readonly passwordHash: FieldRef<"User", 'String'>
    readonly accessKey: FieldRef<"User", 'String'>
    readonly role: FieldRef<"User", 'String'>
    readonly status: FieldRef<"User", 'String'>
    readonly createdAt: FieldRef<"User", 'DateTime'>
    readonly updatedAt: FieldRef<"User", 'DateTime'>
    readonly lastLoginAt: FieldRef<"User", 'DateTime'>
    readonly passwordChangedAt: FieldRef<"User", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * User findUnique
   */
  export type UserFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the User
     */
    select?: UserSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserInclude<ExtArgs> | null
    /**
     * Filter, which User to fetch.
     */
    where: UserWhereUniqueInput
  }

  /**
   * User findUniqueOrThrow
   */
  export type UserFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the User
     */
    select?: UserSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserInclude<ExtArgs> | null
    /**
     * Filter, which User to fetch.
     */
    where: UserWhereUniqueInput
  }

  /**
   * User findFirst
   */
  export type UserFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the User
     */
    select?: UserSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserInclude<ExtArgs> | null
    /**
     * Filter, which User to fetch.
     */
    where?: UserWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Users to fetch.
     */
    orderBy?: UserOrderByWithRelationInput | UserOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Users.
     */
    cursor?: UserWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Users from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Users.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Users.
     */
    distinct?: UserScalarFieldEnum | UserScalarFieldEnum[]
  }

  /**
   * User findFirstOrThrow
   */
  export type UserFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the User
     */
    select?: UserSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserInclude<ExtArgs> | null
    /**
     * Filter, which User to fetch.
     */
    where?: UserWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Users to fetch.
     */
    orderBy?: UserOrderByWithRelationInput | UserOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Users.
     */
    cursor?: UserWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Users from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Users.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Users.
     */
    distinct?: UserScalarFieldEnum | UserScalarFieldEnum[]
  }

  /**
   * User findMany
   */
  export type UserFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the User
     */
    select?: UserSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserInclude<ExtArgs> | null
    /**
     * Filter, which Users to fetch.
     */
    where?: UserWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Users to fetch.
     */
    orderBy?: UserOrderByWithRelationInput | UserOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing Users.
     */
    cursor?: UserWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Users from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Users.
     */
    skip?: number
    distinct?: UserScalarFieldEnum | UserScalarFieldEnum[]
  }

  /**
   * User create
   */
  export type UserCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the User
     */
    select?: UserSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserInclude<ExtArgs> | null
    /**
     * The data needed to create a User.
     */
    data: XOR<UserCreateInput, UserUncheckedCreateInput>
  }

  /**
   * User createMany
   */
  export type UserCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many Users.
     */
    data: UserCreateManyInput | UserCreateManyInput[]
  }

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

  /**
   * User update
   */
  export type UserUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the User
     */
    select?: UserSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserInclude<ExtArgs> | null
    /**
     * The data needed to update a User.
     */
    data: XOR<UserUpdateInput, UserUncheckedUpdateInput>
    /**
     * Choose, which User to update.
     */
    where: UserWhereUniqueInput
  }

  /**
   * User updateMany
   */
  export type UserUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Users.
     */
    data: XOR<UserUpdateManyMutationInput, UserUncheckedUpdateManyInput>
    /**
     * Filter which Users to update
     */
    where?: UserWhereInput
  }

  /**
   * User upsert
   */
  export type UserUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the User
     */
    select?: UserSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserInclude<ExtArgs> | null
    /**
     * The filter to search for the User to update in case it exists.
     */
    where: UserWhereUniqueInput
    /**
     * In case the User found by the `where` argument doesn't exist, create a new User with this data.
     */
    create: XOR<UserCreateInput, UserUncheckedCreateInput>
    /**
     * In case the User was found with the provided `where` argument, update it with this data.
     */
    update: XOR<UserUpdateInput, UserUncheckedUpdateInput>
  }

  /**
   * User delete
   */
  export type UserDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the User
     */
    select?: UserSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserInclude<ExtArgs> | null
    /**
     * Filter which User to delete.
     */
    where: UserWhereUniqueInput
  }

  /**
   * User deleteMany
   */
  export type UserDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Users to delete
     */
    where?: UserWhereInput
  }

  /**
   * User.apiKeys
   */
  export type User$apiKeysArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ApiKey
     */
    select?: ApiKeySelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ApiKeyInclude<ExtArgs> | null
    where?: ApiKeyWhereInput
    orderBy?: ApiKeyOrderByWithRelationInput | ApiKeyOrderByWithRelationInput[]
    cursor?: ApiKeyWhereUniqueInput
    take?: number
    skip?: number
    distinct?: ApiKeyScalarFieldEnum | ApiKeyScalarFieldEnum[]
  }

  /**
   * User.sessions
   */
  export type User$sessionsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the UserSession
     */
    select?: UserSessionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserSessionInclude<ExtArgs> | null
    where?: UserSessionWhereInput
    orderBy?: UserSessionOrderByWithRelationInput | UserSessionOrderByWithRelationInput[]
    cursor?: UserSessionWhereUniqueInput
    take?: number
    skip?: number
    distinct?: UserSessionScalarFieldEnum | UserSessionScalarFieldEnum[]
  }

  /**
   * User.passwordResetTokens
   */
  export type User$passwordResetTokensArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PasswordResetToken
     */
    select?: PasswordResetTokenSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PasswordResetTokenInclude<ExtArgs> | null
    where?: PasswordResetTokenWhereInput
    orderBy?: PasswordResetTokenOrderByWithRelationInput | PasswordResetTokenOrderByWithRelationInput[]
    cursor?: PasswordResetTokenWhereUniqueInput
    take?: number
    skip?: number
    distinct?: PasswordResetTokenScalarFieldEnum | PasswordResetTokenScalarFieldEnum[]
  }

  /**
   * User.teamMemberships
   */
  export type User$teamMembershipsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TeamMember
     */
    select?: TeamMemberSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TeamMemberInclude<ExtArgs> | null
    where?: TeamMemberWhereInput
    orderBy?: TeamMemberOrderByWithRelationInput | TeamMemberOrderByWithRelationInput[]
    cursor?: TeamMemberWhereUniqueInput
    take?: number
    skip?: number
    distinct?: TeamMemberScalarFieldEnum | TeamMemberScalarFieldEnum[]
  }

  /**
   * User without action
   */
  export type UserDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the User
     */
    select?: UserSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserInclude<ExtArgs> | null
  }


  /**
   * Model UserSession
   */

  export type AggregateUserSession = {
    _count: UserSessionCountAggregateOutputType | null
    _min: UserSessionMinAggregateOutputType | null
    _max: UserSessionMaxAggregateOutputType | null
  }

  export type UserSessionMinAggregateOutputType = {
    id: string | null
    userId: string | null
    createdAt: Date | null
    expiresAt: Date | null
    lastSeenAt: Date | null
    userAgent: string | null
    ipHash: string | null
  }

  export type UserSessionMaxAggregateOutputType = {
    id: string | null
    userId: string | null
    createdAt: Date | null
    expiresAt: Date | null
    lastSeenAt: Date | null
    userAgent: string | null
    ipHash: string | null
  }

  export type UserSessionCountAggregateOutputType = {
    id: number
    userId: number
    createdAt: number
    expiresAt: number
    lastSeenAt: number
    userAgent: number
    ipHash: number
    _all: number
  }


  export type UserSessionMinAggregateInputType = {
    id?: true
    userId?: true
    createdAt?: true
    expiresAt?: true
    lastSeenAt?: true
    userAgent?: true
    ipHash?: true
  }

  export type UserSessionMaxAggregateInputType = {
    id?: true
    userId?: true
    createdAt?: true
    expiresAt?: true
    lastSeenAt?: true
    userAgent?: true
    ipHash?: true
  }

  export type UserSessionCountAggregateInputType = {
    id?: true
    userId?: true
    createdAt?: true
    expiresAt?: true
    lastSeenAt?: true
    userAgent?: true
    ipHash?: true
    _all?: true
  }

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

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




  export type UserSessionGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: UserSessionWhereInput
    orderBy?: UserSessionOrderByWithAggregationInput | UserSessionOrderByWithAggregationInput[]
    by: UserSessionScalarFieldEnum[] | UserSessionScalarFieldEnum
    having?: UserSessionScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: UserSessionCountAggregateInputType | true
    _min?: UserSessionMinAggregateInputType
    _max?: UserSessionMaxAggregateInputType
  }

  export type UserSessionGroupByOutputType = {
    id: string
    userId: string
    createdAt: Date
    expiresAt: Date
    lastSeenAt: Date
    userAgent: string | null
    ipHash: string | null
    _count: UserSessionCountAggregateOutputType | null
    _min: UserSessionMinAggregateOutputType | null
    _max: UserSessionMaxAggregateOutputType | null
  }

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


  export type UserSessionSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    userId?: boolean
    createdAt?: boolean
    expiresAt?: boolean
    lastSeenAt?: boolean
    userAgent?: boolean
    ipHash?: boolean
    user?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["userSession"]>

  export type UserSessionSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    userId?: boolean
    createdAt?: boolean
    expiresAt?: boolean
    lastSeenAt?: boolean
    userAgent?: boolean
    ipHash?: boolean
    user?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["userSession"]>

  export type UserSessionSelectScalar = {
    id?: boolean
    userId?: boolean
    createdAt?: boolean
    expiresAt?: boolean
    lastSeenAt?: boolean
    userAgent?: boolean
    ipHash?: boolean
  }

  export type UserSessionInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
  }
  export type UserSessionIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
  }

  export type $UserSessionPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "UserSession"
    objects: {
      user: Prisma.$UserPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      userId: string
      createdAt: Date
      expiresAt: Date
      lastSeenAt: Date
      userAgent: string | null
      ipHash: string | null
    }, ExtArgs["result"]["userSession"]>
    composites: {}
  }

  type UserSessionGetPayload<S extends boolean | null | undefined | UserSessionDefaultArgs> = $Result.GetResult<Prisma.$UserSessionPayload, S>

  type UserSessionCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<UserSessionFindManyArgs, 'select' | 'include' | 'distinct'> & {
      select?: UserSessionCountAggregateInputType | true
    }

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

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

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

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

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

    /**
     * Create a UserSession.
     * @param {UserSessionCreateArgs} args - Arguments to create a UserSession.
     * @example
     * // Create one UserSession
     * const UserSession = await prisma.userSession.create({
     *   data: {
     *     // ... data to create a UserSession
     *   }
     * })
     * 
     */
    create<T extends UserSessionCreateArgs>(args: SelectSubset<T, UserSessionCreateArgs<ExtArgs>>): Prisma__UserSessionClient<$Result.GetResult<Prisma.$UserSessionPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

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

    /**
     * Delete a UserSession.
     * @param {UserSessionDeleteArgs} args - Arguments to delete one UserSession.
     * @example
     * // Delete one UserSession
     * const UserSession = await prisma.userSession.delete({
     *   where: {
     *     // ... filter to delete one UserSession
     *   }
     * })
     * 
     */
    delete<T extends UserSessionDeleteArgs>(args: SelectSubset<T, UserSessionDeleteArgs<ExtArgs>>): Prisma__UserSessionClient<$Result.GetResult<Prisma.$UserSessionPayload<ExtArgs>, T, "delete">, never, ExtArgs>

    /**
     * Update one UserSession.
     * @param {UserSessionUpdateArgs} args - Arguments to update one UserSession.
     * @example
     * // Update one UserSession
     * const userSession = await prisma.userSession.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends UserSessionUpdateArgs>(args: SelectSubset<T, UserSessionUpdateArgs<ExtArgs>>): Prisma__UserSessionClient<$Result.GetResult<Prisma.$UserSessionPayload<ExtArgs>, T, "update">, never, ExtArgs>

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

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

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for UserSession.
   * 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__UserSessionClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    user<T extends UserDefaultArgs<ExtArgs> = {}>(args?: Subset<T, UserDefaultArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findUniqueOrThrow"> | Null, Null, ExtArgs>
    /**
     * 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 UserSession model
   */ 
  interface UserSessionFieldRefs {
    readonly id: FieldRef<"UserSession", 'String'>
    readonly userId: FieldRef<"UserSession", 'String'>
    readonly createdAt: FieldRef<"UserSession", 'DateTime'>
    readonly expiresAt: FieldRef<"UserSession", 'DateTime'>
    readonly lastSeenAt: FieldRef<"UserSession", 'DateTime'>
    readonly userAgent: FieldRef<"UserSession", 'String'>
    readonly ipHash: FieldRef<"UserSession", 'String'>
  }
    

  // Custom InputTypes
  /**
   * UserSession findUnique
   */
  export type UserSessionFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the UserSession
     */
    select?: UserSessionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserSessionInclude<ExtArgs> | null
    /**
     * Filter, which UserSession to fetch.
     */
    where: UserSessionWhereUniqueInput
  }

  /**
   * UserSession findUniqueOrThrow
   */
  export type UserSessionFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the UserSession
     */
    select?: UserSessionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserSessionInclude<ExtArgs> | null
    /**
     * Filter, which UserSession to fetch.
     */
    where: UserSessionWhereUniqueInput
  }

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

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

  /**
   * UserSession findMany
   */
  export type UserSessionFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the UserSession
     */
    select?: UserSessionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserSessionInclude<ExtArgs> | null
    /**
     * Filter, which UserSessions to fetch.
     */
    where?: UserSessionWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of UserSessions to fetch.
     */
    orderBy?: UserSessionOrderByWithRelationInput | UserSessionOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing UserSessions.
     */
    cursor?: UserSessionWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` UserSessions 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` UserSessions.
     */
    skip?: number
    distinct?: UserSessionScalarFieldEnum | UserSessionScalarFieldEnum[]
  }

  /**
   * UserSession create
   */
  export type UserSessionCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the UserSession
     */
    select?: UserSessionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserSessionInclude<ExtArgs> | null
    /**
     * The data needed to create a UserSession.
     */
    data: XOR<UserSessionCreateInput, UserSessionUncheckedCreateInput>
  }

  /**
   * UserSession createMany
   */
  export type UserSessionCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many UserSessions.
     */
    data: UserSessionCreateManyInput | UserSessionCreateManyInput[]
  }

  /**
   * UserSession createManyAndReturn
   */
  export type UserSessionCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the UserSession
     */
    select?: UserSessionSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many UserSessions.
     */
    data: UserSessionCreateManyInput | UserSessionCreateManyInput[]
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserSessionIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * UserSession update
   */
  export type UserSessionUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the UserSession
     */
    select?: UserSessionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserSessionInclude<ExtArgs> | null
    /**
     * The data needed to update a UserSession.
     */
    data: XOR<UserSessionUpdateInput, UserSessionUncheckedUpdateInput>
    /**
     * Choose, which UserSession to update.
     */
    where: UserSessionWhereUniqueInput
  }

  /**
   * UserSession updateMany
   */
  export type UserSessionUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update UserSessions.
     */
    data: XOR<UserSessionUpdateManyMutationInput, UserSessionUncheckedUpdateManyInput>
    /**
     * Filter which UserSessions to update
     */
    where?: UserSessionWhereInput
  }

  /**
   * UserSession upsert
   */
  export type UserSessionUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the UserSession
     */
    select?: UserSessionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserSessionInclude<ExtArgs> | null
    /**
     * The filter to search for the UserSession to update in case it exists.
     */
    where: UserSessionWhereUniqueInput
    /**
     * In case the UserSession found by the `where` argument doesn't exist, create a new UserSession with this data.
     */
    create: XOR<UserSessionCreateInput, UserSessionUncheckedCreateInput>
    /**
     * In case the UserSession was found with the provided `where` argument, update it with this data.
     */
    update: XOR<UserSessionUpdateInput, UserSessionUncheckedUpdateInput>
  }

  /**
   * UserSession delete
   */
  export type UserSessionDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the UserSession
     */
    select?: UserSessionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserSessionInclude<ExtArgs> | null
    /**
     * Filter which UserSession to delete.
     */
    where: UserSessionWhereUniqueInput
  }

  /**
   * UserSession deleteMany
   */
  export type UserSessionDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which UserSessions to delete
     */
    where?: UserSessionWhereInput
  }

  /**
   * UserSession without action
   */
  export type UserSessionDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the UserSession
     */
    select?: UserSessionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserSessionInclude<ExtArgs> | null
  }


  /**
   * Model PasswordResetToken
   */

  export type AggregatePasswordResetToken = {
    _count: PasswordResetTokenCountAggregateOutputType | null
    _min: PasswordResetTokenMinAggregateOutputType | null
    _max: PasswordResetTokenMaxAggregateOutputType | null
  }

  export type PasswordResetTokenMinAggregateOutputType = {
    id: string | null
    userId: string | null
    tokenHash: string | null
    createdAt: Date | null
    expiresAt: Date | null
    usedAt: Date | null
  }

  export type PasswordResetTokenMaxAggregateOutputType = {
    id: string | null
    userId: string | null
    tokenHash: string | null
    createdAt: Date | null
    expiresAt: Date | null
    usedAt: Date | null
  }

  export type PasswordResetTokenCountAggregateOutputType = {
    id: number
    userId: number
    tokenHash: number
    createdAt: number
    expiresAt: number
    usedAt: number
    _all: number
  }


  export type PasswordResetTokenMinAggregateInputType = {
    id?: true
    userId?: true
    tokenHash?: true
    createdAt?: true
    expiresAt?: true
    usedAt?: true
  }

  export type PasswordResetTokenMaxAggregateInputType = {
    id?: true
    userId?: true
    tokenHash?: true
    createdAt?: true
    expiresAt?: true
    usedAt?: true
  }

  export type PasswordResetTokenCountAggregateInputType = {
    id?: true
    userId?: true
    tokenHash?: true
    createdAt?: true
    expiresAt?: true
    usedAt?: true
    _all?: true
  }

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

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




  export type PasswordResetTokenGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: PasswordResetTokenWhereInput
    orderBy?: PasswordResetTokenOrderByWithAggregationInput | PasswordResetTokenOrderByWithAggregationInput[]
    by: PasswordResetTokenScalarFieldEnum[] | PasswordResetTokenScalarFieldEnum
    having?: PasswordResetTokenScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: PasswordResetTokenCountAggregateInputType | true
    _min?: PasswordResetTokenMinAggregateInputType
    _max?: PasswordResetTokenMaxAggregateInputType
  }

  export type PasswordResetTokenGroupByOutputType = {
    id: string
    userId: string
    tokenHash: string
    createdAt: Date
    expiresAt: Date
    usedAt: Date | null
    _count: PasswordResetTokenCountAggregateOutputType | null
    _min: PasswordResetTokenMinAggregateOutputType | null
    _max: PasswordResetTokenMaxAggregateOutputType | null
  }

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


  export type PasswordResetTokenSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    userId?: boolean
    tokenHash?: boolean
    createdAt?: boolean
    expiresAt?: boolean
    usedAt?: boolean
    user?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["passwordResetToken"]>

  export type PasswordResetTokenSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    userId?: boolean
    tokenHash?: boolean
    createdAt?: boolean
    expiresAt?: boolean
    usedAt?: boolean
    user?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["passwordResetToken"]>

  export type PasswordResetTokenSelectScalar = {
    id?: boolean
    userId?: boolean
    tokenHash?: boolean
    createdAt?: boolean
    expiresAt?: boolean
    usedAt?: boolean
  }

  export type PasswordResetTokenInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
  }
  export type PasswordResetTokenIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
  }

  export type $PasswordResetTokenPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "PasswordResetToken"
    objects: {
      user: Prisma.$UserPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      userId: string
      tokenHash: string
      createdAt: Date
      expiresAt: Date
      usedAt: Date | null
    }, ExtArgs["result"]["passwordResetToken"]>
    composites: {}
  }

  type PasswordResetTokenGetPayload<S extends boolean | null | undefined | PasswordResetTokenDefaultArgs> = $Result.GetResult<Prisma.$PasswordResetTokenPayload, S>

  type PasswordResetTokenCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<PasswordResetTokenFindManyArgs, 'select' | 'include' | 'distinct'> & {
      select?: PasswordResetTokenCountAggregateInputType | true
    }

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

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

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

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

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

    /**
     * Create a PasswordResetToken.
     * @param {PasswordResetTokenCreateArgs} args - Arguments to create a PasswordResetToken.
     * @example
     * // Create one PasswordResetToken
     * const PasswordResetToken = await prisma.passwordResetToken.create({
     *   data: {
     *     // ... data to create a PasswordResetToken
     *   }
     * })
     * 
     */
    create<T extends PasswordResetTokenCreateArgs>(args: SelectSubset<T, PasswordResetTokenCreateArgs<ExtArgs>>): Prisma__PasswordResetTokenClient<$Result.GetResult<Prisma.$PasswordResetTokenPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

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

    /**
     * Delete a PasswordResetToken.
     * @param {PasswordResetTokenDeleteArgs} args - Arguments to delete one PasswordResetToken.
     * @example
     * // Delete one PasswordResetToken
     * const PasswordResetToken = await prisma.passwordResetToken.delete({
     *   where: {
     *     // ... filter to delete one PasswordResetToken
     *   }
     * })
     * 
     */
    delete<T extends PasswordResetTokenDeleteArgs>(args: SelectSubset<T, PasswordResetTokenDeleteArgs<ExtArgs>>): Prisma__PasswordResetTokenClient<$Result.GetResult<Prisma.$PasswordResetTokenPayload<ExtArgs>, T, "delete">, never, ExtArgs>

    /**
     * Update one PasswordResetToken.
     * @param {PasswordResetTokenUpdateArgs} args - Arguments to update one PasswordResetToken.
     * @example
     * // Update one PasswordResetToken
     * const passwordResetToken = await prisma.passwordResetToken.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends PasswordResetTokenUpdateArgs>(args: SelectSubset<T, PasswordResetTokenUpdateArgs<ExtArgs>>): Prisma__PasswordResetTokenClient<$Result.GetResult<Prisma.$PasswordResetTokenPayload<ExtArgs>, T, "update">, never, ExtArgs>

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

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

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for PasswordResetToken.
   * 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__PasswordResetTokenClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    user<T extends UserDefaultArgs<ExtArgs> = {}>(args?: Subset<T, UserDefaultArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findUniqueOrThrow"> | Null, Null, ExtArgs>
    /**
     * 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 PasswordResetToken model
   */ 
  interface PasswordResetTokenFieldRefs {
    readonly id: FieldRef<"PasswordResetToken", 'String'>
    readonly userId: FieldRef<"PasswordResetToken", 'String'>
    readonly tokenHash: FieldRef<"PasswordResetToken", 'String'>
    readonly createdAt: FieldRef<"PasswordResetToken", 'DateTime'>
    readonly expiresAt: FieldRef<"PasswordResetToken", 'DateTime'>
    readonly usedAt: FieldRef<"PasswordResetToken", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * PasswordResetToken findUnique
   */
  export type PasswordResetTokenFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PasswordResetToken
     */
    select?: PasswordResetTokenSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PasswordResetTokenInclude<ExtArgs> | null
    /**
     * Filter, which PasswordResetToken to fetch.
     */
    where: PasswordResetTokenWhereUniqueInput
  }

  /**
   * PasswordResetToken findUniqueOrThrow
   */
  export type PasswordResetTokenFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PasswordResetToken
     */
    select?: PasswordResetTokenSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PasswordResetTokenInclude<ExtArgs> | null
    /**
     * Filter, which PasswordResetToken to fetch.
     */
    where: PasswordResetTokenWhereUniqueInput
  }

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

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

  /**
   * PasswordResetToken findMany
   */
  export type PasswordResetTokenFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PasswordResetToken
     */
    select?: PasswordResetTokenSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PasswordResetTokenInclude<ExtArgs> | null
    /**
     * Filter, which PasswordResetTokens to fetch.
     */
    where?: PasswordResetTokenWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of PasswordResetTokens to fetch.
     */
    orderBy?: PasswordResetTokenOrderByWithRelationInput | PasswordResetTokenOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing PasswordResetTokens.
     */
    cursor?: PasswordResetTokenWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` PasswordResetTokens 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` PasswordResetTokens.
     */
    skip?: number
    distinct?: PasswordResetTokenScalarFieldEnum | PasswordResetTokenScalarFieldEnum[]
  }

  /**
   * PasswordResetToken create
   */
  export type PasswordResetTokenCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PasswordResetToken
     */
    select?: PasswordResetTokenSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PasswordResetTokenInclude<ExtArgs> | null
    /**
     * The data needed to create a PasswordResetToken.
     */
    data: XOR<PasswordResetTokenCreateInput, PasswordResetTokenUncheckedCreateInput>
  }

  /**
   * PasswordResetToken createMany
   */
  export type PasswordResetTokenCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many PasswordResetTokens.
     */
    data: PasswordResetTokenCreateManyInput | PasswordResetTokenCreateManyInput[]
  }

  /**
   * PasswordResetToken createManyAndReturn
   */
  export type PasswordResetTokenCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PasswordResetToken
     */
    select?: PasswordResetTokenSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many PasswordResetTokens.
     */
    data: PasswordResetTokenCreateManyInput | PasswordResetTokenCreateManyInput[]
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PasswordResetTokenIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * PasswordResetToken update
   */
  export type PasswordResetTokenUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PasswordResetToken
     */
    select?: PasswordResetTokenSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PasswordResetTokenInclude<ExtArgs> | null
    /**
     * The data needed to update a PasswordResetToken.
     */
    data: XOR<PasswordResetTokenUpdateInput, PasswordResetTokenUncheckedUpdateInput>
    /**
     * Choose, which PasswordResetToken to update.
     */
    where: PasswordResetTokenWhereUniqueInput
  }

  /**
   * PasswordResetToken updateMany
   */
  export type PasswordResetTokenUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update PasswordResetTokens.
     */
    data: XOR<PasswordResetTokenUpdateManyMutationInput, PasswordResetTokenUncheckedUpdateManyInput>
    /**
     * Filter which PasswordResetTokens to update
     */
    where?: PasswordResetTokenWhereInput
  }

  /**
   * PasswordResetToken upsert
   */
  export type PasswordResetTokenUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PasswordResetToken
     */
    select?: PasswordResetTokenSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PasswordResetTokenInclude<ExtArgs> | null
    /**
     * The filter to search for the PasswordResetToken to update in case it exists.
     */
    where: PasswordResetTokenWhereUniqueInput
    /**
     * In case the PasswordResetToken found by the `where` argument doesn't exist, create a new PasswordResetToken with this data.
     */
    create: XOR<PasswordResetTokenCreateInput, PasswordResetTokenUncheckedCreateInput>
    /**
     * In case the PasswordResetToken was found with the provided `where` argument, update it with this data.
     */
    update: XOR<PasswordResetTokenUpdateInput, PasswordResetTokenUncheckedUpdateInput>
  }

  /**
   * PasswordResetToken delete
   */
  export type PasswordResetTokenDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PasswordResetToken
     */
    select?: PasswordResetTokenSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PasswordResetTokenInclude<ExtArgs> | null
    /**
     * Filter which PasswordResetToken to delete.
     */
    where: PasswordResetTokenWhereUniqueInput
  }

  /**
   * PasswordResetToken deleteMany
   */
  export type PasswordResetTokenDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which PasswordResetTokens to delete
     */
    where?: PasswordResetTokenWhereInput
  }

  /**
   * PasswordResetToken without action
   */
  export type PasswordResetTokenDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PasswordResetToken
     */
    select?: PasswordResetTokenSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PasswordResetTokenInclude<ExtArgs> | null
  }


  /**
   * Model TeamMember
   */

  export type AggregateTeamMember = {
    _count: TeamMemberCountAggregateOutputType | null
    _min: TeamMemberMinAggregateOutputType | null
    _max: TeamMemberMaxAggregateOutputType | null
  }

  export type TeamMemberMinAggregateOutputType = {
    teamId: string | null
    userId: string | null
    createdAt: Date | null
  }

  export type TeamMemberMaxAggregateOutputType = {
    teamId: string | null
    userId: string | null
    createdAt: Date | null
  }

  export type TeamMemberCountAggregateOutputType = {
    teamId: number
    userId: number
    createdAt: number
    _all: number
  }


  export type TeamMemberMinAggregateInputType = {
    teamId?: true
    userId?: true
    createdAt?: true
  }

  export type TeamMemberMaxAggregateInputType = {
    teamId?: true
    userId?: true
    createdAt?: true
  }

  export type TeamMemberCountAggregateInputType = {
    teamId?: true
    userId?: true
    createdAt?: true
    _all?: true
  }

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

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




  export type TeamMemberGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: TeamMemberWhereInput
    orderBy?: TeamMemberOrderByWithAggregationInput | TeamMemberOrderByWithAggregationInput[]
    by: TeamMemberScalarFieldEnum[] | TeamMemberScalarFieldEnum
    having?: TeamMemberScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: TeamMemberCountAggregateInputType | true
    _min?: TeamMemberMinAggregateInputType
    _max?: TeamMemberMaxAggregateInputType
  }

  export type TeamMemberGroupByOutputType = {
    teamId: string
    userId: string
    createdAt: Date
    _count: TeamMemberCountAggregateOutputType | null
    _min: TeamMemberMinAggregateOutputType | null
    _max: TeamMemberMaxAggregateOutputType | null
  }

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


  export type TeamMemberSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    teamId?: boolean
    userId?: boolean
    createdAt?: boolean
    team?: boolean | TeamDefaultArgs<ExtArgs>
    user?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["teamMember"]>

  export type TeamMemberSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    teamId?: boolean
    userId?: boolean
    createdAt?: boolean
    team?: boolean | TeamDefaultArgs<ExtArgs>
    user?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["teamMember"]>

  export type TeamMemberSelectScalar = {
    teamId?: boolean
    userId?: boolean
    createdAt?: boolean
  }

  export type TeamMemberInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    team?: boolean | TeamDefaultArgs<ExtArgs>
    user?: boolean | UserDefaultArgs<ExtArgs>
  }
  export type TeamMemberIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    team?: boolean | TeamDefaultArgs<ExtArgs>
    user?: boolean | UserDefaultArgs<ExtArgs>
  }

  export type $TeamMemberPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "TeamMember"
    objects: {
      team: Prisma.$TeamPayload<ExtArgs>
      user: Prisma.$UserPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      teamId: string
      userId: string
      createdAt: Date
    }, ExtArgs["result"]["teamMember"]>
    composites: {}
  }

  type TeamMemberGetPayload<S extends boolean | null | undefined | TeamMemberDefaultArgs> = $Result.GetResult<Prisma.$TeamMemberPayload, S>

  type TeamMemberCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<TeamMemberFindManyArgs, 'select' | 'include' | 'distinct'> & {
      select?: TeamMemberCountAggregateInputType | true
    }

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

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

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

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

    /**
     * Find zero or more TeamMembers 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 {TeamMemberFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all TeamMembers
     * const teamMembers = await prisma.teamMember.findMany()
     * 
     * // Get first 10 TeamMembers
     * const teamMembers = await prisma.teamMember.findMany({ take: 10 })
     * 
     * // Only select the `teamId`
     * const teamMemberWithTeamIdOnly = await prisma.teamMember.findMany({ select: { teamId: true } })
     * 
     */
    findMany<T extends TeamMemberFindManyArgs>(args?: SelectSubset<T, TeamMemberFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$TeamMemberPayload<ExtArgs>, T, "findMany">>

    /**
     * Create a TeamMember.
     * @param {TeamMemberCreateArgs} args - Arguments to create a TeamMember.
     * @example
     * // Create one TeamMember
     * const TeamMember = await prisma.teamMember.create({
     *   data: {
     *     // ... data to create a TeamMember
     *   }
     * })
     * 
     */
    create<T extends TeamMemberCreateArgs>(args: SelectSubset<T, TeamMemberCreateArgs<ExtArgs>>): Prisma__TeamMemberClient<$Result.GetResult<Prisma.$TeamMemberPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

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

    /**
     * Delete a TeamMember.
     * @param {TeamMemberDeleteArgs} args - Arguments to delete one TeamMember.
     * @example
     * // Delete one TeamMember
     * const TeamMember = await prisma.teamMember.delete({
     *   where: {
     *     // ... filter to delete one TeamMember
     *   }
     * })
     * 
     */
    delete<T extends TeamMemberDeleteArgs>(args: SelectSubset<T, TeamMemberDeleteArgs<ExtArgs>>): Prisma__TeamMemberClient<$Result.GetResult<Prisma.$TeamMemberPayload<ExtArgs>, T, "delete">, never, ExtArgs>

    /**
     * Update one TeamMember.
     * @param {TeamMemberUpdateArgs} args - Arguments to update one TeamMember.
     * @example
     * // Update one TeamMember
     * const teamMember = await prisma.teamMember.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends TeamMemberUpdateArgs>(args: SelectSubset<T, TeamMemberUpdateArgs<ExtArgs>>): Prisma__TeamMemberClient<$Result.GetResult<Prisma.$TeamMemberPayload<ExtArgs>, T, "update">, never, ExtArgs>

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

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

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for TeamMember.
   * 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__TeamMemberClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    team<T extends TeamDefaultArgs<ExtArgs> = {}>(args?: Subset<T, TeamDefaultArgs<ExtArgs>>): Prisma__TeamClient<$Result.GetResult<Prisma.$TeamPayload<ExtArgs>, T, "findUniqueOrThrow"> | Null, Null, ExtArgs>
    user<T extends UserDefaultArgs<ExtArgs> = {}>(args?: Subset<T, UserDefaultArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findUniqueOrThrow"> | Null, Null, ExtArgs>
    /**
     * 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 TeamMember model
   */ 
  interface TeamMemberFieldRefs {
    readonly teamId: FieldRef<"TeamMember", 'String'>
    readonly userId: FieldRef<"TeamMember", 'String'>
    readonly createdAt: FieldRef<"TeamMember", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * TeamMember findUnique
   */
  export type TeamMemberFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TeamMember
     */
    select?: TeamMemberSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TeamMemberInclude<ExtArgs> | null
    /**
     * Filter, which TeamMember to fetch.
     */
    where: TeamMemberWhereUniqueInput
  }

  /**
   * TeamMember findUniqueOrThrow
   */
  export type TeamMemberFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TeamMember
     */
    select?: TeamMemberSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TeamMemberInclude<ExtArgs> | null
    /**
     * Filter, which TeamMember to fetch.
     */
    where: TeamMemberWhereUniqueInput
  }

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

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

  /**
   * TeamMember findMany
   */
  export type TeamMemberFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TeamMember
     */
    select?: TeamMemberSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TeamMemberInclude<ExtArgs> | null
    /**
     * Filter, which TeamMembers to fetch.
     */
    where?: TeamMemberWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of TeamMembers to fetch.
     */
    orderBy?: TeamMemberOrderByWithRelationInput | TeamMemberOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing TeamMembers.
     */
    cursor?: TeamMemberWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` TeamMembers 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` TeamMembers.
     */
    skip?: number
    distinct?: TeamMemberScalarFieldEnum | TeamMemberScalarFieldEnum[]
  }

  /**
   * TeamMember create
   */
  export type TeamMemberCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TeamMember
     */
    select?: TeamMemberSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TeamMemberInclude<ExtArgs> | null
    /**
     * The data needed to create a TeamMember.
     */
    data: XOR<TeamMemberCreateInput, TeamMemberUncheckedCreateInput>
  }

  /**
   * TeamMember createMany
   */
  export type TeamMemberCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many TeamMembers.
     */
    data: TeamMemberCreateManyInput | TeamMemberCreateManyInput[]
  }

  /**
   * TeamMember createManyAndReturn
   */
  export type TeamMemberCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TeamMember
     */
    select?: TeamMemberSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many TeamMembers.
     */
    data: TeamMemberCreateManyInput | TeamMemberCreateManyInput[]
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TeamMemberIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * TeamMember update
   */
  export type TeamMemberUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TeamMember
     */
    select?: TeamMemberSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TeamMemberInclude<ExtArgs> | null
    /**
     * The data needed to update a TeamMember.
     */
    data: XOR<TeamMemberUpdateInput, TeamMemberUncheckedUpdateInput>
    /**
     * Choose, which TeamMember to update.
     */
    where: TeamMemberWhereUniqueInput
  }

  /**
   * TeamMember updateMany
   */
  export type TeamMemberUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update TeamMembers.
     */
    data: XOR<TeamMemberUpdateManyMutationInput, TeamMemberUncheckedUpdateManyInput>
    /**
     * Filter which TeamMembers to update
     */
    where?: TeamMemberWhereInput
  }

  /**
   * TeamMember upsert
   */
  export type TeamMemberUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TeamMember
     */
    select?: TeamMemberSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TeamMemberInclude<ExtArgs> | null
    /**
     * The filter to search for the TeamMember to update in case it exists.
     */
    where: TeamMemberWhereUniqueInput
    /**
     * In case the TeamMember found by the `where` argument doesn't exist, create a new TeamMember with this data.
     */
    create: XOR<TeamMemberCreateInput, TeamMemberUncheckedCreateInput>
    /**
     * In case the TeamMember was found with the provided `where` argument, update it with this data.
     */
    update: XOR<TeamMemberUpdateInput, TeamMemberUncheckedUpdateInput>
  }

  /**
   * TeamMember delete
   */
  export type TeamMemberDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TeamMember
     */
    select?: TeamMemberSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TeamMemberInclude<ExtArgs> | null
    /**
     * Filter which TeamMember to delete.
     */
    where: TeamMemberWhereUniqueInput
  }

  /**
   * TeamMember deleteMany
   */
  export type TeamMemberDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which TeamMembers to delete
     */
    where?: TeamMemberWhereInput
  }

  /**
   * TeamMember without action
   */
  export type TeamMemberDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TeamMember
     */
    select?: TeamMemberSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TeamMemberInclude<ExtArgs> | null
  }


  /**
   * Model EventLog
   */

  export type AggregateEventLog = {
    _count: EventLogCountAggregateOutputType | null
    _min: EventLogMinAggregateOutputType | null
    _max: EventLogMaxAggregateOutputType | null
  }

  export type EventLogMinAggregateOutputType = {
    id: string | null
    type: string | null
    payload: string | null
    correlationId: string | null
    teamId: string | null
    occurredAt: Date | null
  }

  export type EventLogMaxAggregateOutputType = {
    id: string | null
    type: string | null
    payload: string | null
    correlationId: string | null
    teamId: string | null
    occurredAt: Date | null
  }

  export type EventLogCountAggregateOutputType = {
    id: number
    type: number
    payload: number
    correlationId: number
    teamId: number
    occurredAt: number
    _all: number
  }


  export type EventLogMinAggregateInputType = {
    id?: true
    type?: true
    payload?: true
    correlationId?: true
    teamId?: true
    occurredAt?: true
  }

  export type EventLogMaxAggregateInputType = {
    id?: true
    type?: true
    payload?: true
    correlationId?: true
    teamId?: true
    occurredAt?: true
  }

  export type EventLogCountAggregateInputType = {
    id?: true
    type?: true
    payload?: true
    correlationId?: true
    teamId?: true
    occurredAt?: true
    _all?: true
  }

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

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




  export type EventLogGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: EventLogWhereInput
    orderBy?: EventLogOrderByWithAggregationInput | EventLogOrderByWithAggregationInput[]
    by: EventLogScalarFieldEnum[] | EventLogScalarFieldEnum
    having?: EventLogScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: EventLogCountAggregateInputType | true
    _min?: EventLogMinAggregateInputType
    _max?: EventLogMaxAggregateInputType
  }

  export type EventLogGroupByOutputType = {
    id: string
    type: string
    payload: string
    correlationId: string | null
    teamId: string | null
    occurredAt: Date
    _count: EventLogCountAggregateOutputType | null
    _min: EventLogMinAggregateOutputType | null
    _max: EventLogMaxAggregateOutputType | null
  }

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


  export type EventLogSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    type?: boolean
    payload?: boolean
    correlationId?: boolean
    teamId?: boolean
    occurredAt?: boolean
  }, ExtArgs["result"]["eventLog"]>

  export type EventLogSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    type?: boolean
    payload?: boolean
    correlationId?: boolean
    teamId?: boolean
    occurredAt?: boolean
  }, ExtArgs["result"]["eventLog"]>

  export type EventLogSelectScalar = {
    id?: boolean
    type?: boolean
    payload?: boolean
    correlationId?: boolean
    teamId?: boolean
    occurredAt?: boolean
  }


  export type $EventLogPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "EventLog"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: string
      type: string
      payload: string
      correlationId: string | null
      teamId: string | null
      occurredAt: Date
    }, ExtArgs["result"]["eventLog"]>
    composites: {}
  }

  type EventLogGetPayload<S extends boolean | null | undefined | EventLogDefaultArgs> = $Result.GetResult<Prisma.$EventLogPayload, S>

  type EventLogCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<EventLogFindManyArgs, 'select' | 'include' | 'distinct'> & {
      select?: EventLogCountAggregateInputType | true
    }

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

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

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

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

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

    /**
     * Create a EventLog.
     * @param {EventLogCreateArgs} args - Arguments to create a EventLog.
     * @example
     * // Create one EventLog
     * const EventLog = await prisma.eventLog.create({
     *   data: {
     *     // ... data to create a EventLog
     *   }
     * })
     * 
     */
    create<T extends EventLogCreateArgs>(args: SelectSubset<T, EventLogCreateArgs<ExtArgs>>): Prisma__EventLogClient<$Result.GetResult<Prisma.$EventLogPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

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

    /**
     * Delete a EventLog.
     * @param {EventLogDeleteArgs} args - Arguments to delete one EventLog.
     * @example
     * // Delete one EventLog
     * const EventLog = await prisma.eventLog.delete({
     *   where: {
     *     // ... filter to delete one EventLog
     *   }
     * })
     * 
     */
    delete<T extends EventLogDeleteArgs>(args: SelectSubset<T, EventLogDeleteArgs<ExtArgs>>): Prisma__EventLogClient<$Result.GetResult<Prisma.$EventLogPayload<ExtArgs>, T, "delete">, never, ExtArgs>

    /**
     * Update one EventLog.
     * @param {EventLogUpdateArgs} args - Arguments to update one EventLog.
     * @example
     * // Update one EventLog
     * const eventLog = await prisma.eventLog.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends EventLogUpdateArgs>(args: SelectSubset<T, EventLogUpdateArgs<ExtArgs>>): Prisma__EventLogClient<$Result.GetResult<Prisma.$EventLogPayload<ExtArgs>, T, "update">, never, ExtArgs>

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

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

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for EventLog.
   * 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__EventLogClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
    /**
     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
     * resolved value cannot be modified from the callback.
     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
     * @returns A Promise for the completion of the callback.
     */
    finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
  }




  /**
   * Fields of the EventLog model
   */ 
  interface EventLogFieldRefs {
    readonly id: FieldRef<"EventLog", 'String'>
    readonly type: FieldRef<"EventLog", 'String'>
    readonly payload: FieldRef<"EventLog", 'String'>
    readonly correlationId: FieldRef<"EventLog", 'String'>
    readonly teamId: FieldRef<"EventLog", 'String'>
    readonly occurredAt: FieldRef<"EventLog", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * EventLog findUnique
   */
  export type EventLogFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the EventLog
     */
    select?: EventLogSelect<ExtArgs> | null
    /**
     * Filter, which EventLog to fetch.
     */
    where: EventLogWhereUniqueInput
  }

  /**
   * EventLog findUniqueOrThrow
   */
  export type EventLogFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the EventLog
     */
    select?: EventLogSelect<ExtArgs> | null
    /**
     * Filter, which EventLog to fetch.
     */
    where: EventLogWhereUniqueInput
  }

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

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

  /**
   * EventLog findMany
   */
  export type EventLogFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the EventLog
     */
    select?: EventLogSelect<ExtArgs> | null
    /**
     * Filter, which EventLogs to fetch.
     */
    where?: EventLogWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of EventLogs to fetch.
     */
    orderBy?: EventLogOrderByWithRelationInput | EventLogOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing EventLogs.
     */
    cursor?: EventLogWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` EventLogs 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` EventLogs.
     */
    skip?: number
    distinct?: EventLogScalarFieldEnum | EventLogScalarFieldEnum[]
  }

  /**
   * EventLog create
   */
  export type EventLogCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the EventLog
     */
    select?: EventLogSelect<ExtArgs> | null
    /**
     * The data needed to create a EventLog.
     */
    data: XOR<EventLogCreateInput, EventLogUncheckedCreateInput>
  }

  /**
   * EventLog createMany
   */
  export type EventLogCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many EventLogs.
     */
    data: EventLogCreateManyInput | EventLogCreateManyInput[]
  }

  /**
   * EventLog createManyAndReturn
   */
  export type EventLogCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the EventLog
     */
    select?: EventLogSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many EventLogs.
     */
    data: EventLogCreateManyInput | EventLogCreateManyInput[]
  }

  /**
   * EventLog update
   */
  export type EventLogUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the EventLog
     */
    select?: EventLogSelect<ExtArgs> | null
    /**
     * The data needed to update a EventLog.
     */
    data: XOR<EventLogUpdateInput, EventLogUncheckedUpdateInput>
    /**
     * Choose, which EventLog to update.
     */
    where: EventLogWhereUniqueInput
  }

  /**
   * EventLog updateMany
   */
  export type EventLogUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update EventLogs.
     */
    data: XOR<EventLogUpdateManyMutationInput, EventLogUncheckedUpdateManyInput>
    /**
     * Filter which EventLogs to update
     */
    where?: EventLogWhereInput
  }

  /**
   * EventLog upsert
   */
  export type EventLogUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the EventLog
     */
    select?: EventLogSelect<ExtArgs> | null
    /**
     * The filter to search for the EventLog to update in case it exists.
     */
    where: EventLogWhereUniqueInput
    /**
     * In case the EventLog found by the `where` argument doesn't exist, create a new EventLog with this data.
     */
    create: XOR<EventLogCreateInput, EventLogUncheckedCreateInput>
    /**
     * In case the EventLog was found with the provided `where` argument, update it with this data.
     */
    update: XOR<EventLogUpdateInput, EventLogUncheckedUpdateInput>
  }

  /**
   * EventLog delete
   */
  export type EventLogDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the EventLog
     */
    select?: EventLogSelect<ExtArgs> | null
    /**
     * Filter which EventLog to delete.
     */
    where: EventLogWhereUniqueInput
  }

  /**
   * EventLog deleteMany
   */
  export type EventLogDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which EventLogs to delete
     */
    where?: EventLogWhereInput
  }

  /**
   * EventLog without action
   */
  export type EventLogDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the EventLog
     */
    select?: EventLogSelect<ExtArgs> | null
  }


  /**
   * Model Project
   */

  export type AggregateProject = {
    _count: ProjectCountAggregateOutputType | null
    _min: ProjectMinAggregateOutputType | null
    _max: ProjectMaxAggregateOutputType | null
  }

  export type ProjectMinAggregateOutputType = {
    id: string | null
    name: string | null
    teamId: string | null
    createdAt: Date | null
  }

  export type ProjectMaxAggregateOutputType = {
    id: string | null
    name: string | null
    teamId: string | null
    createdAt: Date | null
  }

  export type ProjectCountAggregateOutputType = {
    id: number
    name: number
    teamId: number
    createdAt: number
    _all: number
  }


  export type ProjectMinAggregateInputType = {
    id?: true
    name?: true
    teamId?: true
    createdAt?: true
  }

  export type ProjectMaxAggregateInputType = {
    id?: true
    name?: true
    teamId?: true
    createdAt?: true
  }

  export type ProjectCountAggregateInputType = {
    id?: true
    name?: true
    teamId?: true
    createdAt?: true
    _all?: true
  }

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

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




  export type ProjectGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: ProjectWhereInput
    orderBy?: ProjectOrderByWithAggregationInput | ProjectOrderByWithAggregationInput[]
    by: ProjectScalarFieldEnum[] | ProjectScalarFieldEnum
    having?: ProjectScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: ProjectCountAggregateInputType | true
    _min?: ProjectMinAggregateInputType
    _max?: ProjectMaxAggregateInputType
  }

  export type ProjectGroupByOutputType = {
    id: string
    name: string
    teamId: string | null
    createdAt: Date
    _count: ProjectCountAggregateOutputType | null
    _min: ProjectMinAggregateOutputType | null
    _max: ProjectMaxAggregateOutputType | null
  }

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


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

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

  export type ProjectSelectScalar = {
    id?: boolean
    name?: boolean
    teamId?: boolean
    createdAt?: boolean
  }


  export type $ProjectPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Project"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: string
      name: string
      teamId: string | null
      createdAt: Date
    }, ExtArgs["result"]["project"]>
    composites: {}
  }

  type ProjectGetPayload<S extends boolean | null | undefined | ProjectDefaultArgs> = $Result.GetResult<Prisma.$ProjectPayload, S>

  type ProjectCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<ProjectFindManyArgs, 'select' | 'include' | 'distinct'> & {
      select?: ProjectCountAggregateInputType | true
    }

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

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

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

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

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

    /**
     * Create a Project.
     * @param {ProjectCreateArgs} args - Arguments to create a Project.
     * @example
     * // Create one Project
     * const Project = await prisma.project.create({
     *   data: {
     *     // ... data to create a Project
     *   }
     * })
     * 
     */
    create<T extends ProjectCreateArgs>(args: SelectSubset<T, ProjectCreateArgs<ExtArgs>>): Prisma__ProjectClient<$Result.GetResult<Prisma.$ProjectPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

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

    /**
     * Delete a Project.
     * @param {ProjectDeleteArgs} args - Arguments to delete one Project.
     * @example
     * // Delete one Project
     * const Project = await prisma.project.delete({
     *   where: {
     *     // ... filter to delete one Project
     *   }
     * })
     * 
     */
    delete<T extends ProjectDeleteArgs>(args: SelectSubset<T, ProjectDeleteArgs<ExtArgs>>): Prisma__ProjectClient<$Result.GetResult<Prisma.$ProjectPayload<ExtArgs>, T, "delete">, never, ExtArgs>

    /**
     * Update one Project.
     * @param {ProjectUpdateArgs} args - Arguments to update one Project.
     * @example
     * // Update one Project
     * const project = await prisma.project.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends ProjectUpdateArgs>(args: SelectSubset<T, ProjectUpdateArgs<ExtArgs>>): Prisma__ProjectClient<$Result.GetResult<Prisma.$ProjectPayload<ExtArgs>, T, "update">, never, ExtArgs>

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

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

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for Project.
   * 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__ProjectClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
    /**
     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
     * resolved value cannot be modified from the callback.
     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
     * @returns A Promise for the completion of the callback.
     */
    finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
  }




  /**
   * Fields of the Project model
   */ 
  interface ProjectFieldRefs {
    readonly id: FieldRef<"Project", 'String'>
    readonly name: FieldRef<"Project", 'String'>
    readonly teamId: FieldRef<"Project", 'String'>
    readonly createdAt: FieldRef<"Project", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * Project findUnique
   */
  export type ProjectFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Project
     */
    select?: ProjectSelect<ExtArgs> | null
    /**
     * Filter, which Project to fetch.
     */
    where: ProjectWhereUniqueInput
  }

  /**
   * Project findUniqueOrThrow
   */
  export type ProjectFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Project
     */
    select?: ProjectSelect<ExtArgs> | null
    /**
     * Filter, which Project to fetch.
     */
    where: ProjectWhereUniqueInput
  }

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

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

  /**
   * Project findMany
   */
  export type ProjectFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Project
     */
    select?: ProjectSelect<ExtArgs> | null
    /**
     * Filter, which Projects to fetch.
     */
    where?: ProjectWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Projects to fetch.
     */
    orderBy?: ProjectOrderByWithRelationInput | ProjectOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing Projects.
     */
    cursor?: ProjectWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Projects 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` Projects.
     */
    skip?: number
    distinct?: ProjectScalarFieldEnum | ProjectScalarFieldEnum[]
  }

  /**
   * Project create
   */
  export type ProjectCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Project
     */
    select?: ProjectSelect<ExtArgs> | null
    /**
     * The data needed to create a Project.
     */
    data: XOR<ProjectCreateInput, ProjectUncheckedCreateInput>
  }

  /**
   * Project createMany
   */
  export type ProjectCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many Projects.
     */
    data: ProjectCreateManyInput | ProjectCreateManyInput[]
  }

  /**
   * Project createManyAndReturn
   */
  export type ProjectCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Project
     */
    select?: ProjectSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many Projects.
     */
    data: ProjectCreateManyInput | ProjectCreateManyInput[]
  }

  /**
   * Project update
   */
  export type ProjectUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Project
     */
    select?: ProjectSelect<ExtArgs> | null
    /**
     * The data needed to update a Project.
     */
    data: XOR<ProjectUpdateInput, ProjectUncheckedUpdateInput>
    /**
     * Choose, which Project to update.
     */
    where: ProjectWhereUniqueInput
  }

  /**
   * Project updateMany
   */
  export type ProjectUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Projects.
     */
    data: XOR<ProjectUpdateManyMutationInput, ProjectUncheckedUpdateManyInput>
    /**
     * Filter which Projects to update
     */
    where?: ProjectWhereInput
  }

  /**
   * Project upsert
   */
  export type ProjectUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Project
     */
    select?: ProjectSelect<ExtArgs> | null
    /**
     * The filter to search for the Project to update in case it exists.
     */
    where: ProjectWhereUniqueInput
    /**
     * In case the Project found by the `where` argument doesn't exist, create a new Project with this data.
     */
    create: XOR<ProjectCreateInput, ProjectUncheckedCreateInput>
    /**
     * In case the Project was found with the provided `where` argument, update it with this data.
     */
    update: XOR<ProjectUpdateInput, ProjectUncheckedUpdateInput>
  }

  /**
   * Project delete
   */
  export type ProjectDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Project
     */
    select?: ProjectSelect<ExtArgs> | null
    /**
     * Filter which Project to delete.
     */
    where: ProjectWhereUniqueInput
  }

  /**
   * Project deleteMany
   */
  export type ProjectDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Projects to delete
     */
    where?: ProjectWhereInput
  }

  /**
   * Project without action
   */
  export type ProjectDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Project
     */
    select?: ProjectSelect<ExtArgs> | null
  }


  /**
   * Enums
   */

  export const TransactionIsolationLevel: {
    Serializable: 'Serializable'
  };

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


  export const BuildScalarFieldEnum: {
    id: 'id',
    name: 'name',
    createdAt: 'createdAt',
    updatedAt: 'updatedAt'
  };

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


  export const SessionScalarFieldEnum: {
    id: 'id',
    build_id: 'build_id',
    name: 'name',
    status: 'status',
    desired_capabilities: 'desired_capabilities',
    session_capabilities: 'session_capabilities',
    node_id: 'node_id',
    has_live_video: 'has_live_video',
    video_recording_enabled: 'video_recording_enabled',
    video_recording: 'video_recording',
    startTime: 'startTime',
    endTime: 'endTime',
    failure_reason: 'failure_reason',
    is_profiling_available: 'is_profiling_available',
    device_info: 'device_info',
    device_udid: 'device_udid',
    device_platform: 'device_platform',
    device_version: 'device_version',
    device_name: 'device_name',
    createdAt: 'createdAt',
    updatedAt: 'updatedAt',
    performance_trace: 'performance_trace',
    failure_category: 'failure_category',
    ai_analysis: 'ai_analysis',
    tags: 'tags',
    trace_id: 'trace_id',
    last_heartbeat_at: 'last_heartbeat_at',
    heartbeat_pid: 'heartbeat_pid',
    heartbeat_host: 'heartbeat_host',
    api_key_id: 'api_key_id',
    user_id: 'user_id'
  };

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


  export const SessionLogScalarFieldEnum: {
    id: 'id',
    session_id: 'session_id',
    command_name: 'command_name',
    url: 'url',
    method: 'method',
    title: 'title',
    subtitle: 'subtitle',
    body: 'body',
    response: 'response',
    screenshot: 'screenshot',
    is_success: 'is_success',
    is_error: 'is_error',
    is_healed: 'is_healed',
    original_selector: 'original_selector',
    healed_selector: 'healed_selector',
    healing_confidence: 'healing_confidence',
    healing_tier: 'healing_tier',
    original_strategy: 'original_strategy',
    healed_strategy: 'healed_strategy',
    createdAt: 'createdAt',
    updatedAt: 'updatedAt',
    duration: 'duration',
    span_id: 'span_id',
    trace_id: 'trace_id'
  };

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


  export const LogScalarFieldEnum: {
    id: 'id',
    session_id: 'session_id',
    log_type: 'log_type',
    message: 'message',
    timestamp: 'timestamp',
    createdAt: 'createdAt',
    updatedAt: 'updatedAt'
  };

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


  export const ProfilingScalarFieldEnum: {
    id: 'id',
    session_id: 'session_id',
    cpu: 'cpu',
    memory: 'memory',
    total_cpu_used: 'total_cpu_used',
    total_memory_used: 'total_memory_used',
    raw_cpu_log: 'raw_cpu_log',
    raw_memory_log: 'raw_memory_log',
    timestamp: 'timestamp',
    createdAt: 'createdAt',
    updatedAt: 'updatedAt'
  };

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


  export const AppScalarFieldEnum: {
    id: 'id',
    name: 'name',
    filename: 'filename',
    filepath: 'filepath',
    mimetype: 'mimetype',
    size: 'size',
    packageName: 'packageName',
    version: 'version',
    platform: 'platform',
    md5: 'md5',
    createdAt: 'createdAt',
    updatedAt: 'updatedAt'
  };

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


  export const DeviceScalarFieldEnum: {
    udid: 'udid',
    host: 'host',
    systemPort: 'systemPort',
    proxyPort: 'proxyPort',
    proxyHost: 'proxyHost',
    wdaLocalPort: 'wdaLocalPort',
    name: 'name',
    state: 'state',
    sdk: 'sdk',
    platform: 'platform',
    deviceType: 'deviceType',
    busy: 'busy',
    userBlocked: 'userBlocked',
    realDevice: 'realDevice',
    session_id: 'session_id',
    offline: 'offline',
    mjpegServerPort: 'mjpegServerPort',
    lastCmdExecutedAt: 'lastCmdExecutedAt',
    totalUtilizationTimeMilliSec: 'totalUtilizationTimeMilliSec',
    sessionStartTime: 'sessionStartTime',
    newCommandTimeout: 'newCommandTimeout',
    cloud: 'cloud',
    derivedDataPath: 'derivedDataPath',
    chromeDriverPath: 'chromeDriverPath',
    capability: 'capability',
    adbRemoteHost: 'adbRemoteHost',
    adbPort: 'adbPort',
    nodeId: 'nodeId',
    screenWidth: 'screenWidth',
    screenHeight: 'screenHeight',
    dashboard_link: 'dashboard_link',
    total_session_count: 'total_session_count',
    createdAt: 'createdAt',
    updatedAt: 'updatedAt',
    healthCheckError: 'healthCheckError',
    healthStatus: 'healthStatus',
    lastHealthCheckAt: 'lastHealthCheckAt',
    batteryLevel: 'batteryLevel',
    reservationReason: 'reservationReason',
    reservedBy: 'reservedBy',
    reservedUntil: 'reservedUntil',
    storageFree: 'storageFree',
    tags: 'tags',
    thermalStatus: 'thermalStatus',
    sessionProgress: 'sessionProgress',
    totalHealedCount: 'totalHealedCount',
    ip: 'ip',
    cpuArchitecture: 'cpuArchitecture',
    owningSessionId: 'owningSessionId',
    lockedAt: 'lockedAt',
    teamId: 'teamId'
  };

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


  export const PendingSessionScalarFieldEnum: {
    id: 'id',
    capability_id: 'capability_id',
    capability: 'capability',
    createdAt: 'createdAt'
  };

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


  export const CLIArgsScalarFieldEnum: {
    id: 'id',
    args: 'args',
    createdAt: 'createdAt'
  };

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


  export const WebhookConfigScalarFieldEnum: {
    id: 'id',
    url: 'url',
    type: 'type',
    events: 'events',
    active: 'active',
    createdAt: 'createdAt',
    updatedAt: 'updatedAt',
    payloadTemplate: 'payloadTemplate'
  };

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


  export const WebConfigScalarFieldEnum: {
    id: 'id',
    name: 'name',
    value: 'value',
    createdAt: 'createdAt',
    updatedAt: 'updatedAt'
  };

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


  export const LocatorEtalonScalarFieldEnum: {
    id: 'id',
    selector: 'selector',
    strategy: 'strategy',
    attributes: 'attributes',
    nodeName: 'nodeName',
    lastSeen: 'lastSeen',
    createdAt: 'createdAt',
    updatedAt: 'updatedAt'
  };

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


  export const PortLeaseScalarFieldEnum: {
    port: 'port',
    purpose: 'purpose',
    leasedToUdid: 'leasedToUdid',
    leasedToHost: 'leasedToHost',
    leaseId: 'leaseId',
    leasedToPid: 'leasedToPid',
    leasedAt: 'leasedAt',
    expiresAt: 'expiresAt'
  };

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


  export const LeaseScalarFieldEnum: {
    id: 'id',
    tokenHash: 'tokenHash',
    deviceUdid: 'deviceUdid',
    deviceHost: 'deviceHost',
    actorId: 'actorId',
    teamId: 'teamId',
    buildId: 'buildId',
    reason: 'reason',
    status: 'status',
    createdAt: 'createdAt',
    expiresAt: 'expiresAt',
    heartbeatSeconds: 'heartbeatSeconds',
    lastHeartbeatAt: 'lastHeartbeatAt',
    allocatedPorts: 'allocatedPorts',
    capabilityBag: 'capabilityBag'
  };

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


  export const ApiKeyScalarFieldEnum: {
    id: 'id',
    name: 'name',
    keyHash: 'keyHash',
    scopes: 'scopes',
    rateLimit: 'rateLimit',
    createdAt: 'createdAt',
    revokedAt: 'revokedAt',
    lastUsedAt: 'lastUsedAt',
    expiresAt: 'expiresAt',
    teamId: 'teamId',
    role: 'role',
    userId: 'userId'
  };

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


  export const TeamScalarFieldEnum: {
    id: 'id',
    name: 'name',
    createdAt: 'createdAt'
  };

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


  export const SelectorStateScalarFieldEnum: {
    id: 'id',
    original_strategy: 'original_strategy',
    original_selector: 'original_selector',
    status: 'status',
    fixed_at: 'fixed_at',
    fixed_by_api_key: 'fixed_by_api_key',
    resolved_at: 'resolved_at',
    muted_at: 'muted_at',
    muted_by_api_key: 'muted_by_api_key',
    regression_count: 'regression_count',
    clean_builds_count: 'clean_builds_count',
    last_event_at: 'last_event_at',
    createdAt: 'createdAt',
    updatedAt: 'updatedAt'
  };

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


  export const RecordingScalarFieldEnum: {
    id: 'id',
    group_id: 'group_id',
    device_udid: 'device_udid',
    device_host: 'device_host',
    session_id: 'session_id',
    started_at: 'started_at',
    ended_at: 'ended_at',
    status: 'status',
    file_path: 'file_path',
    duration_ms: 'duration_ms',
    size_bytes: 'size_bytes',
    device_snapshot: 'device_snapshot',
    fail_reason: 'fail_reason'
  };

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


  export const BookmarkScalarFieldEnum: {
    id: 'id',
    recording_id: 'recording_id',
    timecode_ms: 'timecode_ms',
    label: 'label',
    note: 'note',
    created_at: 'created_at'
  };

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


  export const AnnotationScalarFieldEnum: {
    id: 'id',
    recording_id: 'recording_id',
    timecode_ms: 'timecode_ms',
    shape: 'shape',
    geometry: 'geometry',
    color: 'color',
    text: 'text',
    author: 'author',
    created_at: 'created_at'
  };

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


  export const UserScalarFieldEnum: {
    id: 'id',
    email: 'email',
    name: 'name',
    passwordHash: 'passwordHash',
    accessKey: 'accessKey',
    role: 'role',
    status: 'status',
    createdAt: 'createdAt',
    updatedAt: 'updatedAt',
    lastLoginAt: 'lastLoginAt',
    passwordChangedAt: 'passwordChangedAt'
  };

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


  export const UserSessionScalarFieldEnum: {
    id: 'id',
    userId: 'userId',
    createdAt: 'createdAt',
    expiresAt: 'expiresAt',
    lastSeenAt: 'lastSeenAt',
    userAgent: 'userAgent',
    ipHash: 'ipHash'
  };

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


  export const PasswordResetTokenScalarFieldEnum: {
    id: 'id',
    userId: 'userId',
    tokenHash: 'tokenHash',
    createdAt: 'createdAt',
    expiresAt: 'expiresAt',
    usedAt: 'usedAt'
  };

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


  export const TeamMemberScalarFieldEnum: {
    teamId: 'teamId',
    userId: 'userId',
    createdAt: 'createdAt'
  };

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


  export const EventLogScalarFieldEnum: {
    id: 'id',
    type: 'type',
    payload: 'payload',
    correlationId: 'correlationId',
    teamId: 'teamId',
    occurredAt: 'occurredAt'
  };

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


  export const ProjectScalarFieldEnum: {
    id: 'id',
    name: 'name',
    teamId: 'teamId',
    createdAt: 'createdAt'
  };

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


  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]


  /**
   * Field references 
   */


  /**
   * 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 'Boolean'
   */
  export type BooleanFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Boolean'>
    


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


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


  export type BuildWhereInput = {
    AND?: BuildWhereInput | BuildWhereInput[]
    OR?: BuildWhereInput[]
    NOT?: BuildWhereInput | BuildWhereInput[]
    id?: StringFilter<"Build"> | string
    name?: StringNullableFilter<"Build"> | string | null
    createdAt?: DateTimeFilter<"Build"> | Date | string
    updatedAt?: DateTimeFilter<"Build"> | Date | string
    sessions?: SessionListRelationFilter
  }

  export type BuildOrderByWithRelationInput = {
    id?: SortOrder
    name?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    sessions?: SessionOrderByRelationAggregateInput
  }

  export type BuildWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: BuildWhereInput | BuildWhereInput[]
    OR?: BuildWhereInput[]
    NOT?: BuildWhereInput | BuildWhereInput[]
    name?: StringNullableFilter<"Build"> | string | null
    createdAt?: DateTimeFilter<"Build"> | Date | string
    updatedAt?: DateTimeFilter<"Build"> | Date | string
    sessions?: SessionListRelationFilter
  }, "id">

  export type BuildOrderByWithAggregationInput = {
    id?: SortOrder
    name?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    _count?: BuildCountOrderByAggregateInput
    _max?: BuildMaxOrderByAggregateInput
    _min?: BuildMinOrderByAggregateInput
  }

  export type BuildScalarWhereWithAggregatesInput = {
    AND?: BuildScalarWhereWithAggregatesInput | BuildScalarWhereWithAggregatesInput[]
    OR?: BuildScalarWhereWithAggregatesInput[]
    NOT?: BuildScalarWhereWithAggregatesInput | BuildScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"Build"> | string
    name?: StringNullableWithAggregatesFilter<"Build"> | string | null
    createdAt?: DateTimeWithAggregatesFilter<"Build"> | Date | string
    updatedAt?: DateTimeWithAggregatesFilter<"Build"> | Date | string
  }

  export type SessionWhereInput = {
    AND?: SessionWhereInput | SessionWhereInput[]
    OR?: SessionWhereInput[]
    NOT?: SessionWhereInput | SessionWhereInput[]
    id?: StringFilter<"Session"> | string
    build_id?: StringNullableFilter<"Session"> | string | null
    name?: StringNullableFilter<"Session"> | string | null
    status?: StringFilter<"Session"> | string
    desired_capabilities?: StringFilter<"Session"> | string
    session_capabilities?: StringFilter<"Session"> | string
    node_id?: StringFilter<"Session"> | string
    has_live_video?: BoolFilter<"Session"> | boolean
    video_recording_enabled?: BoolFilter<"Session"> | boolean
    video_recording?: StringNullableFilter<"Session"> | string | null
    startTime?: DateTimeFilter<"Session"> | Date | string
    endTime?: DateTimeNullableFilter<"Session"> | Date | string | null
    failure_reason?: StringNullableFilter<"Session"> | string | null
    is_profiling_available?: BoolFilter<"Session"> | boolean
    device_info?: StringNullableFilter<"Session"> | string | null
    device_udid?: StringFilter<"Session"> | string
    device_platform?: StringFilter<"Session"> | string
    device_version?: StringFilter<"Session"> | string
    device_name?: StringNullableFilter<"Session"> | string | null
    createdAt?: DateTimeFilter<"Session"> | Date | string
    updatedAt?: DateTimeFilter<"Session"> | Date | string
    performance_trace?: StringNullableFilter<"Session"> | string | null
    failure_category?: StringNullableFilter<"Session"> | string | null
    ai_analysis?: StringNullableFilter<"Session"> | string | null
    tags?: StringNullableFilter<"Session"> | string | null
    trace_id?: StringNullableFilter<"Session"> | string | null
    last_heartbeat_at?: DateTimeNullableFilter<"Session"> | Date | string | null
    heartbeat_pid?: IntNullableFilter<"Session"> | number | null
    heartbeat_host?: StringNullableFilter<"Session"> | string | null
    api_key_id?: StringNullableFilter<"Session"> | string | null
    user_id?: StringNullableFilter<"Session"> | string | null
    Log?: LogListRelationFilter
    Profiling?: ProfilingListRelationFilter
    build?: XOR<BuildNullableRelationFilter, BuildWhereInput> | null
    SessionLog?: SessionLogListRelationFilter
    Recording?: RecordingListRelationFilter
  }

  export type SessionOrderByWithRelationInput = {
    id?: SortOrder
    build_id?: SortOrderInput | SortOrder
    name?: SortOrderInput | SortOrder
    status?: SortOrder
    desired_capabilities?: SortOrder
    session_capabilities?: SortOrder
    node_id?: SortOrder
    has_live_video?: SortOrder
    video_recording_enabled?: SortOrder
    video_recording?: SortOrderInput | SortOrder
    startTime?: SortOrder
    endTime?: SortOrderInput | SortOrder
    failure_reason?: SortOrderInput | SortOrder
    is_profiling_available?: SortOrder
    device_info?: SortOrderInput | SortOrder
    device_udid?: SortOrder
    device_platform?: SortOrder
    device_version?: SortOrder
    device_name?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    performance_trace?: SortOrderInput | SortOrder
    failure_category?: SortOrderInput | SortOrder
    ai_analysis?: SortOrderInput | SortOrder
    tags?: SortOrderInput | SortOrder
    trace_id?: SortOrderInput | SortOrder
    last_heartbeat_at?: SortOrderInput | SortOrder
    heartbeat_pid?: SortOrderInput | SortOrder
    heartbeat_host?: SortOrderInput | SortOrder
    api_key_id?: SortOrderInput | SortOrder
    user_id?: SortOrderInput | SortOrder
    Log?: LogOrderByRelationAggregateInput
    Profiling?: ProfilingOrderByRelationAggregateInput
    build?: BuildOrderByWithRelationInput
    SessionLog?: SessionLogOrderByRelationAggregateInput
    Recording?: RecordingOrderByRelationAggregateInput
  }

  export type SessionWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: SessionWhereInput | SessionWhereInput[]
    OR?: SessionWhereInput[]
    NOT?: SessionWhereInput | SessionWhereInput[]
    build_id?: StringNullableFilter<"Session"> | string | null
    name?: StringNullableFilter<"Session"> | string | null
    status?: StringFilter<"Session"> | string
    desired_capabilities?: StringFilter<"Session"> | string
    session_capabilities?: StringFilter<"Session"> | string
    node_id?: StringFilter<"Session"> | string
    has_live_video?: BoolFilter<"Session"> | boolean
    video_recording_enabled?: BoolFilter<"Session"> | boolean
    video_recording?: StringNullableFilter<"Session"> | string | null
    startTime?: DateTimeFilter<"Session"> | Date | string
    endTime?: DateTimeNullableFilter<"Session"> | Date | string | null
    failure_reason?: StringNullableFilter<"Session"> | string | null
    is_profiling_available?: BoolFilter<"Session"> | boolean
    device_info?: StringNullableFilter<"Session"> | string | null
    device_udid?: StringFilter<"Session"> | string
    device_platform?: StringFilter<"Session"> | string
    device_version?: StringFilter<"Session"> | string
    device_name?: StringNullableFilter<"Session"> | string | null
    createdAt?: DateTimeFilter<"Session"> | Date | string
    updatedAt?: DateTimeFilter<"Session"> | Date | string
    performance_trace?: StringNullableFilter<"Session"> | string | null
    failure_category?: StringNullableFilter<"Session"> | string | null
    ai_analysis?: StringNullableFilter<"Session"> | string | null
    tags?: StringNullableFilter<"Session"> | string | null
    trace_id?: StringNullableFilter<"Session"> | string | null
    last_heartbeat_at?: DateTimeNullableFilter<"Session"> | Date | string | null
    heartbeat_pid?: IntNullableFilter<"Session"> | number | null
    heartbeat_host?: StringNullableFilter<"Session"> | string | null
    api_key_id?: StringNullableFilter<"Session"> | string | null
    user_id?: StringNullableFilter<"Session"> | string | null
    Log?: LogListRelationFilter
    Profiling?: ProfilingListRelationFilter
    build?: XOR<BuildNullableRelationFilter, BuildWhereInput> | null
    SessionLog?: SessionLogListRelationFilter
    Recording?: RecordingListRelationFilter
  }, "id">

  export type SessionOrderByWithAggregationInput = {
    id?: SortOrder
    build_id?: SortOrderInput | SortOrder
    name?: SortOrderInput | SortOrder
    status?: SortOrder
    desired_capabilities?: SortOrder
    session_capabilities?: SortOrder
    node_id?: SortOrder
    has_live_video?: SortOrder
    video_recording_enabled?: SortOrder
    video_recording?: SortOrderInput | SortOrder
    startTime?: SortOrder
    endTime?: SortOrderInput | SortOrder
    failure_reason?: SortOrderInput | SortOrder
    is_profiling_available?: SortOrder
    device_info?: SortOrderInput | SortOrder
    device_udid?: SortOrder
    device_platform?: SortOrder
    device_version?: SortOrder
    device_name?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    performance_trace?: SortOrderInput | SortOrder
    failure_category?: SortOrderInput | SortOrder
    ai_analysis?: SortOrderInput | SortOrder
    tags?: SortOrderInput | SortOrder
    trace_id?: SortOrderInput | SortOrder
    last_heartbeat_at?: SortOrderInput | SortOrder
    heartbeat_pid?: SortOrderInput | SortOrder
    heartbeat_host?: SortOrderInput | SortOrder
    api_key_id?: SortOrderInput | SortOrder
    user_id?: SortOrderInput | SortOrder
    _count?: SessionCountOrderByAggregateInput
    _avg?: SessionAvgOrderByAggregateInput
    _max?: SessionMaxOrderByAggregateInput
    _min?: SessionMinOrderByAggregateInput
    _sum?: SessionSumOrderByAggregateInput
  }

  export type SessionScalarWhereWithAggregatesInput = {
    AND?: SessionScalarWhereWithAggregatesInput | SessionScalarWhereWithAggregatesInput[]
    OR?: SessionScalarWhereWithAggregatesInput[]
    NOT?: SessionScalarWhereWithAggregatesInput | SessionScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"Session"> | string
    build_id?: StringNullableWithAggregatesFilter<"Session"> | string | null
    name?: StringNullableWithAggregatesFilter<"Session"> | string | null
    status?: StringWithAggregatesFilter<"Session"> | string
    desired_capabilities?: StringWithAggregatesFilter<"Session"> | string
    session_capabilities?: StringWithAggregatesFilter<"Session"> | string
    node_id?: StringWithAggregatesFilter<"Session"> | string
    has_live_video?: BoolWithAggregatesFilter<"Session"> | boolean
    video_recording_enabled?: BoolWithAggregatesFilter<"Session"> | boolean
    video_recording?: StringNullableWithAggregatesFilter<"Session"> | string | null
    startTime?: DateTimeWithAggregatesFilter<"Session"> | Date | string
    endTime?: DateTimeNullableWithAggregatesFilter<"Session"> | Date | string | null
    failure_reason?: StringNullableWithAggregatesFilter<"Session"> | string | null
    is_profiling_available?: BoolWithAggregatesFilter<"Session"> | boolean
    device_info?: StringNullableWithAggregatesFilter<"Session"> | string | null
    device_udid?: StringWithAggregatesFilter<"Session"> | string
    device_platform?: StringWithAggregatesFilter<"Session"> | string
    device_version?: StringWithAggregatesFilter<"Session"> | string
    device_name?: StringNullableWithAggregatesFilter<"Session"> | string | null
    createdAt?: DateTimeWithAggregatesFilter<"Session"> | Date | string
    updatedAt?: DateTimeWithAggregatesFilter<"Session"> | Date | string
    performance_trace?: StringNullableWithAggregatesFilter<"Session"> | string | null
    failure_category?: StringNullableWithAggregatesFilter<"Session"> | string | null
    ai_analysis?: StringNullableWithAggregatesFilter<"Session"> | string | null
    tags?: StringNullableWithAggregatesFilter<"Session"> | string | null
    trace_id?: StringNullableWithAggregatesFilter<"Session"> | string | null
    last_heartbeat_at?: DateTimeNullableWithAggregatesFilter<"Session"> | Date | string | null
    heartbeat_pid?: IntNullableWithAggregatesFilter<"Session"> | number | null
    heartbeat_host?: StringNullableWithAggregatesFilter<"Session"> | string | null
    api_key_id?: StringNullableWithAggregatesFilter<"Session"> | string | null
    user_id?: StringNullableWithAggregatesFilter<"Session"> | string | null
  }

  export type SessionLogWhereInput = {
    AND?: SessionLogWhereInput | SessionLogWhereInput[]
    OR?: SessionLogWhereInput[]
    NOT?: SessionLogWhereInput | SessionLogWhereInput[]
    id?: StringFilter<"SessionLog"> | string
    session_id?: StringFilter<"SessionLog"> | string
    command_name?: StringNullableFilter<"SessionLog"> | string | null
    url?: StringFilter<"SessionLog"> | string
    method?: StringFilter<"SessionLog"> | string
    title?: StringFilter<"SessionLog"> | string
    subtitle?: StringNullableFilter<"SessionLog"> | string | null
    body?: StringNullableFilter<"SessionLog"> | string | null
    response?: StringFilter<"SessionLog"> | string
    screenshot?: StringNullableFilter<"SessionLog"> | string | null
    is_success?: BoolNullableFilter<"SessionLog"> | boolean | null
    is_error?: BoolFilter<"SessionLog"> | boolean
    is_healed?: BoolFilter<"SessionLog"> | boolean
    original_selector?: StringNullableFilter<"SessionLog"> | string | null
    healed_selector?: StringNullableFilter<"SessionLog"> | string | null
    healing_confidence?: FloatNullableFilter<"SessionLog"> | number | null
    healing_tier?: StringNullableFilter<"SessionLog"> | string | null
    original_strategy?: StringNullableFilter<"SessionLog"> | string | null
    healed_strategy?: StringNullableFilter<"SessionLog"> | string | null
    createdAt?: DateTimeFilter<"SessionLog"> | Date | string
    updatedAt?: DateTimeFilter<"SessionLog"> | Date | string
    duration?: IntNullableFilter<"SessionLog"> | number | null
    span_id?: StringNullableFilter<"SessionLog"> | string | null
    trace_id?: StringNullableFilter<"SessionLog"> | string | null
    session?: XOR<SessionRelationFilter, SessionWhereInput>
  }

  export type SessionLogOrderByWithRelationInput = {
    id?: SortOrder
    session_id?: SortOrder
    command_name?: SortOrderInput | SortOrder
    url?: SortOrder
    method?: SortOrder
    title?: SortOrder
    subtitle?: SortOrderInput | SortOrder
    body?: SortOrderInput | SortOrder
    response?: SortOrder
    screenshot?: SortOrderInput | SortOrder
    is_success?: SortOrderInput | SortOrder
    is_error?: SortOrder
    is_healed?: SortOrder
    original_selector?: SortOrderInput | SortOrder
    healed_selector?: SortOrderInput | SortOrder
    healing_confidence?: SortOrderInput | SortOrder
    healing_tier?: SortOrderInput | SortOrder
    original_strategy?: SortOrderInput | SortOrder
    healed_strategy?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    duration?: SortOrderInput | SortOrder
    span_id?: SortOrderInput | SortOrder
    trace_id?: SortOrderInput | SortOrder
    session?: SessionOrderByWithRelationInput
  }

  export type SessionLogWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: SessionLogWhereInput | SessionLogWhereInput[]
    OR?: SessionLogWhereInput[]
    NOT?: SessionLogWhereInput | SessionLogWhereInput[]
    session_id?: StringFilter<"SessionLog"> | string
    command_name?: StringNullableFilter<"SessionLog"> | string | null
    url?: StringFilter<"SessionLog"> | string
    method?: StringFilter<"SessionLog"> | string
    title?: StringFilter<"SessionLog"> | string
    subtitle?: StringNullableFilter<"SessionLog"> | string | null
    body?: StringNullableFilter<"SessionLog"> | string | null
    response?: StringFilter<"SessionLog"> | string
    screenshot?: StringNullableFilter<"SessionLog"> | string | null
    is_success?: BoolNullableFilter<"SessionLog"> | boolean | null
    is_error?: BoolFilter<"SessionLog"> | boolean
    is_healed?: BoolFilter<"SessionLog"> | boolean
    original_selector?: StringNullableFilter<"SessionLog"> | string | null
    healed_selector?: StringNullableFilter<"SessionLog"> | string | null
    healing_confidence?: FloatNullableFilter<"SessionLog"> | number | null
    healing_tier?: StringNullableFilter<"SessionLog"> | string | null
    original_strategy?: StringNullableFilter<"SessionLog"> | string | null
    healed_strategy?: StringNullableFilter<"SessionLog"> | string | null
    createdAt?: DateTimeFilter<"SessionLog"> | Date | string
    updatedAt?: DateTimeFilter<"SessionLog"> | Date | string
    duration?: IntNullableFilter<"SessionLog"> | number | null
    span_id?: StringNullableFilter<"SessionLog"> | string | null
    trace_id?: StringNullableFilter<"SessionLog"> | string | null
    session?: XOR<SessionRelationFilter, SessionWhereInput>
  }, "id">

  export type SessionLogOrderByWithAggregationInput = {
    id?: SortOrder
    session_id?: SortOrder
    command_name?: SortOrderInput | SortOrder
    url?: SortOrder
    method?: SortOrder
    title?: SortOrder
    subtitle?: SortOrderInput | SortOrder
    body?: SortOrderInput | SortOrder
    response?: SortOrder
    screenshot?: SortOrderInput | SortOrder
    is_success?: SortOrderInput | SortOrder
    is_error?: SortOrder
    is_healed?: SortOrder
    original_selector?: SortOrderInput | SortOrder
    healed_selector?: SortOrderInput | SortOrder
    healing_confidence?: SortOrderInput | SortOrder
    healing_tier?: SortOrderInput | SortOrder
    original_strategy?: SortOrderInput | SortOrder
    healed_strategy?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    duration?: SortOrderInput | SortOrder
    span_id?: SortOrderInput | SortOrder
    trace_id?: SortOrderInput | SortOrder
    _count?: SessionLogCountOrderByAggregateInput
    _avg?: SessionLogAvgOrderByAggregateInput
    _max?: SessionLogMaxOrderByAggregateInput
    _min?: SessionLogMinOrderByAggregateInput
    _sum?: SessionLogSumOrderByAggregateInput
  }

  export type SessionLogScalarWhereWithAggregatesInput = {
    AND?: SessionLogScalarWhereWithAggregatesInput | SessionLogScalarWhereWithAggregatesInput[]
    OR?: SessionLogScalarWhereWithAggregatesInput[]
    NOT?: SessionLogScalarWhereWithAggregatesInput | SessionLogScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"SessionLog"> | string
    session_id?: StringWithAggregatesFilter<"SessionLog"> | string
    command_name?: StringNullableWithAggregatesFilter<"SessionLog"> | string | null
    url?: StringWithAggregatesFilter<"SessionLog"> | string
    method?: StringWithAggregatesFilter<"SessionLog"> | string
    title?: StringWithAggregatesFilter<"SessionLog"> | string
    subtitle?: StringNullableWithAggregatesFilter<"SessionLog"> | string | null
    body?: StringNullableWithAggregatesFilter<"SessionLog"> | string | null
    response?: StringWithAggregatesFilter<"SessionLog"> | string
    screenshot?: StringNullableWithAggregatesFilter<"SessionLog"> | string | null
    is_success?: BoolNullableWithAggregatesFilter<"SessionLog"> | boolean | null
    is_error?: BoolWithAggregatesFilter<"SessionLog"> | boolean
    is_healed?: BoolWithAggregatesFilter<"SessionLog"> | boolean
    original_selector?: StringNullableWithAggregatesFilter<"SessionLog"> | string | null
    healed_selector?: StringNullableWithAggregatesFilter<"SessionLog"> | string | null
    healing_confidence?: FloatNullableWithAggregatesFilter<"SessionLog"> | number | null
    healing_tier?: StringNullableWithAggregatesFilter<"SessionLog"> | string | null
    original_strategy?: StringNullableWithAggregatesFilter<"SessionLog"> | string | null
    healed_strategy?: StringNullableWithAggregatesFilter<"SessionLog"> | string | null
    createdAt?: DateTimeWithAggregatesFilter<"SessionLog"> | Date | string
    updatedAt?: DateTimeWithAggregatesFilter<"SessionLog"> | Date | string
    duration?: IntNullableWithAggregatesFilter<"SessionLog"> | number | null
    span_id?: StringNullableWithAggregatesFilter<"SessionLog"> | string | null
    trace_id?: StringNullableWithAggregatesFilter<"SessionLog"> | string | null
  }

  export type LogWhereInput = {
    AND?: LogWhereInput | LogWhereInput[]
    OR?: LogWhereInput[]
    NOT?: LogWhereInput | LogWhereInput[]
    id?: StringFilter<"Log"> | string
    session_id?: StringFilter<"Log"> | string
    log_type?: StringFilter<"Log"> | string
    message?: StringFilter<"Log"> | string
    timestamp?: DateTimeFilter<"Log"> | Date | string
    createdAt?: DateTimeFilter<"Log"> | Date | string
    updatedAt?: DateTimeFilter<"Log"> | Date | string
    session?: XOR<SessionRelationFilter, SessionWhereInput>
  }

  export type LogOrderByWithRelationInput = {
    id?: SortOrder
    session_id?: SortOrder
    log_type?: SortOrder
    message?: SortOrder
    timestamp?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    session?: SessionOrderByWithRelationInput
  }

  export type LogWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: LogWhereInput | LogWhereInput[]
    OR?: LogWhereInput[]
    NOT?: LogWhereInput | LogWhereInput[]
    session_id?: StringFilter<"Log"> | string
    log_type?: StringFilter<"Log"> | string
    message?: StringFilter<"Log"> | string
    timestamp?: DateTimeFilter<"Log"> | Date | string
    createdAt?: DateTimeFilter<"Log"> | Date | string
    updatedAt?: DateTimeFilter<"Log"> | Date | string
    session?: XOR<SessionRelationFilter, SessionWhereInput>
  }, "id">

  export type LogOrderByWithAggregationInput = {
    id?: SortOrder
    session_id?: SortOrder
    log_type?: SortOrder
    message?: SortOrder
    timestamp?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    _count?: LogCountOrderByAggregateInput
    _max?: LogMaxOrderByAggregateInput
    _min?: LogMinOrderByAggregateInput
  }

  export type LogScalarWhereWithAggregatesInput = {
    AND?: LogScalarWhereWithAggregatesInput | LogScalarWhereWithAggregatesInput[]
    OR?: LogScalarWhereWithAggregatesInput[]
    NOT?: LogScalarWhereWithAggregatesInput | LogScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"Log"> | string
    session_id?: StringWithAggregatesFilter<"Log"> | string
    log_type?: StringWithAggregatesFilter<"Log"> | string
    message?: StringWithAggregatesFilter<"Log"> | string
    timestamp?: DateTimeWithAggregatesFilter<"Log"> | Date | string
    createdAt?: DateTimeWithAggregatesFilter<"Log"> | Date | string
    updatedAt?: DateTimeWithAggregatesFilter<"Log"> | Date | string
  }

  export type ProfilingWhereInput = {
    AND?: ProfilingWhereInput | ProfilingWhereInput[]
    OR?: ProfilingWhereInput[]
    NOT?: ProfilingWhereInput | ProfilingWhereInput[]
    id?: IntFilter<"Profiling"> | number
    session_id?: StringFilter<"Profiling"> | string
    cpu?: StringNullableFilter<"Profiling"> | string | null
    memory?: StringNullableFilter<"Profiling"> | string | null
    total_cpu_used?: StringNullableFilter<"Profiling"> | string | null
    total_memory_used?: StringNullableFilter<"Profiling"> | string | null
    raw_cpu_log?: StringNullableFilter<"Profiling"> | string | null
    raw_memory_log?: StringNullableFilter<"Profiling"> | string | null
    timestamp?: DateTimeFilter<"Profiling"> | Date | string
    createdAt?: DateTimeFilter<"Profiling"> | Date | string
    updatedAt?: DateTimeFilter<"Profiling"> | Date | string
    session?: XOR<SessionRelationFilter, SessionWhereInput>
  }

  export type ProfilingOrderByWithRelationInput = {
    id?: SortOrder
    session_id?: SortOrder
    cpu?: SortOrderInput | SortOrder
    memory?: SortOrderInput | SortOrder
    total_cpu_used?: SortOrderInput | SortOrder
    total_memory_used?: SortOrderInput | SortOrder
    raw_cpu_log?: SortOrderInput | SortOrder
    raw_memory_log?: SortOrderInput | SortOrder
    timestamp?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    session?: SessionOrderByWithRelationInput
  }

  export type ProfilingWhereUniqueInput = Prisma.AtLeast<{
    id?: number
    AND?: ProfilingWhereInput | ProfilingWhereInput[]
    OR?: ProfilingWhereInput[]
    NOT?: ProfilingWhereInput | ProfilingWhereInput[]
    session_id?: StringFilter<"Profiling"> | string
    cpu?: StringNullableFilter<"Profiling"> | string | null
    memory?: StringNullableFilter<"Profiling"> | string | null
    total_cpu_used?: StringNullableFilter<"Profiling"> | string | null
    total_memory_used?: StringNullableFilter<"Profiling"> | string | null
    raw_cpu_log?: StringNullableFilter<"Profiling"> | string | null
    raw_memory_log?: StringNullableFilter<"Profiling"> | string | null
    timestamp?: DateTimeFilter<"Profiling"> | Date | string
    createdAt?: DateTimeFilter<"Profiling"> | Date | string
    updatedAt?: DateTimeFilter<"Profiling"> | Date | string
    session?: XOR<SessionRelationFilter, SessionWhereInput>
  }, "id">

  export type ProfilingOrderByWithAggregationInput = {
    id?: SortOrder
    session_id?: SortOrder
    cpu?: SortOrderInput | SortOrder
    memory?: SortOrderInput | SortOrder
    total_cpu_used?: SortOrderInput | SortOrder
    total_memory_used?: SortOrderInput | SortOrder
    raw_cpu_log?: SortOrderInput | SortOrder
    raw_memory_log?: SortOrderInput | SortOrder
    timestamp?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    _count?: ProfilingCountOrderByAggregateInput
    _avg?: ProfilingAvgOrderByAggregateInput
    _max?: ProfilingMaxOrderByAggregateInput
    _min?: ProfilingMinOrderByAggregateInput
    _sum?: ProfilingSumOrderByAggregateInput
  }

  export type ProfilingScalarWhereWithAggregatesInput = {
    AND?: ProfilingScalarWhereWithAggregatesInput | ProfilingScalarWhereWithAggregatesInput[]
    OR?: ProfilingScalarWhereWithAggregatesInput[]
    NOT?: ProfilingScalarWhereWithAggregatesInput | ProfilingScalarWhereWithAggregatesInput[]
    id?: IntWithAggregatesFilter<"Profiling"> | number
    session_id?: StringWithAggregatesFilter<"Profiling"> | string
    cpu?: StringNullableWithAggregatesFilter<"Profiling"> | string | null
    memory?: StringNullableWithAggregatesFilter<"Profiling"> | string | null
    total_cpu_used?: StringNullableWithAggregatesFilter<"Profiling"> | string | null
    total_memory_used?: StringNullableWithAggregatesFilter<"Profiling"> | string | null
    raw_cpu_log?: StringNullableWithAggregatesFilter<"Profiling"> | string | null
    raw_memory_log?: StringNullableWithAggregatesFilter<"Profiling"> | string | null
    timestamp?: DateTimeWithAggregatesFilter<"Profiling"> | Date | string
    createdAt?: DateTimeWithAggregatesFilter<"Profiling"> | Date | string
    updatedAt?: DateTimeWithAggregatesFilter<"Profiling"> | Date | string
  }

  export type AppWhereInput = {
    AND?: AppWhereInput | AppWhereInput[]
    OR?: AppWhereInput[]
    NOT?: AppWhereInput | AppWhereInput[]
    id?: StringFilter<"App"> | string
    name?: StringFilter<"App"> | string
    filename?: StringFilter<"App"> | string
    filepath?: StringFilter<"App"> | string
    mimetype?: StringFilter<"App"> | string
    size?: IntFilter<"App"> | number
    packageName?: StringNullableFilter<"App"> | string | null
    version?: StringNullableFilter<"App"> | string | null
    platform?: StringNullableFilter<"App"> | string | null
    md5?: StringNullableFilter<"App"> | string | null
    createdAt?: DateTimeFilter<"App"> | Date | string
    updatedAt?: DateTimeFilter<"App"> | Date | string
  }

  export type AppOrderByWithRelationInput = {
    id?: SortOrder
    name?: SortOrder
    filename?: SortOrder
    filepath?: SortOrder
    mimetype?: SortOrder
    size?: SortOrder
    packageName?: SortOrderInput | SortOrder
    version?: SortOrderInput | SortOrder
    platform?: SortOrderInput | SortOrder
    md5?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type AppWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    md5?: string
    AND?: AppWhereInput | AppWhereInput[]
    OR?: AppWhereInput[]
    NOT?: AppWhereInput | AppWhereInput[]
    name?: StringFilter<"App"> | string
    filename?: StringFilter<"App"> | string
    filepath?: StringFilter<"App"> | string
    mimetype?: StringFilter<"App"> | string
    size?: IntFilter<"App"> | number
    packageName?: StringNullableFilter<"App"> | string | null
    version?: StringNullableFilter<"App"> | string | null
    platform?: StringNullableFilter<"App"> | string | null
    createdAt?: DateTimeFilter<"App"> | Date | string
    updatedAt?: DateTimeFilter<"App"> | Date | string
  }, "id" | "md5">

  export type AppOrderByWithAggregationInput = {
    id?: SortOrder
    name?: SortOrder
    filename?: SortOrder
    filepath?: SortOrder
    mimetype?: SortOrder
    size?: SortOrder
    packageName?: SortOrderInput | SortOrder
    version?: SortOrderInput | SortOrder
    platform?: SortOrderInput | SortOrder
    md5?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    _count?: AppCountOrderByAggregateInput
    _avg?: AppAvgOrderByAggregateInput
    _max?: AppMaxOrderByAggregateInput
    _min?: AppMinOrderByAggregateInput
    _sum?: AppSumOrderByAggregateInput
  }

  export type AppScalarWhereWithAggregatesInput = {
    AND?: AppScalarWhereWithAggregatesInput | AppScalarWhereWithAggregatesInput[]
    OR?: AppScalarWhereWithAggregatesInput[]
    NOT?: AppScalarWhereWithAggregatesInput | AppScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"App"> | string
    name?: StringWithAggregatesFilter<"App"> | string
    filename?: StringWithAggregatesFilter<"App"> | string
    filepath?: StringWithAggregatesFilter<"App"> | string
    mimetype?: StringWithAggregatesFilter<"App"> | string
    size?: IntWithAggregatesFilter<"App"> | number
    packageName?: StringNullableWithAggregatesFilter<"App"> | string | null
    version?: StringNullableWithAggregatesFilter<"App"> | string | null
    platform?: StringNullableWithAggregatesFilter<"App"> | string | null
    md5?: StringNullableWithAggregatesFilter<"App"> | string | null
    createdAt?: DateTimeWithAggregatesFilter<"App"> | Date | string
    updatedAt?: DateTimeWithAggregatesFilter<"App"> | Date | string
  }

  export type DeviceWhereInput = {
    AND?: DeviceWhereInput | DeviceWhereInput[]
    OR?: DeviceWhereInput[]
    NOT?: DeviceWhereInput | DeviceWhereInput[]
    udid?: StringFilter<"Device"> | string
    host?: StringFilter<"Device"> | string
    systemPort?: IntNullableFilter<"Device"> | number | null
    proxyPort?: IntNullableFilter<"Device"> | number | null
    proxyHost?: StringNullableFilter<"Device"> | string | null
    wdaLocalPort?: IntNullableFilter<"Device"> | number | null
    name?: StringNullableFilter<"Device"> | string | null
    state?: StringNullableFilter<"Device"> | string | null
    sdk?: StringNullableFilter<"Device"> | string | null
    platform?: StringNullableFilter<"Device"> | string | null
    deviceType?: StringNullableFilter<"Device"> | string | null
    busy?: BoolNullableFilter<"Device"> | boolean | null
    userBlocked?: BoolNullableFilter<"Device"> | boolean | null
    realDevice?: BoolNullableFilter<"Device"> | boolean | null
    session_id?: StringNullableFilter<"Device"> | string | null
    offline?: BoolNullableFilter<"Device"> | boolean | null
    mjpegServerPort?: IntNullableFilter<"Device"> | number | null
    lastCmdExecutedAt?: FloatNullableFilter<"Device"> | number | null
    totalUtilizationTimeMilliSec?: FloatFilter<"Device"> | number
    sessionStartTime?: FloatFilter<"Device"> | number
    newCommandTimeout?: IntNullableFilter<"Device"> | number | null
    cloud?: StringNullableFilter<"Device"> | string | null
    derivedDataPath?: StringNullableFilter<"Device"> | string | null
    chromeDriverPath?: StringNullableFilter<"Device"> | string | null
    capability?: StringNullableFilter<"Device"> | string | null
    adbRemoteHost?: StringNullableFilter<"Device"> | string | null
    adbPort?: IntNullableFilter<"Device"> | number | null
    nodeId?: StringNullableFilter<"Device"> | string | null
    screenWidth?: StringNullableFilter<"Device"> | string | null
    screenHeight?: StringNullableFilter<"Device"> | string | null
    dashboard_link?: StringNullableFilter<"Device"> | string | null
    total_session_count?: IntNullableFilter<"Device"> | number | null
    createdAt?: DateTimeFilter<"Device"> | Date | string
    updatedAt?: DateTimeFilter<"Device"> | Date | string
    healthCheckError?: StringNullableFilter<"Device"> | string | null
    healthStatus?: StringNullableFilter<"Device"> | string | null
    lastHealthCheckAt?: FloatNullableFilter<"Device"> | number | null
    batteryLevel?: IntNullableFilter<"Device"> | number | null
    reservationReason?: StringNullableFilter<"Device"> | string | null
    reservedBy?: StringNullableFilter<"Device"> | string | null
    reservedUntil?: FloatNullableFilter<"Device"> | number | null
    storageFree?: StringNullableFilter<"Device"> | string | null
    tags?: StringNullableFilter<"Device"> | string | null
    thermalStatus?: StringNullableFilter<"Device"> | string | null
    sessionProgress?: StringNullableFilter<"Device"> | string | null
    totalHealedCount?: IntNullableFilter<"Device"> | number | null
    ip?: StringNullableFilter<"Device"> | string | null
    cpuArchitecture?: StringNullableFilter<"Device"> | string | null
    owningSessionId?: StringNullableFilter<"Device"> | string | null
    lockedAt?: FloatNullableFilter<"Device"> | number | null
    teamId?: StringNullableFilter<"Device"> | string | null
    team?: XOR<TeamNullableRelationFilter, TeamWhereInput> | null
  }

  export type DeviceOrderByWithRelationInput = {
    udid?: SortOrder
    host?: SortOrder
    systemPort?: SortOrderInput | SortOrder
    proxyPort?: SortOrderInput | SortOrder
    proxyHost?: SortOrderInput | SortOrder
    wdaLocalPort?: SortOrderInput | SortOrder
    name?: SortOrderInput | SortOrder
    state?: SortOrderInput | SortOrder
    sdk?: SortOrderInput | SortOrder
    platform?: SortOrderInput | SortOrder
    deviceType?: SortOrderInput | SortOrder
    busy?: SortOrderInput | SortOrder
    userBlocked?: SortOrderInput | SortOrder
    realDevice?: SortOrderInput | SortOrder
    session_id?: SortOrderInput | SortOrder
    offline?: SortOrderInput | SortOrder
    mjpegServerPort?: SortOrderInput | SortOrder
    lastCmdExecutedAt?: SortOrderInput | SortOrder
    totalUtilizationTimeMilliSec?: SortOrder
    sessionStartTime?: SortOrder
    newCommandTimeout?: SortOrderInput | SortOrder
    cloud?: SortOrderInput | SortOrder
    derivedDataPath?: SortOrderInput | SortOrder
    chromeDriverPath?: SortOrderInput | SortOrder
    capability?: SortOrderInput | SortOrder
    adbRemoteHost?: SortOrderInput | SortOrder
    adbPort?: SortOrderInput | SortOrder
    nodeId?: SortOrderInput | SortOrder
    screenWidth?: SortOrderInput | SortOrder
    screenHeight?: SortOrderInput | SortOrder
    dashboard_link?: SortOrderInput | SortOrder
    total_session_count?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    healthCheckError?: SortOrderInput | SortOrder
    healthStatus?: SortOrderInput | SortOrder
    lastHealthCheckAt?: SortOrderInput | SortOrder
    batteryLevel?: SortOrderInput | SortOrder
    reservationReason?: SortOrderInput | SortOrder
    reservedBy?: SortOrderInput | SortOrder
    reservedUntil?: SortOrderInput | SortOrder
    storageFree?: SortOrderInput | SortOrder
    tags?: SortOrderInput | SortOrder
    thermalStatus?: SortOrderInput | SortOrder
    sessionProgress?: SortOrderInput | SortOrder
    totalHealedCount?: SortOrderInput | SortOrder
    ip?: SortOrderInput | SortOrder
    cpuArchitecture?: SortOrderInput | SortOrder
    owningSessionId?: SortOrderInput | SortOrder
    lockedAt?: SortOrderInput | SortOrder
    teamId?: SortOrderInput | SortOrder
    team?: TeamOrderByWithRelationInput
  }

  export type DeviceWhereUniqueInput = Prisma.AtLeast<{
    udid_host?: DeviceUdidHostCompoundUniqueInput
    AND?: DeviceWhereInput | DeviceWhereInput[]
    OR?: DeviceWhereInput[]
    NOT?: DeviceWhereInput | DeviceWhereInput[]
    udid?: StringFilter<"Device"> | string
    host?: StringFilter<"Device"> | string
    systemPort?: IntNullableFilter<"Device"> | number | null
    proxyPort?: IntNullableFilter<"Device"> | number | null
    proxyHost?: StringNullableFilter<"Device"> | string | null
    wdaLocalPort?: IntNullableFilter<"Device"> | number | null
    name?: StringNullableFilter<"Device"> | string | null
    state?: StringNullableFilter<"Device"> | string | null
    sdk?: StringNullableFilter<"Device"> | string | null
    platform?: StringNullableFilter<"Device"> | string | null
    deviceType?: StringNullableFilter<"Device"> | string | null
    busy?: BoolNullableFilter<"Device"> | boolean | null
    userBlocked?: BoolNullableFilter<"Device"> | boolean | null
    realDevice?: BoolNullableFilter<"Device"> | boolean | null
    session_id?: StringNullableFilter<"Device"> | string | null
    offline?: BoolNullableFilter<"Device"> | boolean | null
    mjpegServerPort?: IntNullableFilter<"Device"> | number | null
    lastCmdExecutedAt?: FloatNullableFilter<"Device"> | number | null
    totalUtilizationTimeMilliSec?: FloatFilter<"Device"> | number
    sessionStartTime?: FloatFilter<"Device"> | number
    newCommandTimeout?: IntNullableFilter<"Device"> | number | null
    cloud?: StringNullableFilter<"Device"> | string | null
    derivedDataPath?: StringNullableFilter<"Device"> | string | null
    chromeDriverPath?: StringNullableFilter<"Device"> | string | null
    capability?: StringNullableFilter<"Device"> | string | null
    adbRemoteHost?: StringNullableFilter<"Device"> | string | null
    adbPort?: IntNullableFilter<"Device"> | number | null
    nodeId?: StringNullableFilter<"Device"> | string | null
    screenWidth?: StringNullableFilter<"Device"> | string | null
    screenHeight?: StringNullableFilter<"Device"> | string | null
    dashboard_link?: StringNullableFilter<"Device"> | string | null
    total_session_count?: IntNullableFilter<"Device"> | number | null
    createdAt?: DateTimeFilter<"Device"> | Date | string
    updatedAt?: DateTimeFilter<"Device"> | Date | string
    healthCheckError?: StringNullableFilter<"Device"> | string | null
    healthStatus?: StringNullableFilter<"Device"> | string | null
    lastHealthCheckAt?: FloatNullableFilter<"Device"> | number | null
    batteryLevel?: IntNullableFilter<"Device"> | number | null
    reservationReason?: StringNullableFilter<"Device"> | string | null
    reservedBy?: StringNullableFilter<"Device"> | string | null
    reservedUntil?: FloatNullableFilter<"Device"> | number | null
    storageFree?: StringNullableFilter<"Device"> | string | null
    tags?: StringNullableFilter<"Device"> | string | null
    thermalStatus?: StringNullableFilter<"Device"> | string | null
    sessionProgress?: StringNullableFilter<"Device"> | string | null
    totalHealedCount?: IntNullableFilter<"Device"> | number | null
    ip?: StringNullableFilter<"Device"> | string | null
    cpuArchitecture?: StringNullableFilter<"Device"> | string | null
    owningSessionId?: StringNullableFilter<"Device"> | string | null
    lockedAt?: FloatNullableFilter<"Device"> | number | null
    teamId?: StringNullableFilter<"Device"> | string | null
    team?: XOR<TeamNullableRelationFilter, TeamWhereInput> | null
  }, "udid_host">

  export type DeviceOrderByWithAggregationInput = {
    udid?: SortOrder
    host?: SortOrder
    systemPort?: SortOrderInput | SortOrder
    proxyPort?: SortOrderInput | SortOrder
    proxyHost?: SortOrderInput | SortOrder
    wdaLocalPort?: SortOrderInput | SortOrder
    name?: SortOrderInput | SortOrder
    state?: SortOrderInput | SortOrder
    sdk?: SortOrderInput | SortOrder
    platform?: SortOrderInput | SortOrder
    deviceType?: SortOrderInput | SortOrder
    busy?: SortOrderInput | SortOrder
    userBlocked?: SortOrderInput | SortOrder
    realDevice?: SortOrderInput | SortOrder
    session_id?: SortOrderInput | SortOrder
    offline?: SortOrderInput | SortOrder
    mjpegServerPort?: SortOrderInput | SortOrder
    lastCmdExecutedAt?: SortOrderInput | SortOrder
    totalUtilizationTimeMilliSec?: SortOrder
    sessionStartTime?: SortOrder
    newCommandTimeout?: SortOrderInput | SortOrder
    cloud?: SortOrderInput | SortOrder
    derivedDataPath?: SortOrderInput | SortOrder
    chromeDriverPath?: SortOrderInput | SortOrder
    capability?: SortOrderInput | SortOrder
    adbRemoteHost?: SortOrderInput | SortOrder
    adbPort?: SortOrderInput | SortOrder
    nodeId?: SortOrderInput | SortOrder
    screenWidth?: SortOrderInput | SortOrder
    screenHeight?: SortOrderInput | SortOrder
    dashboard_link?: SortOrderInput | SortOrder
    total_session_count?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    healthCheckError?: SortOrderInput | SortOrder
    healthStatus?: SortOrderInput | SortOrder
    lastHealthCheckAt?: SortOrderInput | SortOrder
    batteryLevel?: SortOrderInput | SortOrder
    reservationReason?: SortOrderInput | SortOrder
    reservedBy?: SortOrderInput | SortOrder
    reservedUntil?: SortOrderInput | SortOrder
    storageFree?: SortOrderInput | SortOrder
    tags?: SortOrderInput | SortOrder
    thermalStatus?: SortOrderInput | SortOrder
    sessionProgress?: SortOrderInput | SortOrder
    totalHealedCount?: SortOrderInput | SortOrder
    ip?: SortOrderInput | SortOrder
    cpuArchitecture?: SortOrderInput | SortOrder
    owningSessionId?: SortOrderInput | SortOrder
    lockedAt?: SortOrderInput | SortOrder
    teamId?: SortOrderInput | SortOrder
    _count?: DeviceCountOrderByAggregateInput
    _avg?: DeviceAvgOrderByAggregateInput
    _max?: DeviceMaxOrderByAggregateInput
    _min?: DeviceMinOrderByAggregateInput
    _sum?: DeviceSumOrderByAggregateInput
  }

  export type DeviceScalarWhereWithAggregatesInput = {
    AND?: DeviceScalarWhereWithAggregatesInput | DeviceScalarWhereWithAggregatesInput[]
    OR?: DeviceScalarWhereWithAggregatesInput[]
    NOT?: DeviceScalarWhereWithAggregatesInput | DeviceScalarWhereWithAggregatesInput[]
    udid?: StringWithAggregatesFilter<"Device"> | string
    host?: StringWithAggregatesFilter<"Device"> | string
    systemPort?: IntNullableWithAggregatesFilter<"Device"> | number | null
    proxyPort?: IntNullableWithAggregatesFilter<"Device"> | number | null
    proxyHost?: StringNullableWithAggregatesFilter<"Device"> | string | null
    wdaLocalPort?: IntNullableWithAggregatesFilter<"Device"> | number | null
    name?: StringNullableWithAggregatesFilter<"Device"> | string | null
    state?: StringNullableWithAggregatesFilter<"Device"> | string | null
    sdk?: StringNullableWithAggregatesFilter<"Device"> | string | null
    platform?: StringNullableWithAggregatesFilter<"Device"> | string | null
    deviceType?: StringNullableWithAggregatesFilter<"Device"> | string | null
    busy?: BoolNullableWithAggregatesFilter<"Device"> | boolean | null
    userBlocked?: BoolNullableWithAggregatesFilter<"Device"> | boolean | null
    realDevice?: BoolNullableWithAggregatesFilter<"Device"> | boolean | null
    session_id?: StringNullableWithAggregatesFilter<"Device"> | string | null
    offline?: BoolNullableWithAggregatesFilter<"Device"> | boolean | null
    mjpegServerPort?: IntNullableWithAggregatesFilter<"Device"> | number | null
    lastCmdExecutedAt?: FloatNullableWithAggregatesFilter<"Device"> | number | null
    totalUtilizationTimeMilliSec?: FloatWithAggregatesFilter<"Device"> | number
    sessionStartTime?: FloatWithAggregatesFilter<"Device"> | number
    newCommandTimeout?: IntNullableWithAggregatesFilter<"Device"> | number | null
    cloud?: StringNullableWithAggregatesFilter<"Device"> | string | null
    derivedDataPath?: StringNullableWithAggregatesFilter<"Device"> | string | null
    chromeDriverPath?: StringNullableWithAggregatesFilter<"Device"> | string | null
    capability?: StringNullableWithAggregatesFilter<"Device"> | string | null
    adbRemoteHost?: StringNullableWithAggregatesFilter<"Device"> | string | null
    adbPort?: IntNullableWithAggregatesFilter<"Device"> | number | null
    nodeId?: StringNullableWithAggregatesFilter<"Device"> | string | null
    screenWidth?: StringNullableWithAggregatesFilter<"Device"> | string | null
    screenHeight?: StringNullableWithAggregatesFilter<"Device"> | string | null
    dashboard_link?: StringNullableWithAggregatesFilter<"Device"> | string | null
    total_session_count?: IntNullableWithAggregatesFilter<"Device"> | number | null
    createdAt?: DateTimeWithAggregatesFilter<"Device"> | Date | string
    updatedAt?: DateTimeWithAggregatesFilter<"Device"> | Date | string
    healthCheckError?: StringNullableWithAggregatesFilter<"Device"> | string | null
    healthStatus?: StringNullableWithAggregatesFilter<"Device"> | string | null
    lastHealthCheckAt?: FloatNullableWithAggregatesFilter<"Device"> | number | null
    batteryLevel?: IntNullableWithAggregatesFilter<"Device"> | number | null
    reservationReason?: StringNullableWithAggregatesFilter<"Device"> | string | null
    reservedBy?: StringNullableWithAggregatesFilter<"Device"> | string | null
    reservedUntil?: FloatNullableWithAggregatesFilter<"Device"> | number | null
    storageFree?: StringNullableWithAggregatesFilter<"Device"> | string | null
    tags?: StringNullableWithAggregatesFilter<"Device"> | string | null
    thermalStatus?: StringNullableWithAggregatesFilter<"Device"> | string | null
    sessionProgress?: StringNullableWithAggregatesFilter<"Device"> | string | null
    totalHealedCount?: IntNullableWithAggregatesFilter<"Device"> | number | null
    ip?: StringNullableWithAggregatesFilter<"Device"> | string | null
    cpuArchitecture?: StringNullableWithAggregatesFilter<"Device"> | string | null
    owningSessionId?: StringNullableWithAggregatesFilter<"Device"> | string | null
    lockedAt?: FloatNullableWithAggregatesFilter<"Device"> | number | null
    teamId?: StringNullableWithAggregatesFilter<"Device"> | string | null
  }

  export type PendingSessionWhereInput = {
    AND?: PendingSessionWhereInput | PendingSessionWhereInput[]
    OR?: PendingSessionWhereInput[]
    NOT?: PendingSessionWhereInput | PendingSessionWhereInput[]
    id?: IntFilter<"PendingSession"> | number
    capability_id?: StringFilter<"PendingSession"> | string
    capability?: StringFilter<"PendingSession"> | string
    createdAt?: FloatFilter<"PendingSession"> | number
  }

  export type PendingSessionOrderByWithRelationInput = {
    id?: SortOrder
    capability_id?: SortOrder
    capability?: SortOrder
    createdAt?: SortOrder
  }

  export type PendingSessionWhereUniqueInput = Prisma.AtLeast<{
    id?: number
    capability_id?: string
    AND?: PendingSessionWhereInput | PendingSessionWhereInput[]
    OR?: PendingSessionWhereInput[]
    NOT?: PendingSessionWhereInput | PendingSessionWhereInput[]
    capability?: StringFilter<"PendingSession"> | string
    createdAt?: FloatFilter<"PendingSession"> | number
  }, "id" | "capability_id">

  export type PendingSessionOrderByWithAggregationInput = {
    id?: SortOrder
    capability_id?: SortOrder
    capability?: SortOrder
    createdAt?: SortOrder
    _count?: PendingSessionCountOrderByAggregateInput
    _avg?: PendingSessionAvgOrderByAggregateInput
    _max?: PendingSessionMaxOrderByAggregateInput
    _min?: PendingSessionMinOrderByAggregateInput
    _sum?: PendingSessionSumOrderByAggregateInput
  }

  export type PendingSessionScalarWhereWithAggregatesInput = {
    AND?: PendingSessionScalarWhereWithAggregatesInput | PendingSessionScalarWhereWithAggregatesInput[]
    OR?: PendingSessionScalarWhereWithAggregatesInput[]
    NOT?: PendingSessionScalarWhereWithAggregatesInput | PendingSessionScalarWhereWithAggregatesInput[]
    id?: IntWithAggregatesFilter<"PendingSession"> | number
    capability_id?: StringWithAggregatesFilter<"PendingSession"> | string
    capability?: StringWithAggregatesFilter<"PendingSession"> | string
    createdAt?: FloatWithAggregatesFilter<"PendingSession"> | number
  }

  export type CLIArgsWhereInput = {
    AND?: CLIArgsWhereInput | CLIArgsWhereInput[]
    OR?: CLIArgsWhereInput[]
    NOT?: CLIArgsWhereInput | CLIArgsWhereInput[]
    id?: IntFilter<"CLIArgs"> | number
    args?: StringFilter<"CLIArgs"> | string
    createdAt?: DateTimeFilter<"CLIArgs"> | Date | string
  }

  export type CLIArgsOrderByWithRelationInput = {
    id?: SortOrder
    args?: SortOrder
    createdAt?: SortOrder
  }

  export type CLIArgsWhereUniqueInput = Prisma.AtLeast<{
    id?: number
    AND?: CLIArgsWhereInput | CLIArgsWhereInput[]
    OR?: CLIArgsWhereInput[]
    NOT?: CLIArgsWhereInput | CLIArgsWhereInput[]
    args?: StringFilter<"CLIArgs"> | string
    createdAt?: DateTimeFilter<"CLIArgs"> | Date | string
  }, "id">

  export type CLIArgsOrderByWithAggregationInput = {
    id?: SortOrder
    args?: SortOrder
    createdAt?: SortOrder
    _count?: CLIArgsCountOrderByAggregateInput
    _avg?: CLIArgsAvgOrderByAggregateInput
    _max?: CLIArgsMaxOrderByAggregateInput
    _min?: CLIArgsMinOrderByAggregateInput
    _sum?: CLIArgsSumOrderByAggregateInput
  }

  export type CLIArgsScalarWhereWithAggregatesInput = {
    AND?: CLIArgsScalarWhereWithAggregatesInput | CLIArgsScalarWhereWithAggregatesInput[]
    OR?: CLIArgsScalarWhereWithAggregatesInput[]
    NOT?: CLIArgsScalarWhereWithAggregatesInput | CLIArgsScalarWhereWithAggregatesInput[]
    id?: IntWithAggregatesFilter<"CLIArgs"> | number
    args?: StringWithAggregatesFilter<"CLIArgs"> | string
    createdAt?: DateTimeWithAggregatesFilter<"CLIArgs"> | Date | string
  }

  export type WebhookConfigWhereInput = {
    AND?: WebhookConfigWhereInput | WebhookConfigWhereInput[]
    OR?: WebhookConfigWhereInput[]
    NOT?: WebhookConfigWhereInput | WebhookConfigWhereInput[]
    id?: StringFilter<"WebhookConfig"> | string
    url?: StringFilter<"WebhookConfig"> | string
    type?: StringFilter<"WebhookConfig"> | string
    events?: StringFilter<"WebhookConfig"> | string
    active?: BoolFilter<"WebhookConfig"> | boolean
    createdAt?: DateTimeFilter<"WebhookConfig"> | Date | string
    updatedAt?: DateTimeFilter<"WebhookConfig"> | Date | string
    payloadTemplate?: StringNullableFilter<"WebhookConfig"> | string | null
  }

  export type WebhookConfigOrderByWithRelationInput = {
    id?: SortOrder
    url?: SortOrder
    type?: SortOrder
    events?: SortOrder
    active?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    payloadTemplate?: SortOrderInput | SortOrder
  }

  export type WebhookConfigWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: WebhookConfigWhereInput | WebhookConfigWhereInput[]
    OR?: WebhookConfigWhereInput[]
    NOT?: WebhookConfigWhereInput | WebhookConfigWhereInput[]
    url?: StringFilter<"WebhookConfig"> | string
    type?: StringFilter<"WebhookConfig"> | string
    events?: StringFilter<"WebhookConfig"> | string
    active?: BoolFilter<"WebhookConfig"> | boolean
    createdAt?: DateTimeFilter<"WebhookConfig"> | Date | string
    updatedAt?: DateTimeFilter<"WebhookConfig"> | Date | string
    payloadTemplate?: StringNullableFilter<"WebhookConfig"> | string | null
  }, "id">

  export type WebhookConfigOrderByWithAggregationInput = {
    id?: SortOrder
    url?: SortOrder
    type?: SortOrder
    events?: SortOrder
    active?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    payloadTemplate?: SortOrderInput | SortOrder
    _count?: WebhookConfigCountOrderByAggregateInput
    _max?: WebhookConfigMaxOrderByAggregateInput
    _min?: WebhookConfigMinOrderByAggregateInput
  }

  export type WebhookConfigScalarWhereWithAggregatesInput = {
    AND?: WebhookConfigScalarWhereWithAggregatesInput | WebhookConfigScalarWhereWithAggregatesInput[]
    OR?: WebhookConfigScalarWhereWithAggregatesInput[]
    NOT?: WebhookConfigScalarWhereWithAggregatesInput | WebhookConfigScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"WebhookConfig"> | string
    url?: StringWithAggregatesFilter<"WebhookConfig"> | string
    type?: StringWithAggregatesFilter<"WebhookConfig"> | string
    events?: StringWithAggregatesFilter<"WebhookConfig"> | string
    active?: BoolWithAggregatesFilter<"WebhookConfig"> | boolean
    createdAt?: DateTimeWithAggregatesFilter<"WebhookConfig"> | Date | string
    updatedAt?: DateTimeWithAggregatesFilter<"WebhookConfig"> | Date | string
    payloadTemplate?: StringNullableWithAggregatesFilter<"WebhookConfig"> | string | null
  }

  export type WebConfigWhereInput = {
    AND?: WebConfigWhereInput | WebConfigWhereInput[]
    OR?: WebConfigWhereInput[]
    NOT?: WebConfigWhereInput | WebConfigWhereInput[]
    id?: StringFilter<"WebConfig"> | string
    name?: StringFilter<"WebConfig"> | string
    value?: StringFilter<"WebConfig"> | string
    createdAt?: DateTimeFilter<"WebConfig"> | Date | string
    updatedAt?: DateTimeFilter<"WebConfig"> | Date | string
  }

  export type WebConfigOrderByWithRelationInput = {
    id?: SortOrder
    name?: SortOrder
    value?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type WebConfigWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    name?: string
    AND?: WebConfigWhereInput | WebConfigWhereInput[]
    OR?: WebConfigWhereInput[]
    NOT?: WebConfigWhereInput | WebConfigWhereInput[]
    value?: StringFilter<"WebConfig"> | string
    createdAt?: DateTimeFilter<"WebConfig"> | Date | string
    updatedAt?: DateTimeFilter<"WebConfig"> | Date | string
  }, "id" | "name">

  export type WebConfigOrderByWithAggregationInput = {
    id?: SortOrder
    name?: SortOrder
    value?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    _count?: WebConfigCountOrderByAggregateInput
    _max?: WebConfigMaxOrderByAggregateInput
    _min?: WebConfigMinOrderByAggregateInput
  }

  export type WebConfigScalarWhereWithAggregatesInput = {
    AND?: WebConfigScalarWhereWithAggregatesInput | WebConfigScalarWhereWithAggregatesInput[]
    OR?: WebConfigScalarWhereWithAggregatesInput[]
    NOT?: WebConfigScalarWhereWithAggregatesInput | WebConfigScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"WebConfig"> | string
    name?: StringWithAggregatesFilter<"WebConfig"> | string
    value?: StringWithAggregatesFilter<"WebConfig"> | string
    createdAt?: DateTimeWithAggregatesFilter<"WebConfig"> | Date | string
    updatedAt?: DateTimeWithAggregatesFilter<"WebConfig"> | Date | string
  }

  export type LocatorEtalonWhereInput = {
    AND?: LocatorEtalonWhereInput | LocatorEtalonWhereInput[]
    OR?: LocatorEtalonWhereInput[]
    NOT?: LocatorEtalonWhereInput | LocatorEtalonWhereInput[]
    id?: StringFilter<"LocatorEtalon"> | string
    selector?: StringFilter<"LocatorEtalon"> | string
    strategy?: StringFilter<"LocatorEtalon"> | string
    attributes?: StringFilter<"LocatorEtalon"> | string
    nodeName?: StringFilter<"LocatorEtalon"> | string
    lastSeen?: DateTimeFilter<"LocatorEtalon"> | Date | string
    createdAt?: DateTimeFilter<"LocatorEtalon"> | Date | string
    updatedAt?: DateTimeFilter<"LocatorEtalon"> | Date | string
  }

  export type LocatorEtalonOrderByWithRelationInput = {
    id?: SortOrder
    selector?: SortOrder
    strategy?: SortOrder
    attributes?: SortOrder
    nodeName?: SortOrder
    lastSeen?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type LocatorEtalonWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    selector?: string
    AND?: LocatorEtalonWhereInput | LocatorEtalonWhereInput[]
    OR?: LocatorEtalonWhereInput[]
    NOT?: LocatorEtalonWhereInput | LocatorEtalonWhereInput[]
    strategy?: StringFilter<"LocatorEtalon"> | string
    attributes?: StringFilter<"LocatorEtalon"> | string
    nodeName?: StringFilter<"LocatorEtalon"> | string
    lastSeen?: DateTimeFilter<"LocatorEtalon"> | Date | string
    createdAt?: DateTimeFilter<"LocatorEtalon"> | Date | string
    updatedAt?: DateTimeFilter<"LocatorEtalon"> | Date | string
  }, "id" | "selector">

  export type LocatorEtalonOrderByWithAggregationInput = {
    id?: SortOrder
    selector?: SortOrder
    strategy?: SortOrder
    attributes?: SortOrder
    nodeName?: SortOrder
    lastSeen?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    _count?: LocatorEtalonCountOrderByAggregateInput
    _max?: LocatorEtalonMaxOrderByAggregateInput
    _min?: LocatorEtalonMinOrderByAggregateInput
  }

  export type LocatorEtalonScalarWhereWithAggregatesInput = {
    AND?: LocatorEtalonScalarWhereWithAggregatesInput | LocatorEtalonScalarWhereWithAggregatesInput[]
    OR?: LocatorEtalonScalarWhereWithAggregatesInput[]
    NOT?: LocatorEtalonScalarWhereWithAggregatesInput | LocatorEtalonScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"LocatorEtalon"> | string
    selector?: StringWithAggregatesFilter<"LocatorEtalon"> | string
    strategy?: StringWithAggregatesFilter<"LocatorEtalon"> | string
    attributes?: StringWithAggregatesFilter<"LocatorEtalon"> | string
    nodeName?: StringWithAggregatesFilter<"LocatorEtalon"> | string
    lastSeen?: DateTimeWithAggregatesFilter<"LocatorEtalon"> | Date | string
    createdAt?: DateTimeWithAggregatesFilter<"LocatorEtalon"> | Date | string
    updatedAt?: DateTimeWithAggregatesFilter<"LocatorEtalon"> | Date | string
  }

  export type PortLeaseWhereInput = {
    AND?: PortLeaseWhereInput | PortLeaseWhereInput[]
    OR?: PortLeaseWhereInput[]
    NOT?: PortLeaseWhereInput | PortLeaseWhereInput[]
    port?: IntFilter<"PortLease"> | number
    purpose?: StringFilter<"PortLease"> | string
    leasedToUdid?: StringFilter<"PortLease"> | string
    leasedToHost?: StringFilter<"PortLease"> | string
    leaseId?: StringNullableFilter<"PortLease"> | string | null
    leasedToPid?: IntNullableFilter<"PortLease"> | number | null
    leasedAt?: FloatFilter<"PortLease"> | number
    expiresAt?: FloatFilter<"PortLease"> | number
  }

  export type PortLeaseOrderByWithRelationInput = {
    port?: SortOrder
    purpose?: SortOrder
    leasedToUdid?: SortOrder
    leasedToHost?: SortOrder
    leaseId?: SortOrderInput | SortOrder
    leasedToPid?: SortOrderInput | SortOrder
    leasedAt?: SortOrder
    expiresAt?: SortOrder
  }

  export type PortLeaseWhereUniqueInput = Prisma.AtLeast<{
    port?: number
    AND?: PortLeaseWhereInput | PortLeaseWhereInput[]
    OR?: PortLeaseWhereInput[]
    NOT?: PortLeaseWhereInput | PortLeaseWhereInput[]
    purpose?: StringFilter<"PortLease"> | string
    leasedToUdid?: StringFilter<"PortLease"> | string
    leasedToHost?: StringFilter<"PortLease"> | string
    leaseId?: StringNullableFilter<"PortLease"> | string | null
    leasedToPid?: IntNullableFilter<"PortLease"> | number | null
    leasedAt?: FloatFilter<"PortLease"> | number
    expiresAt?: FloatFilter<"PortLease"> | number
  }, "port">

  export type PortLeaseOrderByWithAggregationInput = {
    port?: SortOrder
    purpose?: SortOrder
    leasedToUdid?: SortOrder
    leasedToHost?: SortOrder
    leaseId?: SortOrderInput | SortOrder
    leasedToPid?: SortOrderInput | SortOrder
    leasedAt?: SortOrder
    expiresAt?: SortOrder
    _count?: PortLeaseCountOrderByAggregateInput
    _avg?: PortLeaseAvgOrderByAggregateInput
    _max?: PortLeaseMaxOrderByAggregateInput
    _min?: PortLeaseMinOrderByAggregateInput
    _sum?: PortLeaseSumOrderByAggregateInput
  }

  export type PortLeaseScalarWhereWithAggregatesInput = {
    AND?: PortLeaseScalarWhereWithAggregatesInput | PortLeaseScalarWhereWithAggregatesInput[]
    OR?: PortLeaseScalarWhereWithAggregatesInput[]
    NOT?: PortLeaseScalarWhereWithAggregatesInput | PortLeaseScalarWhereWithAggregatesInput[]
    port?: IntWithAggregatesFilter<"PortLease"> | number
    purpose?: StringWithAggregatesFilter<"PortLease"> | string
    leasedToUdid?: StringWithAggregatesFilter<"PortLease"> | string
    leasedToHost?: StringWithAggregatesFilter<"PortLease"> | string
    leaseId?: StringNullableWithAggregatesFilter<"PortLease"> | string | null
    leasedToPid?: IntNullableWithAggregatesFilter<"PortLease"> | number | null
    leasedAt?: FloatWithAggregatesFilter<"PortLease"> | number
    expiresAt?: FloatWithAggregatesFilter<"PortLease"> | number
  }

  export type LeaseWhereInput = {
    AND?: LeaseWhereInput | LeaseWhereInput[]
    OR?: LeaseWhereInput[]
    NOT?: LeaseWhereInput | LeaseWhereInput[]
    id?: StringFilter<"Lease"> | string
    tokenHash?: StringFilter<"Lease"> | string
    deviceUdid?: StringFilter<"Lease"> | string
    deviceHost?: StringFilter<"Lease"> | string
    actorId?: StringFilter<"Lease"> | string
    teamId?: StringNullableFilter<"Lease"> | string | null
    buildId?: StringNullableFilter<"Lease"> | string | null
    reason?: StringNullableFilter<"Lease"> | string | null
    status?: StringFilter<"Lease"> | string
    createdAt?: DateTimeFilter<"Lease"> | Date | string
    expiresAt?: FloatFilter<"Lease"> | number
    heartbeatSeconds?: IntFilter<"Lease"> | number
    lastHeartbeatAt?: FloatFilter<"Lease"> | number
    allocatedPorts?: StringFilter<"Lease"> | string
    capabilityBag?: StringFilter<"Lease"> | string
  }

  export type LeaseOrderByWithRelationInput = {
    id?: SortOrder
    tokenHash?: SortOrder
    deviceUdid?: SortOrder
    deviceHost?: SortOrder
    actorId?: SortOrder
    teamId?: SortOrderInput | SortOrder
    buildId?: SortOrderInput | SortOrder
    reason?: SortOrderInput | SortOrder
    status?: SortOrder
    createdAt?: SortOrder
    expiresAt?: SortOrder
    heartbeatSeconds?: SortOrder
    lastHeartbeatAt?: SortOrder
    allocatedPorts?: SortOrder
    capabilityBag?: SortOrder
  }

  export type LeaseWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: LeaseWhereInput | LeaseWhereInput[]
    OR?: LeaseWhereInput[]
    NOT?: LeaseWhereInput | LeaseWhereInput[]
    tokenHash?: StringFilter<"Lease"> | string
    deviceUdid?: StringFilter<"Lease"> | string
    deviceHost?: StringFilter<"Lease"> | string
    actorId?: StringFilter<"Lease"> | string
    teamId?: StringNullableFilter<"Lease"> | string | null
    buildId?: StringNullableFilter<"Lease"> | string | null
    reason?: StringNullableFilter<"Lease"> | string | null
    status?: StringFilter<"Lease"> | string
    createdAt?: DateTimeFilter<"Lease"> | Date | string
    expiresAt?: FloatFilter<"Lease"> | number
    heartbeatSeconds?: IntFilter<"Lease"> | number
    lastHeartbeatAt?: FloatFilter<"Lease"> | number
    allocatedPorts?: StringFilter<"Lease"> | string
    capabilityBag?: StringFilter<"Lease"> | string
  }, "id">

  export type LeaseOrderByWithAggregationInput = {
    id?: SortOrder
    tokenHash?: SortOrder
    deviceUdid?: SortOrder
    deviceHost?: SortOrder
    actorId?: SortOrder
    teamId?: SortOrderInput | SortOrder
    buildId?: SortOrderInput | SortOrder
    reason?: SortOrderInput | SortOrder
    status?: SortOrder
    createdAt?: SortOrder
    expiresAt?: SortOrder
    heartbeatSeconds?: SortOrder
    lastHeartbeatAt?: SortOrder
    allocatedPorts?: SortOrder
    capabilityBag?: SortOrder
    _count?: LeaseCountOrderByAggregateInput
    _avg?: LeaseAvgOrderByAggregateInput
    _max?: LeaseMaxOrderByAggregateInput
    _min?: LeaseMinOrderByAggregateInput
    _sum?: LeaseSumOrderByAggregateInput
  }

  export type LeaseScalarWhereWithAggregatesInput = {
    AND?: LeaseScalarWhereWithAggregatesInput | LeaseScalarWhereWithAggregatesInput[]
    OR?: LeaseScalarWhereWithAggregatesInput[]
    NOT?: LeaseScalarWhereWithAggregatesInput | LeaseScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"Lease"> | string
    tokenHash?: StringWithAggregatesFilter<"Lease"> | string
    deviceUdid?: StringWithAggregatesFilter<"Lease"> | string
    deviceHost?: StringWithAggregatesFilter<"Lease"> | string
    actorId?: StringWithAggregatesFilter<"Lease"> | string
    teamId?: StringNullableWithAggregatesFilter<"Lease"> | string | null
    buildId?: StringNullableWithAggregatesFilter<"Lease"> | string | null
    reason?: StringNullableWithAggregatesFilter<"Lease"> | string | null
    status?: StringWithAggregatesFilter<"Lease"> | string
    createdAt?: DateTimeWithAggregatesFilter<"Lease"> | Date | string
    expiresAt?: FloatWithAggregatesFilter<"Lease"> | number
    heartbeatSeconds?: IntWithAggregatesFilter<"Lease"> | number
    lastHeartbeatAt?: FloatWithAggregatesFilter<"Lease"> | number
    allocatedPorts?: StringWithAggregatesFilter<"Lease"> | string
    capabilityBag?: StringWithAggregatesFilter<"Lease"> | string
  }

  export type ApiKeyWhereInput = {
    AND?: ApiKeyWhereInput | ApiKeyWhereInput[]
    OR?: ApiKeyWhereInput[]
    NOT?: ApiKeyWhereInput | ApiKeyWhereInput[]
    id?: StringFilter<"ApiKey"> | string
    name?: StringFilter<"ApiKey"> | string
    keyHash?: StringFilter<"ApiKey"> | string
    scopes?: StringFilter<"ApiKey"> | string
    rateLimit?: IntFilter<"ApiKey"> | number
    createdAt?: DateTimeFilter<"ApiKey"> | Date | string
    revokedAt?: DateTimeNullableFilter<"ApiKey"> | Date | string | null
    lastUsedAt?: DateTimeNullableFilter<"ApiKey"> | Date | string | null
    expiresAt?: DateTimeNullableFilter<"ApiKey"> | Date | string | null
    teamId?: StringNullableFilter<"ApiKey"> | string | null
    role?: StringFilter<"ApiKey"> | string
    userId?: StringFilter<"ApiKey"> | string
    team?: XOR<TeamNullableRelationFilter, TeamWhereInput> | null
    user?: XOR<UserRelationFilter, UserWhereInput>
  }

  export type ApiKeyOrderByWithRelationInput = {
    id?: SortOrder
    name?: SortOrder
    keyHash?: SortOrder
    scopes?: SortOrder
    rateLimit?: SortOrder
    createdAt?: SortOrder
    revokedAt?: SortOrderInput | SortOrder
    lastUsedAt?: SortOrderInput | SortOrder
    expiresAt?: SortOrderInput | SortOrder
    teamId?: SortOrderInput | SortOrder
    role?: SortOrder
    userId?: SortOrder
    team?: TeamOrderByWithRelationInput
    user?: UserOrderByWithRelationInput
  }

  export type ApiKeyWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    keyHash?: string
    AND?: ApiKeyWhereInput | ApiKeyWhereInput[]
    OR?: ApiKeyWhereInput[]
    NOT?: ApiKeyWhereInput | ApiKeyWhereInput[]
    name?: StringFilter<"ApiKey"> | string
    scopes?: StringFilter<"ApiKey"> | string
    rateLimit?: IntFilter<"ApiKey"> | number
    createdAt?: DateTimeFilter<"ApiKey"> | Date | string
    revokedAt?: DateTimeNullableFilter<"ApiKey"> | Date | string | null
    lastUsedAt?: DateTimeNullableFilter<"ApiKey"> | Date | string | null
    expiresAt?: DateTimeNullableFilter<"ApiKey"> | Date | string | null
    teamId?: StringNullableFilter<"ApiKey"> | string | null
    role?: StringFilter<"ApiKey"> | string
    userId?: StringFilter<"ApiKey"> | string
    team?: XOR<TeamNullableRelationFilter, TeamWhereInput> | null
    user?: XOR<UserRelationFilter, UserWhereInput>
  }, "id" | "keyHash">

  export type ApiKeyOrderByWithAggregationInput = {
    id?: SortOrder
    name?: SortOrder
    keyHash?: SortOrder
    scopes?: SortOrder
    rateLimit?: SortOrder
    createdAt?: SortOrder
    revokedAt?: SortOrderInput | SortOrder
    lastUsedAt?: SortOrderInput | SortOrder
    expiresAt?: SortOrderInput | SortOrder
    teamId?: SortOrderInput | SortOrder
    role?: SortOrder
    userId?: SortOrder
    _count?: ApiKeyCountOrderByAggregateInput
    _avg?: ApiKeyAvgOrderByAggregateInput
    _max?: ApiKeyMaxOrderByAggregateInput
    _min?: ApiKeyMinOrderByAggregateInput
    _sum?: ApiKeySumOrderByAggregateInput
  }

  export type ApiKeyScalarWhereWithAggregatesInput = {
    AND?: ApiKeyScalarWhereWithAggregatesInput | ApiKeyScalarWhereWithAggregatesInput[]
    OR?: ApiKeyScalarWhereWithAggregatesInput[]
    NOT?: ApiKeyScalarWhereWithAggregatesInput | ApiKeyScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"ApiKey"> | string
    name?: StringWithAggregatesFilter<"ApiKey"> | string
    keyHash?: StringWithAggregatesFilter<"ApiKey"> | string
    scopes?: StringWithAggregatesFilter<"ApiKey"> | string
    rateLimit?: IntWithAggregatesFilter<"ApiKey"> | number
    createdAt?: DateTimeWithAggregatesFilter<"ApiKey"> | Date | string
    revokedAt?: DateTimeNullableWithAggregatesFilter<"ApiKey"> | Date | string | null
    lastUsedAt?: DateTimeNullableWithAggregatesFilter<"ApiKey"> | Date | string | null
    expiresAt?: DateTimeNullableWithAggregatesFilter<"ApiKey"> | Date | string | null
    teamId?: StringNullableWithAggregatesFilter<"ApiKey"> | string | null
    role?: StringWithAggregatesFilter<"ApiKey"> | string
    userId?: StringWithAggregatesFilter<"ApiKey"> | string
  }

  export type TeamWhereInput = {
    AND?: TeamWhereInput | TeamWhereInput[]
    OR?: TeamWhereInput[]
    NOT?: TeamWhereInput | TeamWhereInput[]
    id?: StringFilter<"Team"> | string
    name?: StringFilter<"Team"> | string
    createdAt?: DateTimeFilter<"Team"> | Date | string
    devices?: DeviceListRelationFilter
    apiKeys?: ApiKeyListRelationFilter
    members?: TeamMemberListRelationFilter
  }

  export type TeamOrderByWithRelationInput = {
    id?: SortOrder
    name?: SortOrder
    createdAt?: SortOrder
    devices?: DeviceOrderByRelationAggregateInput
    apiKeys?: ApiKeyOrderByRelationAggregateInput
    members?: TeamMemberOrderByRelationAggregateInput
  }

  export type TeamWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    name?: string
    AND?: TeamWhereInput | TeamWhereInput[]
    OR?: TeamWhereInput[]
    NOT?: TeamWhereInput | TeamWhereInput[]
    createdAt?: DateTimeFilter<"Team"> | Date | string
    devices?: DeviceListRelationFilter
    apiKeys?: ApiKeyListRelationFilter
    members?: TeamMemberListRelationFilter
  }, "id" | "name">

  export type TeamOrderByWithAggregationInput = {
    id?: SortOrder
    name?: SortOrder
    createdAt?: SortOrder
    _count?: TeamCountOrderByAggregateInput
    _max?: TeamMaxOrderByAggregateInput
    _min?: TeamMinOrderByAggregateInput
  }

  export type TeamScalarWhereWithAggregatesInput = {
    AND?: TeamScalarWhereWithAggregatesInput | TeamScalarWhereWithAggregatesInput[]
    OR?: TeamScalarWhereWithAggregatesInput[]
    NOT?: TeamScalarWhereWithAggregatesInput | TeamScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"Team"> | string
    name?: StringWithAggregatesFilter<"Team"> | string
    createdAt?: DateTimeWithAggregatesFilter<"Team"> | Date | string
  }

  export type SelectorStateWhereInput = {
    AND?: SelectorStateWhereInput | SelectorStateWhereInput[]
    OR?: SelectorStateWhereInput[]
    NOT?: SelectorStateWhereInput | SelectorStateWhereInput[]
    id?: StringFilter<"SelectorState"> | string
    original_strategy?: StringFilter<"SelectorState"> | string
    original_selector?: StringFilter<"SelectorState"> | string
    status?: StringFilter<"SelectorState"> | string
    fixed_at?: DateTimeNullableFilter<"SelectorState"> | Date | string | null
    fixed_by_api_key?: StringNullableFilter<"SelectorState"> | string | null
    resolved_at?: DateTimeNullableFilter<"SelectorState"> | Date | string | null
    muted_at?: DateTimeNullableFilter<"SelectorState"> | Date | string | null
    muted_by_api_key?: StringNullableFilter<"SelectorState"> | string | null
    regression_count?: IntFilter<"SelectorState"> | number
    clean_builds_count?: IntFilter<"SelectorState"> | number
    last_event_at?: DateTimeFilter<"SelectorState"> | Date | string
    createdAt?: DateTimeFilter<"SelectorState"> | Date | string
    updatedAt?: DateTimeFilter<"SelectorState"> | Date | string
  }

  export type SelectorStateOrderByWithRelationInput = {
    id?: SortOrder
    original_strategy?: SortOrder
    original_selector?: SortOrder
    status?: SortOrder
    fixed_at?: SortOrderInput | SortOrder
    fixed_by_api_key?: SortOrderInput | SortOrder
    resolved_at?: SortOrderInput | SortOrder
    muted_at?: SortOrderInput | SortOrder
    muted_by_api_key?: SortOrderInput | SortOrder
    regression_count?: SortOrder
    clean_builds_count?: SortOrder
    last_event_at?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type SelectorStateWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    original_strategy_original_selector?: SelectorStateOriginal_strategyOriginal_selectorCompoundUniqueInput
    AND?: SelectorStateWhereInput | SelectorStateWhereInput[]
    OR?: SelectorStateWhereInput[]
    NOT?: SelectorStateWhereInput | SelectorStateWhereInput[]
    original_strategy?: StringFilter<"SelectorState"> | string
    original_selector?: StringFilter<"SelectorState"> | string
    status?: StringFilter<"SelectorState"> | string
    fixed_at?: DateTimeNullableFilter<"SelectorState"> | Date | string | null
    fixed_by_api_key?: StringNullableFilter<"SelectorState"> | string | null
    resolved_at?: DateTimeNullableFilter<"SelectorState"> | Date | string | null
    muted_at?: DateTimeNullableFilter<"SelectorState"> | Date | string | null
    muted_by_api_key?: StringNullableFilter<"SelectorState"> | string | null
    regression_count?: IntFilter<"SelectorState"> | number
    clean_builds_count?: IntFilter<"SelectorState"> | number
    last_event_at?: DateTimeFilter<"SelectorState"> | Date | string
    createdAt?: DateTimeFilter<"SelectorState"> | Date | string
    updatedAt?: DateTimeFilter<"SelectorState"> | Date | string
  }, "id" | "original_strategy_original_selector">

  export type SelectorStateOrderByWithAggregationInput = {
    id?: SortOrder
    original_strategy?: SortOrder
    original_selector?: SortOrder
    status?: SortOrder
    fixed_at?: SortOrderInput | SortOrder
    fixed_by_api_key?: SortOrderInput | SortOrder
    resolved_at?: SortOrderInput | SortOrder
    muted_at?: SortOrderInput | SortOrder
    muted_by_api_key?: SortOrderInput | SortOrder
    regression_count?: SortOrder
    clean_builds_count?: SortOrder
    last_event_at?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    _count?: SelectorStateCountOrderByAggregateInput
    _avg?: SelectorStateAvgOrderByAggregateInput
    _max?: SelectorStateMaxOrderByAggregateInput
    _min?: SelectorStateMinOrderByAggregateInput
    _sum?: SelectorStateSumOrderByAggregateInput
  }

  export type SelectorStateScalarWhereWithAggregatesInput = {
    AND?: SelectorStateScalarWhereWithAggregatesInput | SelectorStateScalarWhereWithAggregatesInput[]
    OR?: SelectorStateScalarWhereWithAggregatesInput[]
    NOT?: SelectorStateScalarWhereWithAggregatesInput | SelectorStateScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"SelectorState"> | string
    original_strategy?: StringWithAggregatesFilter<"SelectorState"> | string
    original_selector?: StringWithAggregatesFilter<"SelectorState"> | string
    status?: StringWithAggregatesFilter<"SelectorState"> | string
    fixed_at?: DateTimeNullableWithAggregatesFilter<"SelectorState"> | Date | string | null
    fixed_by_api_key?: StringNullableWithAggregatesFilter<"SelectorState"> | string | null
    resolved_at?: DateTimeNullableWithAggregatesFilter<"SelectorState"> | Date | string | null
    muted_at?: DateTimeNullableWithAggregatesFilter<"SelectorState"> | Date | string | null
    muted_by_api_key?: StringNullableWithAggregatesFilter<"SelectorState"> | string | null
    regression_count?: IntWithAggregatesFilter<"SelectorState"> | number
    clean_builds_count?: IntWithAggregatesFilter<"SelectorState"> | number
    last_event_at?: DateTimeWithAggregatesFilter<"SelectorState"> | Date | string
    createdAt?: DateTimeWithAggregatesFilter<"SelectorState"> | Date | string
    updatedAt?: DateTimeWithAggregatesFilter<"SelectorState"> | Date | string
  }

  export type RecordingWhereInput = {
    AND?: RecordingWhereInput | RecordingWhereInput[]
    OR?: RecordingWhereInput[]
    NOT?: RecordingWhereInput | RecordingWhereInput[]
    id?: StringFilter<"Recording"> | string
    group_id?: StringFilter<"Recording"> | string
    device_udid?: StringFilter<"Recording"> | string
    device_host?: StringFilter<"Recording"> | string
    session_id?: StringNullableFilter<"Recording"> | string | null
    started_at?: DateTimeFilter<"Recording"> | Date | string
    ended_at?: DateTimeNullableFilter<"Recording"> | Date | string | null
    status?: StringFilter<"Recording"> | string
    file_path?: StringFilter<"Recording"> | string
    duration_ms?: IntNullableFilter<"Recording"> | number | null
    size_bytes?: IntNullableFilter<"Recording"> | number | null
    device_snapshot?: StringNullableFilter<"Recording"> | string | null
    fail_reason?: StringNullableFilter<"Recording"> | string | null
    bookmarks?: BookmarkListRelationFilter
    annotations?: AnnotationListRelationFilter
    Session?: XOR<SessionNullableRelationFilter, SessionWhereInput> | null
  }

  export type RecordingOrderByWithRelationInput = {
    id?: SortOrder
    group_id?: SortOrder
    device_udid?: SortOrder
    device_host?: SortOrder
    session_id?: SortOrderInput | SortOrder
    started_at?: SortOrder
    ended_at?: SortOrderInput | SortOrder
    status?: SortOrder
    file_path?: SortOrder
    duration_ms?: SortOrderInput | SortOrder
    size_bytes?: SortOrderInput | SortOrder
    device_snapshot?: SortOrderInput | SortOrder
    fail_reason?: SortOrderInput | SortOrder
    bookmarks?: BookmarkOrderByRelationAggregateInput
    annotations?: AnnotationOrderByRelationAggregateInput
    Session?: SessionOrderByWithRelationInput
  }

  export type RecordingWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: RecordingWhereInput | RecordingWhereInput[]
    OR?: RecordingWhereInput[]
    NOT?: RecordingWhereInput | RecordingWhereInput[]
    group_id?: StringFilter<"Recording"> | string
    device_udid?: StringFilter<"Recording"> | string
    device_host?: StringFilter<"Recording"> | string
    session_id?: StringNullableFilter<"Recording"> | string | null
    started_at?: DateTimeFilter<"Recording"> | Date | string
    ended_at?: DateTimeNullableFilter<"Recording"> | Date | string | null
    status?: StringFilter<"Recording"> | string
    file_path?: StringFilter<"Recording"> | string
    duration_ms?: IntNullableFilter<"Recording"> | number | null
    size_bytes?: IntNullableFilter<"Recording"> | number | null
    device_snapshot?: StringNullableFilter<"Recording"> | string | null
    fail_reason?: StringNullableFilter<"Recording"> | string | null
    bookmarks?: BookmarkListRelationFilter
    annotations?: AnnotationListRelationFilter
    Session?: XOR<SessionNullableRelationFilter, SessionWhereInput> | null
  }, "id">

  export type RecordingOrderByWithAggregationInput = {
    id?: SortOrder
    group_id?: SortOrder
    device_udid?: SortOrder
    device_host?: SortOrder
    session_id?: SortOrderInput | SortOrder
    started_at?: SortOrder
    ended_at?: SortOrderInput | SortOrder
    status?: SortOrder
    file_path?: SortOrder
    duration_ms?: SortOrderInput | SortOrder
    size_bytes?: SortOrderInput | SortOrder
    device_snapshot?: SortOrderInput | SortOrder
    fail_reason?: SortOrderInput | SortOrder
    _count?: RecordingCountOrderByAggregateInput
    _avg?: RecordingAvgOrderByAggregateInput
    _max?: RecordingMaxOrderByAggregateInput
    _min?: RecordingMinOrderByAggregateInput
    _sum?: RecordingSumOrderByAggregateInput
  }

  export type RecordingScalarWhereWithAggregatesInput = {
    AND?: RecordingScalarWhereWithAggregatesInput | RecordingScalarWhereWithAggregatesInput[]
    OR?: RecordingScalarWhereWithAggregatesInput[]
    NOT?: RecordingScalarWhereWithAggregatesInput | RecordingScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"Recording"> | string
    group_id?: StringWithAggregatesFilter<"Recording"> | string
    device_udid?: StringWithAggregatesFilter<"Recording"> | string
    device_host?: StringWithAggregatesFilter<"Recording"> | string
    session_id?: StringNullableWithAggregatesFilter<"Recording"> | string | null
    started_at?: DateTimeWithAggregatesFilter<"Recording"> | Date | string
    ended_at?: DateTimeNullableWithAggregatesFilter<"Recording"> | Date | string | null
    status?: StringWithAggregatesFilter<"Recording"> | string
    file_path?: StringWithAggregatesFilter<"Recording"> | string
    duration_ms?: IntNullableWithAggregatesFilter<"Recording"> | number | null
    size_bytes?: IntNullableWithAggregatesFilter<"Recording"> | number | null
    device_snapshot?: StringNullableWithAggregatesFilter<"Recording"> | string | null
    fail_reason?: StringNullableWithAggregatesFilter<"Recording"> | string | null
  }

  export type BookmarkWhereInput = {
    AND?: BookmarkWhereInput | BookmarkWhereInput[]
    OR?: BookmarkWhereInput[]
    NOT?: BookmarkWhereInput | BookmarkWhereInput[]
    id?: StringFilter<"Bookmark"> | string
    recording_id?: StringFilter<"Bookmark"> | string
    timecode_ms?: IntFilter<"Bookmark"> | number
    label?: StringFilter<"Bookmark"> | string
    note?: StringNullableFilter<"Bookmark"> | string | null
    created_at?: DateTimeFilter<"Bookmark"> | Date | string
    Recording?: XOR<RecordingRelationFilter, RecordingWhereInput>
  }

  export type BookmarkOrderByWithRelationInput = {
    id?: SortOrder
    recording_id?: SortOrder
    timecode_ms?: SortOrder
    label?: SortOrder
    note?: SortOrderInput | SortOrder
    created_at?: SortOrder
    Recording?: RecordingOrderByWithRelationInput
  }

  export type BookmarkWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: BookmarkWhereInput | BookmarkWhereInput[]
    OR?: BookmarkWhereInput[]
    NOT?: BookmarkWhereInput | BookmarkWhereInput[]
    recording_id?: StringFilter<"Bookmark"> | string
    timecode_ms?: IntFilter<"Bookmark"> | number
    label?: StringFilter<"Bookmark"> | string
    note?: StringNullableFilter<"Bookmark"> | string | null
    created_at?: DateTimeFilter<"Bookmark"> | Date | string
    Recording?: XOR<RecordingRelationFilter, RecordingWhereInput>
  }, "id">

  export type BookmarkOrderByWithAggregationInput = {
    id?: SortOrder
    recording_id?: SortOrder
    timecode_ms?: SortOrder
    label?: SortOrder
    note?: SortOrderInput | SortOrder
    created_at?: SortOrder
    _count?: BookmarkCountOrderByAggregateInput
    _avg?: BookmarkAvgOrderByAggregateInput
    _max?: BookmarkMaxOrderByAggregateInput
    _min?: BookmarkMinOrderByAggregateInput
    _sum?: BookmarkSumOrderByAggregateInput
  }

  export type BookmarkScalarWhereWithAggregatesInput = {
    AND?: BookmarkScalarWhereWithAggregatesInput | BookmarkScalarWhereWithAggregatesInput[]
    OR?: BookmarkScalarWhereWithAggregatesInput[]
    NOT?: BookmarkScalarWhereWithAggregatesInput | BookmarkScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"Bookmark"> | string
    recording_id?: StringWithAggregatesFilter<"Bookmark"> | string
    timecode_ms?: IntWithAggregatesFilter<"Bookmark"> | number
    label?: StringWithAggregatesFilter<"Bookmark"> | string
    note?: StringNullableWithAggregatesFilter<"Bookmark"> | string | null
    created_at?: DateTimeWithAggregatesFilter<"Bookmark"> | Date | string
  }

  export type AnnotationWhereInput = {
    AND?: AnnotationWhereInput | AnnotationWhereInput[]
    OR?: AnnotationWhereInput[]
    NOT?: AnnotationWhereInput | AnnotationWhereInput[]
    id?: StringFilter<"Annotation"> | string
    recording_id?: StringFilter<"Annotation"> | string
    timecode_ms?: IntFilter<"Annotation"> | number
    shape?: StringFilter<"Annotation"> | string
    geometry?: StringFilter<"Annotation"> | string
    color?: StringFilter<"Annotation"> | string
    text?: StringNullableFilter<"Annotation"> | string | null
    author?: StringNullableFilter<"Annotation"> | string | null
    created_at?: DateTimeFilter<"Annotation"> | Date | string
    Recording?: XOR<RecordingRelationFilter, RecordingWhereInput>
  }

  export type AnnotationOrderByWithRelationInput = {
    id?: SortOrder
    recording_id?: SortOrder
    timecode_ms?: SortOrder
    shape?: SortOrder
    geometry?: SortOrder
    color?: SortOrder
    text?: SortOrderInput | SortOrder
    author?: SortOrderInput | SortOrder
    created_at?: SortOrder
    Recording?: RecordingOrderByWithRelationInput
  }

  export type AnnotationWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: AnnotationWhereInput | AnnotationWhereInput[]
    OR?: AnnotationWhereInput[]
    NOT?: AnnotationWhereInput | AnnotationWhereInput[]
    recording_id?: StringFilter<"Annotation"> | string
    timecode_ms?: IntFilter<"Annotation"> | number
    shape?: StringFilter<"Annotation"> | string
    geometry?: StringFilter<"Annotation"> | string
    color?: StringFilter<"Annotation"> | string
    text?: StringNullableFilter<"Annotation"> | string | null
    author?: StringNullableFilter<"Annotation"> | string | null
    created_at?: DateTimeFilter<"Annotation"> | Date | string
    Recording?: XOR<RecordingRelationFilter, RecordingWhereInput>
  }, "id">

  export type AnnotationOrderByWithAggregationInput = {
    id?: SortOrder
    recording_id?: SortOrder
    timecode_ms?: SortOrder
    shape?: SortOrder
    geometry?: SortOrder
    color?: SortOrder
    text?: SortOrderInput | SortOrder
    author?: SortOrderInput | SortOrder
    created_at?: SortOrder
    _count?: AnnotationCountOrderByAggregateInput
    _avg?: AnnotationAvgOrderByAggregateInput
    _max?: AnnotationMaxOrderByAggregateInput
    _min?: AnnotationMinOrderByAggregateInput
    _sum?: AnnotationSumOrderByAggregateInput
  }

  export type AnnotationScalarWhereWithAggregatesInput = {
    AND?: AnnotationScalarWhereWithAggregatesInput | AnnotationScalarWhereWithAggregatesInput[]
    OR?: AnnotationScalarWhereWithAggregatesInput[]
    NOT?: AnnotationScalarWhereWithAggregatesInput | AnnotationScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"Annotation"> | string
    recording_id?: StringWithAggregatesFilter<"Annotation"> | string
    timecode_ms?: IntWithAggregatesFilter<"Annotation"> | number
    shape?: StringWithAggregatesFilter<"Annotation"> | string
    geometry?: StringWithAggregatesFilter<"Annotation"> | string
    color?: StringWithAggregatesFilter<"Annotation"> | string
    text?: StringNullableWithAggregatesFilter<"Annotation"> | string | null
    author?: StringNullableWithAggregatesFilter<"Annotation"> | string | null
    created_at?: DateTimeWithAggregatesFilter<"Annotation"> | Date | string
  }

  export type UserWhereInput = {
    AND?: UserWhereInput | UserWhereInput[]
    OR?: UserWhereInput[]
    NOT?: UserWhereInput | UserWhereInput[]
    id?: StringFilter<"User"> | string
    email?: StringFilter<"User"> | string
    name?: StringFilter<"User"> | string
    passwordHash?: StringFilter<"User"> | string
    accessKey?: StringFilter<"User"> | string
    role?: StringFilter<"User"> | string
    status?: StringFilter<"User"> | string
    createdAt?: DateTimeFilter<"User"> | Date | string
    updatedAt?: DateTimeFilter<"User"> | Date | string
    lastLoginAt?: DateTimeNullableFilter<"User"> | Date | string | null
    passwordChangedAt?: DateTimeNullableFilter<"User"> | Date | string | null
    apiKeys?: ApiKeyListRelationFilter
    sessions?: UserSessionListRelationFilter
    passwordResetTokens?: PasswordResetTokenListRelationFilter
    teamMemberships?: TeamMemberListRelationFilter
  }

  export type UserOrderByWithRelationInput = {
    id?: SortOrder
    email?: SortOrder
    name?: SortOrder
    passwordHash?: SortOrder
    accessKey?: SortOrder
    role?: SortOrder
    status?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    lastLoginAt?: SortOrderInput | SortOrder
    passwordChangedAt?: SortOrderInput | SortOrder
    apiKeys?: ApiKeyOrderByRelationAggregateInput
    sessions?: UserSessionOrderByRelationAggregateInput
    passwordResetTokens?: PasswordResetTokenOrderByRelationAggregateInput
    teamMemberships?: TeamMemberOrderByRelationAggregateInput
  }

  export type UserWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    email?: string
    accessKey?: string
    AND?: UserWhereInput | UserWhereInput[]
    OR?: UserWhereInput[]
    NOT?: UserWhereInput | UserWhereInput[]
    name?: StringFilter<"User"> | string
    passwordHash?: StringFilter<"User"> | string
    role?: StringFilter<"User"> | string
    status?: StringFilter<"User"> | string
    createdAt?: DateTimeFilter<"User"> | Date | string
    updatedAt?: DateTimeFilter<"User"> | Date | string
    lastLoginAt?: DateTimeNullableFilter<"User"> | Date | string | null
    passwordChangedAt?: DateTimeNullableFilter<"User"> | Date | string | null
    apiKeys?: ApiKeyListRelationFilter
    sessions?: UserSessionListRelationFilter
    passwordResetTokens?: PasswordResetTokenListRelationFilter
    teamMemberships?: TeamMemberListRelationFilter
  }, "id" | "email" | "accessKey">

  export type UserOrderByWithAggregationInput = {
    id?: SortOrder
    email?: SortOrder
    name?: SortOrder
    passwordHash?: SortOrder
    accessKey?: SortOrder
    role?: SortOrder
    status?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    lastLoginAt?: SortOrderInput | SortOrder
    passwordChangedAt?: SortOrderInput | SortOrder
    _count?: UserCountOrderByAggregateInput
    _max?: UserMaxOrderByAggregateInput
    _min?: UserMinOrderByAggregateInput
  }

  export type UserScalarWhereWithAggregatesInput = {
    AND?: UserScalarWhereWithAggregatesInput | UserScalarWhereWithAggregatesInput[]
    OR?: UserScalarWhereWithAggregatesInput[]
    NOT?: UserScalarWhereWithAggregatesInput | UserScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"User"> | string
    email?: StringWithAggregatesFilter<"User"> | string
    name?: StringWithAggregatesFilter<"User"> | string
    passwordHash?: StringWithAggregatesFilter<"User"> | string
    accessKey?: StringWithAggregatesFilter<"User"> | string
    role?: StringWithAggregatesFilter<"User"> | string
    status?: StringWithAggregatesFilter<"User"> | string
    createdAt?: DateTimeWithAggregatesFilter<"User"> | Date | string
    updatedAt?: DateTimeWithAggregatesFilter<"User"> | Date | string
    lastLoginAt?: DateTimeNullableWithAggregatesFilter<"User"> | Date | string | null
    passwordChangedAt?: DateTimeNullableWithAggregatesFilter<"User"> | Date | string | null
  }

  export type UserSessionWhereInput = {
    AND?: UserSessionWhereInput | UserSessionWhereInput[]
    OR?: UserSessionWhereInput[]
    NOT?: UserSessionWhereInput | UserSessionWhereInput[]
    id?: StringFilter<"UserSession"> | string
    userId?: StringFilter<"UserSession"> | string
    createdAt?: DateTimeFilter<"UserSession"> | Date | string
    expiresAt?: DateTimeFilter<"UserSession"> | Date | string
    lastSeenAt?: DateTimeFilter<"UserSession"> | Date | string
    userAgent?: StringNullableFilter<"UserSession"> | string | null
    ipHash?: StringNullableFilter<"UserSession"> | string | null
    user?: XOR<UserRelationFilter, UserWhereInput>
  }

  export type UserSessionOrderByWithRelationInput = {
    id?: SortOrder
    userId?: SortOrder
    createdAt?: SortOrder
    expiresAt?: SortOrder
    lastSeenAt?: SortOrder
    userAgent?: SortOrderInput | SortOrder
    ipHash?: SortOrderInput | SortOrder
    user?: UserOrderByWithRelationInput
  }

  export type UserSessionWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: UserSessionWhereInput | UserSessionWhereInput[]
    OR?: UserSessionWhereInput[]
    NOT?: UserSessionWhereInput | UserSessionWhereInput[]
    userId?: StringFilter<"UserSession"> | string
    createdAt?: DateTimeFilter<"UserSession"> | Date | string
    expiresAt?: DateTimeFilter<"UserSession"> | Date | string
    lastSeenAt?: DateTimeFilter<"UserSession"> | Date | string
    userAgent?: StringNullableFilter<"UserSession"> | string | null
    ipHash?: StringNullableFilter<"UserSession"> | string | null
    user?: XOR<UserRelationFilter, UserWhereInput>
  }, "id">

  export type UserSessionOrderByWithAggregationInput = {
    id?: SortOrder
    userId?: SortOrder
    createdAt?: SortOrder
    expiresAt?: SortOrder
    lastSeenAt?: SortOrder
    userAgent?: SortOrderInput | SortOrder
    ipHash?: SortOrderInput | SortOrder
    _count?: UserSessionCountOrderByAggregateInput
    _max?: UserSessionMaxOrderByAggregateInput
    _min?: UserSessionMinOrderByAggregateInput
  }

  export type UserSessionScalarWhereWithAggregatesInput = {
    AND?: UserSessionScalarWhereWithAggregatesInput | UserSessionScalarWhereWithAggregatesInput[]
    OR?: UserSessionScalarWhereWithAggregatesInput[]
    NOT?: UserSessionScalarWhereWithAggregatesInput | UserSessionScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"UserSession"> | string
    userId?: StringWithAggregatesFilter<"UserSession"> | string
    createdAt?: DateTimeWithAggregatesFilter<"UserSession"> | Date | string
    expiresAt?: DateTimeWithAggregatesFilter<"UserSession"> | Date | string
    lastSeenAt?: DateTimeWithAggregatesFilter<"UserSession"> | Date | string
    userAgent?: StringNullableWithAggregatesFilter<"UserSession"> | string | null
    ipHash?: StringNullableWithAggregatesFilter<"UserSession"> | string | null
  }

  export type PasswordResetTokenWhereInput = {
    AND?: PasswordResetTokenWhereInput | PasswordResetTokenWhereInput[]
    OR?: PasswordResetTokenWhereInput[]
    NOT?: PasswordResetTokenWhereInput | PasswordResetTokenWhereInput[]
    id?: StringFilter<"PasswordResetToken"> | string
    userId?: StringFilter<"PasswordResetToken"> | string
    tokenHash?: StringFilter<"PasswordResetToken"> | string
    createdAt?: DateTimeFilter<"PasswordResetToken"> | Date | string
    expiresAt?: DateTimeFilter<"PasswordResetToken"> | Date | string
    usedAt?: DateTimeNullableFilter<"PasswordResetToken"> | Date | string | null
    user?: XOR<UserRelationFilter, UserWhereInput>
  }

  export type PasswordResetTokenOrderByWithRelationInput = {
    id?: SortOrder
    userId?: SortOrder
    tokenHash?: SortOrder
    createdAt?: SortOrder
    expiresAt?: SortOrder
    usedAt?: SortOrderInput | SortOrder
    user?: UserOrderByWithRelationInput
  }

  export type PasswordResetTokenWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    tokenHash?: string
    AND?: PasswordResetTokenWhereInput | PasswordResetTokenWhereInput[]
    OR?: PasswordResetTokenWhereInput[]
    NOT?: PasswordResetTokenWhereInput | PasswordResetTokenWhereInput[]
    userId?: StringFilter<"PasswordResetToken"> | string
    createdAt?: DateTimeFilter<"PasswordResetToken"> | Date | string
    expiresAt?: DateTimeFilter<"PasswordResetToken"> | Date | string
    usedAt?: DateTimeNullableFilter<"PasswordResetToken"> | Date | string | null
    user?: XOR<UserRelationFilter, UserWhereInput>
  }, "id" | "tokenHash">

  export type PasswordResetTokenOrderByWithAggregationInput = {
    id?: SortOrder
    userId?: SortOrder
    tokenHash?: SortOrder
    createdAt?: SortOrder
    expiresAt?: SortOrder
    usedAt?: SortOrderInput | SortOrder
    _count?: PasswordResetTokenCountOrderByAggregateInput
    _max?: PasswordResetTokenMaxOrderByAggregateInput
    _min?: PasswordResetTokenMinOrderByAggregateInput
  }

  export type PasswordResetTokenScalarWhereWithAggregatesInput = {
    AND?: PasswordResetTokenScalarWhereWithAggregatesInput | PasswordResetTokenScalarWhereWithAggregatesInput[]
    OR?: PasswordResetTokenScalarWhereWithAggregatesInput[]
    NOT?: PasswordResetTokenScalarWhereWithAggregatesInput | PasswordResetTokenScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"PasswordResetToken"> | string
    userId?: StringWithAggregatesFilter<"PasswordResetToken"> | string
    tokenHash?: StringWithAggregatesFilter<"PasswordResetToken"> | string
    createdAt?: DateTimeWithAggregatesFilter<"PasswordResetToken"> | Date | string
    expiresAt?: DateTimeWithAggregatesFilter<"PasswordResetToken"> | Date | string
    usedAt?: DateTimeNullableWithAggregatesFilter<"PasswordResetToken"> | Date | string | null
  }

  export type TeamMemberWhereInput = {
    AND?: TeamMemberWhereInput | TeamMemberWhereInput[]
    OR?: TeamMemberWhereInput[]
    NOT?: TeamMemberWhereInput | TeamMemberWhereInput[]
    teamId?: StringFilter<"TeamMember"> | string
    userId?: StringFilter<"TeamMember"> | string
    createdAt?: DateTimeFilter<"TeamMember"> | Date | string
    team?: XOR<TeamRelationFilter, TeamWhereInput>
    user?: XOR<UserRelationFilter, UserWhereInput>
  }

  export type TeamMemberOrderByWithRelationInput = {
    teamId?: SortOrder
    userId?: SortOrder
    createdAt?: SortOrder
    team?: TeamOrderByWithRelationInput
    user?: UserOrderByWithRelationInput
  }

  export type TeamMemberWhereUniqueInput = Prisma.AtLeast<{
    teamId_userId?: TeamMemberTeamIdUserIdCompoundUniqueInput
    AND?: TeamMemberWhereInput | TeamMemberWhereInput[]
    OR?: TeamMemberWhereInput[]
    NOT?: TeamMemberWhereInput | TeamMemberWhereInput[]
    teamId?: StringFilter<"TeamMember"> | string
    userId?: StringFilter<"TeamMember"> | string
    createdAt?: DateTimeFilter<"TeamMember"> | Date | string
    team?: XOR<TeamRelationFilter, TeamWhereInput>
    user?: XOR<UserRelationFilter, UserWhereInput>
  }, "teamId_userId">

  export type TeamMemberOrderByWithAggregationInput = {
    teamId?: SortOrder
    userId?: SortOrder
    createdAt?: SortOrder
    _count?: TeamMemberCountOrderByAggregateInput
    _max?: TeamMemberMaxOrderByAggregateInput
    _min?: TeamMemberMinOrderByAggregateInput
  }

  export type TeamMemberScalarWhereWithAggregatesInput = {
    AND?: TeamMemberScalarWhereWithAggregatesInput | TeamMemberScalarWhereWithAggregatesInput[]
    OR?: TeamMemberScalarWhereWithAggregatesInput[]
    NOT?: TeamMemberScalarWhereWithAggregatesInput | TeamMemberScalarWhereWithAggregatesInput[]
    teamId?: StringWithAggregatesFilter<"TeamMember"> | string
    userId?: StringWithAggregatesFilter<"TeamMember"> | string
    createdAt?: DateTimeWithAggregatesFilter<"TeamMember"> | Date | string
  }

  export type EventLogWhereInput = {
    AND?: EventLogWhereInput | EventLogWhereInput[]
    OR?: EventLogWhereInput[]
    NOT?: EventLogWhereInput | EventLogWhereInput[]
    id?: StringFilter<"EventLog"> | string
    type?: StringFilter<"EventLog"> | string
    payload?: StringFilter<"EventLog"> | string
    correlationId?: StringNullableFilter<"EventLog"> | string | null
    teamId?: StringNullableFilter<"EventLog"> | string | null
    occurredAt?: DateTimeFilter<"EventLog"> | Date | string
  }

  export type EventLogOrderByWithRelationInput = {
    id?: SortOrder
    type?: SortOrder
    payload?: SortOrder
    correlationId?: SortOrderInput | SortOrder
    teamId?: SortOrderInput | SortOrder
    occurredAt?: SortOrder
  }

  export type EventLogWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: EventLogWhereInput | EventLogWhereInput[]
    OR?: EventLogWhereInput[]
    NOT?: EventLogWhereInput | EventLogWhereInput[]
    type?: StringFilter<"EventLog"> | string
    payload?: StringFilter<"EventLog"> | string
    correlationId?: StringNullableFilter<"EventLog"> | string | null
    teamId?: StringNullableFilter<"EventLog"> | string | null
    occurredAt?: DateTimeFilter<"EventLog"> | Date | string
  }, "id">

  export type EventLogOrderByWithAggregationInput = {
    id?: SortOrder
    type?: SortOrder
    payload?: SortOrder
    correlationId?: SortOrderInput | SortOrder
    teamId?: SortOrderInput | SortOrder
    occurredAt?: SortOrder
    _count?: EventLogCountOrderByAggregateInput
    _max?: EventLogMaxOrderByAggregateInput
    _min?: EventLogMinOrderByAggregateInput
  }

  export type EventLogScalarWhereWithAggregatesInput = {
    AND?: EventLogScalarWhereWithAggregatesInput | EventLogScalarWhereWithAggregatesInput[]
    OR?: EventLogScalarWhereWithAggregatesInput[]
    NOT?: EventLogScalarWhereWithAggregatesInput | EventLogScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"EventLog"> | string
    type?: StringWithAggregatesFilter<"EventLog"> | string
    payload?: StringWithAggregatesFilter<"EventLog"> | string
    correlationId?: StringNullableWithAggregatesFilter<"EventLog"> | string | null
    teamId?: StringNullableWithAggregatesFilter<"EventLog"> | string | null
    occurredAt?: DateTimeWithAggregatesFilter<"EventLog"> | Date | string
  }

  export type ProjectWhereInput = {
    AND?: ProjectWhereInput | ProjectWhereInput[]
    OR?: ProjectWhereInput[]
    NOT?: ProjectWhereInput | ProjectWhereInput[]
    id?: StringFilter<"Project"> | string
    name?: StringFilter<"Project"> | string
    teamId?: StringNullableFilter<"Project"> | string | null
    createdAt?: DateTimeFilter<"Project"> | Date | string
  }

  export type ProjectOrderByWithRelationInput = {
    id?: SortOrder
    name?: SortOrder
    teamId?: SortOrderInput | SortOrder
    createdAt?: SortOrder
  }

  export type ProjectWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: ProjectWhereInput | ProjectWhereInput[]
    OR?: ProjectWhereInput[]
    NOT?: ProjectWhereInput | ProjectWhereInput[]
    name?: StringFilter<"Project"> | string
    teamId?: StringNullableFilter<"Project"> | string | null
    createdAt?: DateTimeFilter<"Project"> | Date | string
  }, "id">

  export type ProjectOrderByWithAggregationInput = {
    id?: SortOrder
    name?: SortOrder
    teamId?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    _count?: ProjectCountOrderByAggregateInput
    _max?: ProjectMaxOrderByAggregateInput
    _min?: ProjectMinOrderByAggregateInput
  }

  export type ProjectScalarWhereWithAggregatesInput = {
    AND?: ProjectScalarWhereWithAggregatesInput | ProjectScalarWhereWithAggregatesInput[]
    OR?: ProjectScalarWhereWithAggregatesInput[]
    NOT?: ProjectScalarWhereWithAggregatesInput | ProjectScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"Project"> | string
    name?: StringWithAggregatesFilter<"Project"> | string
    teamId?: StringNullableWithAggregatesFilter<"Project"> | string | null
    createdAt?: DateTimeWithAggregatesFilter<"Project"> | Date | string
  }

  export type BuildCreateInput = {
    id?: string
    name?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    sessions?: SessionCreateNestedManyWithoutBuildInput
  }

  export type BuildUncheckedCreateInput = {
    id?: string
    name?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    sessions?: SessionUncheckedCreateNestedManyWithoutBuildInput
  }

  export type BuildUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    sessions?: SessionUpdateManyWithoutBuildNestedInput
  }

  export type BuildUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    sessions?: SessionUncheckedUpdateManyWithoutBuildNestedInput
  }

  export type BuildCreateManyInput = {
    id?: string
    name?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type BuildUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type BuildUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type SessionCreateInput = {
    id: string
    name?: string | null
    status?: string
    desired_capabilities: string
    session_capabilities: string
    node_id: string
    has_live_video: boolean
    video_recording_enabled?: boolean
    video_recording?: string | null
    startTime?: Date | string
    endTime?: Date | string | null
    failure_reason?: string | null
    is_profiling_available?: boolean
    device_info?: string | null
    device_udid: string
    device_platform: string
    device_version: string
    device_name?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    performance_trace?: string | null
    failure_category?: string | null
    ai_analysis?: string | null
    tags?: string | null
    trace_id?: string | null
    last_heartbeat_at?: Date | string | null
    heartbeat_pid?: number | null
    heartbeat_host?: string | null
    api_key_id?: string | null
    user_id?: string | null
    Log?: LogCreateNestedManyWithoutSessionInput
    Profiling?: ProfilingCreateNestedManyWithoutSessionInput
    build?: BuildCreateNestedOneWithoutSessionsInput
    SessionLog?: SessionLogCreateNestedManyWithoutSessionInput
    Recording?: RecordingCreateNestedManyWithoutSessionInput
  }

  export type SessionUncheckedCreateInput = {
    id: string
    build_id?: string | null
    name?: string | null
    status?: string
    desired_capabilities: string
    session_capabilities: string
    node_id: string
    has_live_video: boolean
    video_recording_enabled?: boolean
    video_recording?: string | null
    startTime?: Date | string
    endTime?: Date | string | null
    failure_reason?: string | null
    is_profiling_available?: boolean
    device_info?: string | null
    device_udid: string
    device_platform: string
    device_version: string
    device_name?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    performance_trace?: string | null
    failure_category?: string | null
    ai_analysis?: string | null
    tags?: string | null
    trace_id?: string | null
    last_heartbeat_at?: Date | string | null
    heartbeat_pid?: number | null
    heartbeat_host?: string | null
    api_key_id?: string | null
    user_id?: string | null
    Log?: LogUncheckedCreateNestedManyWithoutSessionInput
    Profiling?: ProfilingUncheckedCreateNestedManyWithoutSessionInput
    SessionLog?: SessionLogUncheckedCreateNestedManyWithoutSessionInput
    Recording?: RecordingUncheckedCreateNestedManyWithoutSessionInput
  }

  export type SessionUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: NullableStringFieldUpdateOperationsInput | string | null
    status?: StringFieldUpdateOperationsInput | string
    desired_capabilities?: StringFieldUpdateOperationsInput | string
    session_capabilities?: StringFieldUpdateOperationsInput | string
    node_id?: StringFieldUpdateOperationsInput | string
    has_live_video?: BoolFieldUpdateOperationsInput | boolean
    video_recording_enabled?: BoolFieldUpdateOperationsInput | boolean
    video_recording?: NullableStringFieldUpdateOperationsInput | string | null
    startTime?: DateTimeFieldUpdateOperationsInput | Date | string
    endTime?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    failure_reason?: NullableStringFieldUpdateOperationsInput | string | null
    is_profiling_available?: BoolFieldUpdateOperationsInput | boolean
    device_info?: NullableStringFieldUpdateOperationsInput | string | null
    device_udid?: StringFieldUpdateOperationsInput | string
    device_platform?: StringFieldUpdateOperationsInput | string
    device_version?: StringFieldUpdateOperationsInput | string
    device_name?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    performance_trace?: NullableStringFieldUpdateOperationsInput | string | null
    failure_category?: NullableStringFieldUpdateOperationsInput | string | null
    ai_analysis?: NullableStringFieldUpdateOperationsInput | string | null
    tags?: NullableStringFieldUpdateOperationsInput | string | null
    trace_id?: NullableStringFieldUpdateOperationsInput | string | null
    last_heartbeat_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    heartbeat_pid?: NullableIntFieldUpdateOperationsInput | number | null
    heartbeat_host?: NullableStringFieldUpdateOperationsInput | string | null
    api_key_id?: NullableStringFieldUpdateOperationsInput | string | null
    user_id?: NullableStringFieldUpdateOperationsInput | string | null
    Log?: LogUpdateManyWithoutSessionNestedInput
    Profiling?: ProfilingUpdateManyWithoutSessionNestedInput
    build?: BuildUpdateOneWithoutSessionsNestedInput
    SessionLog?: SessionLogUpdateManyWithoutSessionNestedInput
    Recording?: RecordingUpdateManyWithoutSessionNestedInput
  }

  export type SessionUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    build_id?: NullableStringFieldUpdateOperationsInput | string | null
    name?: NullableStringFieldUpdateOperationsInput | string | null
    status?: StringFieldUpdateOperationsInput | string
    desired_capabilities?: StringFieldUpdateOperationsInput | string
    session_capabilities?: StringFieldUpdateOperationsInput | string
    node_id?: StringFieldUpdateOperationsInput | string
    has_live_video?: BoolFieldUpdateOperationsInput | boolean
    video_recording_enabled?: BoolFieldUpdateOperationsInput | boolean
    video_recording?: NullableStringFieldUpdateOperationsInput | string | null
    startTime?: DateTimeFieldUpdateOperationsInput | Date | string
    endTime?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    failure_reason?: NullableStringFieldUpdateOperationsInput | string | null
    is_profiling_available?: BoolFieldUpdateOperationsInput | boolean
    device_info?: NullableStringFieldUpdateOperationsInput | string | null
    device_udid?: StringFieldUpdateOperationsInput | string
    device_platform?: StringFieldUpdateOperationsInput | string
    device_version?: StringFieldUpdateOperationsInput | string
    device_name?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    performance_trace?: NullableStringFieldUpdateOperationsInput | string | null
    failure_category?: NullableStringFieldUpdateOperationsInput | string | null
    ai_analysis?: NullableStringFieldUpdateOperationsInput | string | null
    tags?: NullableStringFieldUpdateOperationsInput | string | null
    trace_id?: NullableStringFieldUpdateOperationsInput | string | null
    last_heartbeat_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    heartbeat_pid?: NullableIntFieldUpdateOperationsInput | number | null
    heartbeat_host?: NullableStringFieldUpdateOperationsInput | string | null
    api_key_id?: NullableStringFieldUpdateOperationsInput | string | null
    user_id?: NullableStringFieldUpdateOperationsInput | string | null
    Log?: LogUncheckedUpdateManyWithoutSessionNestedInput
    Profiling?: ProfilingUncheckedUpdateManyWithoutSessionNestedInput
    SessionLog?: SessionLogUncheckedUpdateManyWithoutSessionNestedInput
    Recording?: RecordingUncheckedUpdateManyWithoutSessionNestedInput
  }

  export type SessionCreateManyInput = {
    id: string
    build_id?: string | null
    name?: string | null
    status?: string
    desired_capabilities: string
    session_capabilities: string
    node_id: string
    has_live_video: boolean
    video_recording_enabled?: boolean
    video_recording?: string | null
    startTime?: Date | string
    endTime?: Date | string | null
    failure_reason?: string | null
    is_profiling_available?: boolean
    device_info?: string | null
    device_udid: string
    device_platform: string
    device_version: string
    device_name?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    performance_trace?: string | null
    failure_category?: string | null
    ai_analysis?: string | null
    tags?: string | null
    trace_id?: string | null
    last_heartbeat_at?: Date | string | null
    heartbeat_pid?: number | null
    heartbeat_host?: string | null
    api_key_id?: string | null
    user_id?: string | null
  }

  export type SessionUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: NullableStringFieldUpdateOperationsInput | string | null
    status?: StringFieldUpdateOperationsInput | string
    desired_capabilities?: StringFieldUpdateOperationsInput | string
    session_capabilities?: StringFieldUpdateOperationsInput | string
    node_id?: StringFieldUpdateOperationsInput | string
    has_live_video?: BoolFieldUpdateOperationsInput | boolean
    video_recording_enabled?: BoolFieldUpdateOperationsInput | boolean
    video_recording?: NullableStringFieldUpdateOperationsInput | string | null
    startTime?: DateTimeFieldUpdateOperationsInput | Date | string
    endTime?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    failure_reason?: NullableStringFieldUpdateOperationsInput | string | null
    is_profiling_available?: BoolFieldUpdateOperationsInput | boolean
    device_info?: NullableStringFieldUpdateOperationsInput | string | null
    device_udid?: StringFieldUpdateOperationsInput | string
    device_platform?: StringFieldUpdateOperationsInput | string
    device_version?: StringFieldUpdateOperationsInput | string
    device_name?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    performance_trace?: NullableStringFieldUpdateOperationsInput | string | null
    failure_category?: NullableStringFieldUpdateOperationsInput | string | null
    ai_analysis?: NullableStringFieldUpdateOperationsInput | string | null
    tags?: NullableStringFieldUpdateOperationsInput | string | null
    trace_id?: NullableStringFieldUpdateOperationsInput | string | null
    last_heartbeat_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    heartbeat_pid?: NullableIntFieldUpdateOperationsInput | number | null
    heartbeat_host?: NullableStringFieldUpdateOperationsInput | string | null
    api_key_id?: NullableStringFieldUpdateOperationsInput | string | null
    user_id?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type SessionUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    build_id?: NullableStringFieldUpdateOperationsInput | string | null
    name?: NullableStringFieldUpdateOperationsInput | string | null
    status?: StringFieldUpdateOperationsInput | string
    desired_capabilities?: StringFieldUpdateOperationsInput | string
    session_capabilities?: StringFieldUpdateOperationsInput | string
    node_id?: StringFieldUpdateOperationsInput | string
    has_live_video?: BoolFieldUpdateOperationsInput | boolean
    video_recording_enabled?: BoolFieldUpdateOperationsInput | boolean
    video_recording?: NullableStringFieldUpdateOperationsInput | string | null
    startTime?: DateTimeFieldUpdateOperationsInput | Date | string
    endTime?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    failure_reason?: NullableStringFieldUpdateOperationsInput | string | null
    is_profiling_available?: BoolFieldUpdateOperationsInput | boolean
    device_info?: NullableStringFieldUpdateOperationsInput | string | null
    device_udid?: StringFieldUpdateOperationsInput | string
    device_platform?: StringFieldUpdateOperationsInput | string
    device_version?: StringFieldUpdateOperationsInput | string
    device_name?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    performance_trace?: NullableStringFieldUpdateOperationsInput | string | null
    failure_category?: NullableStringFieldUpdateOperationsInput | string | null
    ai_analysis?: NullableStringFieldUpdateOperationsInput | string | null
    tags?: NullableStringFieldUpdateOperationsInput | string | null
    trace_id?: NullableStringFieldUpdateOperationsInput | string | null
    last_heartbeat_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    heartbeat_pid?: NullableIntFieldUpdateOperationsInput | number | null
    heartbeat_host?: NullableStringFieldUpdateOperationsInput | string | null
    api_key_id?: NullableStringFieldUpdateOperationsInput | string | null
    user_id?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type SessionLogCreateInput = {
    id?: string
    command_name?: string | null
    url: string
    method: string
    title: string
    subtitle?: string | null
    body?: string | null
    response: string
    screenshot?: string | null
    is_success?: boolean | null
    is_error?: boolean
    is_healed?: boolean
    original_selector?: string | null
    healed_selector?: string | null
    healing_confidence?: number | null
    healing_tier?: string | null
    original_strategy?: string | null
    healed_strategy?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    duration?: number | null
    span_id?: string | null
    trace_id?: string | null
    session: SessionCreateNestedOneWithoutSessionLogInput
  }

  export type SessionLogUncheckedCreateInput = {
    id?: string
    session_id: string
    command_name?: string | null
    url: string
    method: string
    title: string
    subtitle?: string | null
    body?: string | null
    response: string
    screenshot?: string | null
    is_success?: boolean | null
    is_error?: boolean
    is_healed?: boolean
    original_selector?: string | null
    healed_selector?: string | null
    healing_confidence?: number | null
    healing_tier?: string | null
    original_strategy?: string | null
    healed_strategy?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    duration?: number | null
    span_id?: string | null
    trace_id?: string | null
  }

  export type SessionLogUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    command_name?: NullableStringFieldUpdateOperationsInput | string | null
    url?: StringFieldUpdateOperationsInput | string
    method?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    subtitle?: NullableStringFieldUpdateOperationsInput | string | null
    body?: NullableStringFieldUpdateOperationsInput | string | null
    response?: StringFieldUpdateOperationsInput | string
    screenshot?: NullableStringFieldUpdateOperationsInput | string | null
    is_success?: NullableBoolFieldUpdateOperationsInput | boolean | null
    is_error?: BoolFieldUpdateOperationsInput | boolean
    is_healed?: BoolFieldUpdateOperationsInput | boolean
    original_selector?: NullableStringFieldUpdateOperationsInput | string | null
    healed_selector?: NullableStringFieldUpdateOperationsInput | string | null
    healing_confidence?: NullableFloatFieldUpdateOperationsInput | number | null
    healing_tier?: NullableStringFieldUpdateOperationsInput | string | null
    original_strategy?: NullableStringFieldUpdateOperationsInput | string | null
    healed_strategy?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    duration?: NullableIntFieldUpdateOperationsInput | number | null
    span_id?: NullableStringFieldUpdateOperationsInput | string | null
    trace_id?: NullableStringFieldUpdateOperationsInput | string | null
    session?: SessionUpdateOneRequiredWithoutSessionLogNestedInput
  }

  export type SessionLogUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    session_id?: StringFieldUpdateOperationsInput | string
    command_name?: NullableStringFieldUpdateOperationsInput | string | null
    url?: StringFieldUpdateOperationsInput | string
    method?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    subtitle?: NullableStringFieldUpdateOperationsInput | string | null
    body?: NullableStringFieldUpdateOperationsInput | string | null
    response?: StringFieldUpdateOperationsInput | string
    screenshot?: NullableStringFieldUpdateOperationsInput | string | null
    is_success?: NullableBoolFieldUpdateOperationsInput | boolean | null
    is_error?: BoolFieldUpdateOperationsInput | boolean
    is_healed?: BoolFieldUpdateOperationsInput | boolean
    original_selector?: NullableStringFieldUpdateOperationsInput | string | null
    healed_selector?: NullableStringFieldUpdateOperationsInput | string | null
    healing_confidence?: NullableFloatFieldUpdateOperationsInput | number | null
    healing_tier?: NullableStringFieldUpdateOperationsInput | string | null
    original_strategy?: NullableStringFieldUpdateOperationsInput | string | null
    healed_strategy?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    duration?: NullableIntFieldUpdateOperationsInput | number | null
    span_id?: NullableStringFieldUpdateOperationsInput | string | null
    trace_id?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type SessionLogCreateManyInput = {
    id?: string
    session_id: string
    command_name?: string | null
    url: string
    method: string
    title: string
    subtitle?: string | null
    body?: string | null
    response: string
    screenshot?: string | null
    is_success?: boolean | null
    is_error?: boolean
    is_healed?: boolean
    original_selector?: string | null
    healed_selector?: string | null
    healing_confidence?: number | null
    healing_tier?: string | null
    original_strategy?: string | null
    healed_strategy?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    duration?: number | null
    span_id?: string | null
    trace_id?: string | null
  }

  export type SessionLogUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    command_name?: NullableStringFieldUpdateOperationsInput | string | null
    url?: StringFieldUpdateOperationsInput | string
    method?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    subtitle?: NullableStringFieldUpdateOperationsInput | string | null
    body?: NullableStringFieldUpdateOperationsInput | string | null
    response?: StringFieldUpdateOperationsInput | string
    screenshot?: NullableStringFieldUpdateOperationsInput | string | null
    is_success?: NullableBoolFieldUpdateOperationsInput | boolean | null
    is_error?: BoolFieldUpdateOperationsInput | boolean
    is_healed?: BoolFieldUpdateOperationsInput | boolean
    original_selector?: NullableStringFieldUpdateOperationsInput | string | null
    healed_selector?: NullableStringFieldUpdateOperationsInput | string | null
    healing_confidence?: NullableFloatFieldUpdateOperationsInput | number | null
    healing_tier?: NullableStringFieldUpdateOperationsInput | string | null
    original_strategy?: NullableStringFieldUpdateOperationsInput | string | null
    healed_strategy?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    duration?: NullableIntFieldUpdateOperationsInput | number | null
    span_id?: NullableStringFieldUpdateOperationsInput | string | null
    trace_id?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type SessionLogUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    session_id?: StringFieldUpdateOperationsInput | string
    command_name?: NullableStringFieldUpdateOperationsInput | string | null
    url?: StringFieldUpdateOperationsInput | string
    method?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    subtitle?: NullableStringFieldUpdateOperationsInput | string | null
    body?: NullableStringFieldUpdateOperationsInput | string | null
    response?: StringFieldUpdateOperationsInput | string
    screenshot?: NullableStringFieldUpdateOperationsInput | string | null
    is_success?: NullableBoolFieldUpdateOperationsInput | boolean | null
    is_error?: BoolFieldUpdateOperationsInput | boolean
    is_healed?: BoolFieldUpdateOperationsInput | boolean
    original_selector?: NullableStringFieldUpdateOperationsInput | string | null
    healed_selector?: NullableStringFieldUpdateOperationsInput | string | null
    healing_confidence?: NullableFloatFieldUpdateOperationsInput | number | null
    healing_tier?: NullableStringFieldUpdateOperationsInput | string | null
    original_strategy?: NullableStringFieldUpdateOperationsInput | string | null
    healed_strategy?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    duration?: NullableIntFieldUpdateOperationsInput | number | null
    span_id?: NullableStringFieldUpdateOperationsInput | string | null
    trace_id?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type LogCreateInput = {
    id?: string
    log_type: string
    message: string
    timestamp?: Date | string
    createdAt?: Date | string
    updatedAt?: Date | string
    session: SessionCreateNestedOneWithoutLogInput
  }

  export type LogUncheckedCreateInput = {
    id?: string
    session_id: string
    log_type: string
    message: string
    timestamp?: Date | string
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type LogUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    log_type?: StringFieldUpdateOperationsInput | string
    message?: StringFieldUpdateOperationsInput | string
    timestamp?: DateTimeFieldUpdateOperationsInput | Date | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    session?: SessionUpdateOneRequiredWithoutLogNestedInput
  }

  export type LogUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    session_id?: StringFieldUpdateOperationsInput | string
    log_type?: StringFieldUpdateOperationsInput | string
    message?: StringFieldUpdateOperationsInput | string
    timestamp?: DateTimeFieldUpdateOperationsInput | Date | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type LogCreateManyInput = {
    id?: string
    session_id: string
    log_type: string
    message: string
    timestamp?: Date | string
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type LogUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    log_type?: StringFieldUpdateOperationsInput | string
    message?: StringFieldUpdateOperationsInput | string
    timestamp?: DateTimeFieldUpdateOperationsInput | Date | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type LogUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    session_id?: StringFieldUpdateOperationsInput | string
    log_type?: StringFieldUpdateOperationsInput | string
    message?: StringFieldUpdateOperationsInput | string
    timestamp?: DateTimeFieldUpdateOperationsInput | Date | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type ProfilingCreateInput = {
    cpu?: string | null
    memory?: string | null
    total_cpu_used?: string | null
    total_memory_used?: string | null
    raw_cpu_log?: string | null
    raw_memory_log?: string | null
    timestamp: Date | string
    createdAt?: Date | string
    updatedAt?: Date | string
    session: SessionCreateNestedOneWithoutProfilingInput
  }

  export type ProfilingUncheckedCreateInput = {
    id?: number
    session_id: string
    cpu?: string | null
    memory?: string | null
    total_cpu_used?: string | null
    total_memory_used?: string | null
    raw_cpu_log?: string | null
    raw_memory_log?: string | null
    timestamp: Date | string
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type ProfilingUpdateInput = {
    cpu?: NullableStringFieldUpdateOperationsInput | string | null
    memory?: NullableStringFieldUpdateOperationsInput | string | null
    total_cpu_used?: NullableStringFieldUpdateOperationsInput | string | null
    total_memory_used?: NullableStringFieldUpdateOperationsInput | string | null
    raw_cpu_log?: NullableStringFieldUpdateOperationsInput | string | null
    raw_memory_log?: NullableStringFieldUpdateOperationsInput | string | null
    timestamp?: DateTimeFieldUpdateOperationsInput | Date | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    session?: SessionUpdateOneRequiredWithoutProfilingNestedInput
  }

  export type ProfilingUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    session_id?: StringFieldUpdateOperationsInput | string
    cpu?: NullableStringFieldUpdateOperationsInput | string | null
    memory?: NullableStringFieldUpdateOperationsInput | string | null
    total_cpu_used?: NullableStringFieldUpdateOperationsInput | string | null
    total_memory_used?: NullableStringFieldUpdateOperationsInput | string | null
    raw_cpu_log?: NullableStringFieldUpdateOperationsInput | string | null
    raw_memory_log?: NullableStringFieldUpdateOperationsInput | string | null
    timestamp?: DateTimeFieldUpdateOperationsInput | Date | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type ProfilingCreateManyInput = {
    id?: number
    session_id: string
    cpu?: string | null
    memory?: string | null
    total_cpu_used?: string | null
    total_memory_used?: string | null
    raw_cpu_log?: string | null
    raw_memory_log?: string | null
    timestamp: Date | string
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type ProfilingUpdateManyMutationInput = {
    cpu?: NullableStringFieldUpdateOperationsInput | string | null
    memory?: NullableStringFieldUpdateOperationsInput | string | null
    total_cpu_used?: NullableStringFieldUpdateOperationsInput | string | null
    total_memory_used?: NullableStringFieldUpdateOperationsInput | string | null
    raw_cpu_log?: NullableStringFieldUpdateOperationsInput | string | null
    raw_memory_log?: NullableStringFieldUpdateOperationsInput | string | null
    timestamp?: DateTimeFieldUpdateOperationsInput | Date | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type ProfilingUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    session_id?: StringFieldUpdateOperationsInput | string
    cpu?: NullableStringFieldUpdateOperationsInput | string | null
    memory?: NullableStringFieldUpdateOperationsInput | string | null
    total_cpu_used?: NullableStringFieldUpdateOperationsInput | string | null
    total_memory_used?: NullableStringFieldUpdateOperationsInput | string | null
    raw_cpu_log?: NullableStringFieldUpdateOperationsInput | string | null
    raw_memory_log?: NullableStringFieldUpdateOperationsInput | string | null
    timestamp?: DateTimeFieldUpdateOperationsInput | Date | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type AppCreateInput = {
    id?: string
    name: string
    filename: string
    filepath: string
    mimetype: string
    size: number
    packageName?: string | null
    version?: string | null
    platform?: string | null
    md5?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type AppUncheckedCreateInput = {
    id?: string
    name: string
    filename: string
    filepath: string
    mimetype: string
    size: number
    packageName?: string | null
    version?: string | null
    platform?: string | null
    md5?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type AppUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    filename?: StringFieldUpdateOperationsInput | string
    filepath?: StringFieldUpdateOperationsInput | string
    mimetype?: StringFieldUpdateOperationsInput | string
    size?: IntFieldUpdateOperationsInput | number
    packageName?: NullableStringFieldUpdateOperationsInput | string | null
    version?: NullableStringFieldUpdateOperationsInput | string | null
    platform?: NullableStringFieldUpdateOperationsInput | string | null
    md5?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type AppUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    filename?: StringFieldUpdateOperationsInput | string
    filepath?: StringFieldUpdateOperationsInput | string
    mimetype?: StringFieldUpdateOperationsInput | string
    size?: IntFieldUpdateOperationsInput | number
    packageName?: NullableStringFieldUpdateOperationsInput | string | null
    version?: NullableStringFieldUpdateOperationsInput | string | null
    platform?: NullableStringFieldUpdateOperationsInput | string | null
    md5?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type AppCreateManyInput = {
    id?: string
    name: string
    filename: string
    filepath: string
    mimetype: string
    size: number
    packageName?: string | null
    version?: string | null
    platform?: string | null
    md5?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type AppUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    filename?: StringFieldUpdateOperationsInput | string
    filepath?: StringFieldUpdateOperationsInput | string
    mimetype?: StringFieldUpdateOperationsInput | string
    size?: IntFieldUpdateOperationsInput | number
    packageName?: NullableStringFieldUpdateOperationsInput | string | null
    version?: NullableStringFieldUpdateOperationsInput | string | null
    platform?: NullableStringFieldUpdateOperationsInput | string | null
    md5?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type AppUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    filename?: StringFieldUpdateOperationsInput | string
    filepath?: StringFieldUpdateOperationsInput | string
    mimetype?: StringFieldUpdateOperationsInput | string
    size?: IntFieldUpdateOperationsInput | number
    packageName?: NullableStringFieldUpdateOperationsInput | string | null
    version?: NullableStringFieldUpdateOperationsInput | string | null
    platform?: NullableStringFieldUpdateOperationsInput | string | null
    md5?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type DeviceCreateInput = {
    udid: string
    host: string
    systemPort?: number | null
    proxyPort?: number | null
    proxyHost?: string | null
    wdaLocalPort?: number | null
    name?: string | null
    state?: string | null
    sdk?: string | null
    platform?: string | null
    deviceType?: string | null
    busy?: boolean | null
    userBlocked?: boolean | null
    realDevice?: boolean | null
    session_id?: string | null
    offline?: boolean | null
    mjpegServerPort?: number | null
    lastCmdExecutedAt?: number | null
    totalUtilizationTimeMilliSec?: number
    sessionStartTime?: number
    newCommandTimeout?: number | null
    cloud?: string | null
    derivedDataPath?: string | null
    chromeDriverPath?: string | null
    capability?: string | null
    adbRemoteHost?: string | null
    adbPort?: number | null
    nodeId?: string | null
    screenWidth?: string | null
    screenHeight?: string | null
    dashboard_link?: string | null
    total_session_count?: number | null
    createdAt?: Date | string
    updatedAt?: Date | string
    healthCheckError?: string | null
    healthStatus?: string | null
    lastHealthCheckAt?: number | null
    batteryLevel?: number | null
    reservationReason?: string | null
    reservedBy?: string | null
    reservedUntil?: number | null
    storageFree?: string | null
    tags?: string | null
    thermalStatus?: string | null
    sessionProgress?: string | null
    totalHealedCount?: number | null
    ip?: string | null
    cpuArchitecture?: string | null
    owningSessionId?: string | null
    lockedAt?: number | null
    team?: TeamCreateNestedOneWithoutDevicesInput
  }

  export type DeviceUncheckedCreateInput = {
    udid: string
    host: string
    systemPort?: number | null
    proxyPort?: number | null
    proxyHost?: string | null
    wdaLocalPort?: number | null
    name?: string | null
    state?: string | null
    sdk?: string | null
    platform?: string | null
    deviceType?: string | null
    busy?: boolean | null
    userBlocked?: boolean | null
    realDevice?: boolean | null
    session_id?: string | null
    offline?: boolean | null
    mjpegServerPort?: number | null
    lastCmdExecutedAt?: number | null
    totalUtilizationTimeMilliSec?: number
    sessionStartTime?: number
    newCommandTimeout?: number | null
    cloud?: string | null
    derivedDataPath?: string | null
    chromeDriverPath?: string | null
    capability?: string | null
    adbRemoteHost?: string | null
    adbPort?: number | null
    nodeId?: string | null
    screenWidth?: string | null
    screenHeight?: string | null
    dashboard_link?: string | null
    total_session_count?: number | null
    createdAt?: Date | string
    updatedAt?: Date | string
    healthCheckError?: string | null
    healthStatus?: string | null
    lastHealthCheckAt?: number | null
    batteryLevel?: number | null
    reservationReason?: string | null
    reservedBy?: string | null
    reservedUntil?: number | null
    storageFree?: string | null
    tags?: string | null
    thermalStatus?: string | null
    sessionProgress?: string | null
    totalHealedCount?: number | null
    ip?: string | null
    cpuArchitecture?: string | null
    owningSessionId?: string | null
    lockedAt?: number | null
    teamId?: string | null
  }

  export type DeviceUpdateInput = {
    udid?: StringFieldUpdateOperationsInput | string
    host?: StringFieldUpdateOperationsInput | string
    systemPort?: NullableIntFieldUpdateOperationsInput | number | null
    proxyPort?: NullableIntFieldUpdateOperationsInput | number | null
    proxyHost?: NullableStringFieldUpdateOperationsInput | string | null
    wdaLocalPort?: NullableIntFieldUpdateOperationsInput | number | null
    name?: NullableStringFieldUpdateOperationsInput | string | null
    state?: NullableStringFieldUpdateOperationsInput | string | null
    sdk?: NullableStringFieldUpdateOperationsInput | string | null
    platform?: NullableStringFieldUpdateOperationsInput | string | null
    deviceType?: NullableStringFieldUpdateOperationsInput | string | null
    busy?: NullableBoolFieldUpdateOperationsInput | boolean | null
    userBlocked?: NullableBoolFieldUpdateOperationsInput | boolean | null
    realDevice?: NullableBoolFieldUpdateOperationsInput | boolean | null
    session_id?: NullableStringFieldUpdateOperationsInput | string | null
    offline?: NullableBoolFieldUpdateOperationsInput | boolean | null
    mjpegServerPort?: NullableIntFieldUpdateOperationsInput | number | null
    lastCmdExecutedAt?: NullableFloatFieldUpdateOperationsInput | number | null
    totalUtilizationTimeMilliSec?: FloatFieldUpdateOperationsInput | number
    sessionStartTime?: FloatFieldUpdateOperationsInput | number
    newCommandTimeout?: NullableIntFieldUpdateOperationsInput | number | null
    cloud?: NullableStringFieldUpdateOperationsInput | string | null
    derivedDataPath?: NullableStringFieldUpdateOperationsInput | string | null
    chromeDriverPath?: NullableStringFieldUpdateOperationsInput | string | null
    capability?: NullableStringFieldUpdateOperationsInput | string | null
    adbRemoteHost?: NullableStringFieldUpdateOperationsInput | string | null
    adbPort?: NullableIntFieldUpdateOperationsInput | number | null
    nodeId?: NullableStringFieldUpdateOperationsInput | string | null
    screenWidth?: NullableStringFieldUpdateOperationsInput | string | null
    screenHeight?: NullableStringFieldUpdateOperationsInput | string | null
    dashboard_link?: NullableStringFieldUpdateOperationsInput | string | null
    total_session_count?: NullableIntFieldUpdateOperationsInput | number | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    healthCheckError?: NullableStringFieldUpdateOperationsInput | string | null
    healthStatus?: NullableStringFieldUpdateOperationsInput | string | null
    lastHealthCheckAt?: NullableFloatFieldUpdateOperationsInput | number | null
    batteryLevel?: NullableIntFieldUpdateOperationsInput | number | null
    reservationReason?: NullableStringFieldUpdateOperationsInput | string | null
    reservedBy?: NullableStringFieldUpdateOperationsInput | string | null
    reservedUntil?: NullableFloatFieldUpdateOperationsInput | number | null
    storageFree?: NullableStringFieldUpdateOperationsInput | string | null
    tags?: NullableStringFieldUpdateOperationsInput | string | null
    thermalStatus?: NullableStringFieldUpdateOperationsInput | string | null
    sessionProgress?: NullableStringFieldUpdateOperationsInput | string | null
    totalHealedCount?: NullableIntFieldUpdateOperationsInput | number | null
    ip?: NullableStringFieldUpdateOperationsInput | string | null
    cpuArchitecture?: NullableStringFieldUpdateOperationsInput | string | null
    owningSessionId?: NullableStringFieldUpdateOperationsInput | string | null
    lockedAt?: NullableFloatFieldUpdateOperationsInput | number | null
    team?: TeamUpdateOneWithoutDevicesNestedInput
  }

  export type DeviceUncheckedUpdateInput = {
    udid?: StringFieldUpdateOperationsInput | string
    host?: StringFieldUpdateOperationsInput | string
    systemPort?: NullableIntFieldUpdateOperationsInput | number | null
    proxyPort?: NullableIntFieldUpdateOperationsInput | number | null
    proxyHost?: NullableStringFieldUpdateOperationsInput | string | null
    wdaLocalPort?: NullableIntFieldUpdateOperationsInput | number | null
    name?: NullableStringFieldUpdateOperationsInput | string | null
    state?: NullableStringFieldUpdateOperationsInput | string | null
    sdk?: NullableStringFieldUpdateOperationsInput | string | null
    platform?: NullableStringFieldUpdateOperationsInput | string | null
    deviceType?: NullableStringFieldUpdateOperationsInput | string | null
    busy?: NullableBoolFieldUpdateOperationsInput | boolean | null
    userBlocked?: NullableBoolFieldUpdateOperationsInput | boolean | null
    realDevice?: NullableBoolFieldUpdateOperationsInput | boolean | null
    session_id?: NullableStringFieldUpdateOperationsInput | string | null
    offline?: NullableBoolFieldUpdateOperationsInput | boolean | null
    mjpegServerPort?: NullableIntFieldUpdateOperationsInput | number | null
    lastCmdExecutedAt?: NullableFloatFieldUpdateOperationsInput | number | null
    totalUtilizationTimeMilliSec?: FloatFieldUpdateOperationsInput | number
    sessionStartTime?: FloatFieldUpdateOperationsInput | number
    newCommandTimeout?: NullableIntFieldUpdateOperationsInput | number | null
    cloud?: NullableStringFieldUpdateOperationsInput | string | null
    derivedDataPath?: NullableStringFieldUpdateOperationsInput | string | null
    chromeDriverPath?: NullableStringFieldUpdateOperationsInput | string | null
    capability?: NullableStringFieldUpdateOperationsInput | string | null
    adbRemoteHost?: NullableStringFieldUpdateOperationsInput | string | null
    adbPort?: NullableIntFieldUpdateOperationsInput | number | null
    nodeId?: NullableStringFieldUpdateOperationsInput | string | null
    screenWidth?: NullableStringFieldUpdateOperationsInput | string | null
    screenHeight?: NullableStringFieldUpdateOperationsInput | string | null
    dashboard_link?: NullableStringFieldUpdateOperationsInput | string | null
    total_session_count?: NullableIntFieldUpdateOperationsInput | number | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    healthCheckError?: NullableStringFieldUpdateOperationsInput | string | null
    healthStatus?: NullableStringFieldUpdateOperationsInput | string | null
    lastHealthCheckAt?: NullableFloatFieldUpdateOperationsInput | number | null
    batteryLevel?: NullableIntFieldUpdateOperationsInput | number | null
    reservationReason?: NullableStringFieldUpdateOperationsInput | string | null
    reservedBy?: NullableStringFieldUpdateOperationsInput | string | null
    reservedUntil?: NullableFloatFieldUpdateOperationsInput | number | null
    storageFree?: NullableStringFieldUpdateOperationsInput | string | null
    tags?: NullableStringFieldUpdateOperationsInput | string | null
    thermalStatus?: NullableStringFieldUpdateOperationsInput | string | null
    sessionProgress?: NullableStringFieldUpdateOperationsInput | string | null
    totalHealedCount?: NullableIntFieldUpdateOperationsInput | number | null
    ip?: NullableStringFieldUpdateOperationsInput | string | null
    cpuArchitecture?: NullableStringFieldUpdateOperationsInput | string | null
    owningSessionId?: NullableStringFieldUpdateOperationsInput | string | null
    lockedAt?: NullableFloatFieldUpdateOperationsInput | number | null
    teamId?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type DeviceCreateManyInput = {
    udid: string
    host: string
    systemPort?: number | null
    proxyPort?: number | null
    proxyHost?: string | null
    wdaLocalPort?: number | null
    name?: string | null
    state?: string | null
    sdk?: string | null
    platform?: string | null
    deviceType?: string | null
    busy?: boolean | null
    userBlocked?: boolean | null
    realDevice?: boolean | null
    session_id?: string | null
    offline?: boolean | null
    mjpegServerPort?: number | null
    lastCmdExecutedAt?: number | null
    totalUtilizationTimeMilliSec?: number
    sessionStartTime?: number
    newCommandTimeout?: number | null
    cloud?: string | null
    derivedDataPath?: string | null
    chromeDriverPath?: string | null
    capability?: string | null
    adbRemoteHost?: string | null
    adbPort?: number | null
    nodeId?: string | null
    screenWidth?: string | null
    screenHeight?: string | null
    dashboard_link?: string | null
    total_session_count?: number | null
    createdAt?: Date | string
    updatedAt?: Date | string
    healthCheckError?: string | null
    healthStatus?: string | null
    lastHealthCheckAt?: number | null
    batteryLevel?: number | null
    reservationReason?: string | null
    reservedBy?: string | null
    reservedUntil?: number | null
    storageFree?: string | null
    tags?: string | null
    thermalStatus?: string | null
    sessionProgress?: string | null
    totalHealedCount?: number | null
    ip?: string | null
    cpuArchitecture?: string | null
    owningSessionId?: string | null
    lockedAt?: number | null
    teamId?: string | null
  }

  export type DeviceUpdateManyMutationInput = {
    udid?: StringFieldUpdateOperationsInput | string
    host?: StringFieldUpdateOperationsInput | string
    systemPort?: NullableIntFieldUpdateOperationsInput | number | null
    proxyPort?: NullableIntFieldUpdateOperationsInput | number | null
    proxyHost?: NullableStringFieldUpdateOperationsInput | string | null
    wdaLocalPort?: NullableIntFieldUpdateOperationsInput | number | null
    name?: NullableStringFieldUpdateOperationsInput | string | null
    state?: NullableStringFieldUpdateOperationsInput | string | null
    sdk?: NullableStringFieldUpdateOperationsInput | string | null
    platform?: NullableStringFieldUpdateOperationsInput | string | null
    deviceType?: NullableStringFieldUpdateOperationsInput | string | null
    busy?: NullableBoolFieldUpdateOperationsInput | boolean | null
    userBlocked?: NullableBoolFieldUpdateOperationsInput | boolean | null
    realDevice?: NullableBoolFieldUpdateOperationsInput | boolean | null
    session_id?: NullableStringFieldUpdateOperationsInput | string | null
    offline?: NullableBoolFieldUpdateOperationsInput | boolean | null
    mjpegServerPort?: NullableIntFieldUpdateOperationsInput | number | null
    lastCmdExecutedAt?: NullableFloatFieldUpdateOperationsInput | number | null
    totalUtilizationTimeMilliSec?: FloatFieldUpdateOperationsInput | number
    sessionStartTime?: FloatFieldUpdateOperationsInput | number
    newCommandTimeout?: NullableIntFieldUpdateOperationsInput | number | null
    cloud?: NullableStringFieldUpdateOperationsInput | string | null
    derivedDataPath?: NullableStringFieldUpdateOperationsInput | string | null
    chromeDriverPath?: NullableStringFieldUpdateOperationsInput | string | null
    capability?: NullableStringFieldUpdateOperationsInput | string | null
    adbRemoteHost?: NullableStringFieldUpdateOperationsInput | string | null
    adbPort?: NullableIntFieldUpdateOperationsInput | number | null
    nodeId?: NullableStringFieldUpdateOperationsInput | string | null
    screenWidth?: NullableStringFieldUpdateOperationsInput | string | null
    screenHeight?: NullableStringFieldUpdateOperationsInput | string | null
    dashboard_link?: NullableStringFieldUpdateOperationsInput | string | null
    total_session_count?: NullableIntFieldUpdateOperationsInput | number | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    healthCheckError?: NullableStringFieldUpdateOperationsInput | string | null
    healthStatus?: NullableStringFieldUpdateOperationsInput | string | null
    lastHealthCheckAt?: NullableFloatFieldUpdateOperationsInput | number | null
    batteryLevel?: NullableIntFieldUpdateOperationsInput | number | null
    reservationReason?: NullableStringFieldUpdateOperationsInput | string | null
    reservedBy?: NullableStringFieldUpdateOperationsInput | string | null
    reservedUntil?: NullableFloatFieldUpdateOperationsInput | number | null
    storageFree?: NullableStringFieldUpdateOperationsInput | string | null
    tags?: NullableStringFieldUpdateOperationsInput | string | null
    thermalStatus?: NullableStringFieldUpdateOperationsInput | string | null
    sessionProgress?: NullableStringFieldUpdateOperationsInput | string | null
    totalHealedCount?: NullableIntFieldUpdateOperationsInput | number | null
    ip?: NullableStringFieldUpdateOperationsInput | string | null
    cpuArchitecture?: NullableStringFieldUpdateOperationsInput | string | null
    owningSessionId?: NullableStringFieldUpdateOperationsInput | string | null
    lockedAt?: NullableFloatFieldUpdateOperationsInput | number | null
  }

  export type DeviceUncheckedUpdateManyInput = {
    udid?: StringFieldUpdateOperationsInput | string
    host?: StringFieldUpdateOperationsInput | string
    systemPort?: NullableIntFieldUpdateOperationsInput | number | null
    proxyPort?: NullableIntFieldUpdateOperationsInput | number | null
    proxyHost?: NullableStringFieldUpdateOperationsInput | string | null
    wdaLocalPort?: NullableIntFieldUpdateOperationsInput | number | null
    name?: NullableStringFieldUpdateOperationsInput | string | null
    state?: NullableStringFieldUpdateOperationsInput | string | null
    sdk?: NullableStringFieldUpdateOperationsInput | string | null
    platform?: NullableStringFieldUpdateOperationsInput | string | null
    deviceType?: NullableStringFieldUpdateOperationsInput | string | null
    busy?: NullableBoolFieldUpdateOperationsInput | boolean | null
    userBlocked?: NullableBoolFieldUpdateOperationsInput | boolean | null
    realDevice?: NullableBoolFieldUpdateOperationsInput | boolean | null
    session_id?: NullableStringFieldUpdateOperationsInput | string | null
    offline?: NullableBoolFieldUpdateOperationsInput | boolean | null
    mjpegServerPort?: NullableIntFieldUpdateOperationsInput | number | null
    lastCmdExecutedAt?: NullableFloatFieldUpdateOperationsInput | number | null
    totalUtilizationTimeMilliSec?: FloatFieldUpdateOperationsInput | number
    sessionStartTime?: FloatFieldUpdateOperationsInput | number
    newCommandTimeout?: NullableIntFieldUpdateOperationsInput | number | null
    cloud?: NullableStringFieldUpdateOperationsInput | string | null
    derivedDataPath?: NullableStringFieldUpdateOperationsInput | string | null
    chromeDriverPath?: NullableStringFieldUpdateOperationsInput | string | null
    capability?: NullableStringFieldUpdateOperationsInput | string | null
    adbRemoteHost?: NullableStringFieldUpdateOperationsInput | string | null
    adbPort?: NullableIntFieldUpdateOperationsInput | number | null
    nodeId?: NullableStringFieldUpdateOperationsInput | string | null
    screenWidth?: NullableStringFieldUpdateOperationsInput | string | null
    screenHeight?: NullableStringFieldUpdateOperationsInput | string | null
    dashboard_link?: NullableStringFieldUpdateOperationsInput | string | null
    total_session_count?: NullableIntFieldUpdateOperationsInput | number | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    healthCheckError?: NullableStringFieldUpdateOperationsInput | string | null
    healthStatus?: NullableStringFieldUpdateOperationsInput | string | null
    lastHealthCheckAt?: NullableFloatFieldUpdateOperationsInput | number | null
    batteryLevel?: NullableIntFieldUpdateOperationsInput | number | null
    reservationReason?: NullableStringFieldUpdateOperationsInput | string | null
    reservedBy?: NullableStringFieldUpdateOperationsInput | string | null
    reservedUntil?: NullableFloatFieldUpdateOperationsInput | number | null
    storageFree?: NullableStringFieldUpdateOperationsInput | string | null
    tags?: NullableStringFieldUpdateOperationsInput | string | null
    thermalStatus?: NullableStringFieldUpdateOperationsInput | string | null
    sessionProgress?: NullableStringFieldUpdateOperationsInput | string | null
    totalHealedCount?: NullableIntFieldUpdateOperationsInput | number | null
    ip?: NullableStringFieldUpdateOperationsInput | string | null
    cpuArchitecture?: NullableStringFieldUpdateOperationsInput | string | null
    owningSessionId?: NullableStringFieldUpdateOperationsInput | string | null
    lockedAt?: NullableFloatFieldUpdateOperationsInput | number | null
    teamId?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type PendingSessionCreateInput = {
    capability_id: string
    capability: string
    createdAt: number
  }

  export type PendingSessionUncheckedCreateInput = {
    id?: number
    capability_id: string
    capability: string
    createdAt: number
  }

  export type PendingSessionUpdateInput = {
    capability_id?: StringFieldUpdateOperationsInput | string
    capability?: StringFieldUpdateOperationsInput | string
    createdAt?: FloatFieldUpdateOperationsInput | number
  }

  export type PendingSessionUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    capability_id?: StringFieldUpdateOperationsInput | string
    capability?: StringFieldUpdateOperationsInput | string
    createdAt?: FloatFieldUpdateOperationsInput | number
  }

  export type PendingSessionCreateManyInput = {
    id?: number
    capability_id: string
    capability: string
    createdAt: number
  }

  export type PendingSessionUpdateManyMutationInput = {
    capability_id?: StringFieldUpdateOperationsInput | string
    capability?: StringFieldUpdateOperationsInput | string
    createdAt?: FloatFieldUpdateOperationsInput | number
  }

  export type PendingSessionUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    capability_id?: StringFieldUpdateOperationsInput | string
    capability?: StringFieldUpdateOperationsInput | string
    createdAt?: FloatFieldUpdateOperationsInput | number
  }

  export type CLIArgsCreateInput = {
    args: string
    createdAt?: Date | string
  }

  export type CLIArgsUncheckedCreateInput = {
    id?: number
    args: string
    createdAt?: Date | string
  }

  export type CLIArgsUpdateInput = {
    args?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type CLIArgsUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    args?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type CLIArgsCreateManyInput = {
    id?: number
    args: string
    createdAt?: Date | string
  }

  export type CLIArgsUpdateManyMutationInput = {
    args?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type CLIArgsUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    args?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type WebhookConfigCreateInput = {
    id?: string
    url: string
    type?: string
    events: string
    active?: boolean
    createdAt?: Date | string
    updatedAt?: Date | string
    payloadTemplate?: string | null
  }

  export type WebhookConfigUncheckedCreateInput = {
    id?: string
    url: string
    type?: string
    events: string
    active?: boolean
    createdAt?: Date | string
    updatedAt?: Date | string
    payloadTemplate?: string | null
  }

  export type WebhookConfigUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    url?: StringFieldUpdateOperationsInput | string
    type?: StringFieldUpdateOperationsInput | string
    events?: StringFieldUpdateOperationsInput | string
    active?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    payloadTemplate?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type WebhookConfigUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    url?: StringFieldUpdateOperationsInput | string
    type?: StringFieldUpdateOperationsInput | string
    events?: StringFieldUpdateOperationsInput | string
    active?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    payloadTemplate?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type WebhookConfigCreateManyInput = {
    id?: string
    url: string
    type?: string
    events: string
    active?: boolean
    createdAt?: Date | string
    updatedAt?: Date | string
    payloadTemplate?: string | null
  }

  export type WebhookConfigUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    url?: StringFieldUpdateOperationsInput | string
    type?: StringFieldUpdateOperationsInput | string
    events?: StringFieldUpdateOperationsInput | string
    active?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    payloadTemplate?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type WebhookConfigUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    url?: StringFieldUpdateOperationsInput | string
    type?: StringFieldUpdateOperationsInput | string
    events?: StringFieldUpdateOperationsInput | string
    active?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    payloadTemplate?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type WebConfigCreateInput = {
    id?: string
    name: string
    value: string
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type WebConfigUncheckedCreateInput = {
    id?: string
    name: string
    value: string
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type WebConfigUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    value?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type WebConfigUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    value?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type WebConfigCreateManyInput = {
    id?: string
    name: string
    value: string
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type WebConfigUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    value?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type WebConfigUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    value?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type LocatorEtalonCreateInput = {
    id?: string
    selector: string
    strategy: string
    attributes: string
    nodeName: string
    lastSeen?: Date | string
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type LocatorEtalonUncheckedCreateInput = {
    id?: string
    selector: string
    strategy: string
    attributes: string
    nodeName: string
    lastSeen?: Date | string
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type LocatorEtalonUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    selector?: StringFieldUpdateOperationsInput | string
    strategy?: StringFieldUpdateOperationsInput | string
    attributes?: StringFieldUpdateOperationsInput | string
    nodeName?: StringFieldUpdateOperationsInput | string
    lastSeen?: DateTimeFieldUpdateOperationsInput | Date | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type LocatorEtalonUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    selector?: StringFieldUpdateOperationsInput | string
    strategy?: StringFieldUpdateOperationsInput | string
    attributes?: StringFieldUpdateOperationsInput | string
    nodeName?: StringFieldUpdateOperationsInput | string
    lastSeen?: DateTimeFieldUpdateOperationsInput | Date | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type LocatorEtalonCreateManyInput = {
    id?: string
    selector: string
    strategy: string
    attributes: string
    nodeName: string
    lastSeen?: Date | string
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type LocatorEtalonUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    selector?: StringFieldUpdateOperationsInput | string
    strategy?: StringFieldUpdateOperationsInput | string
    attributes?: StringFieldUpdateOperationsInput | string
    nodeName?: StringFieldUpdateOperationsInput | string
    lastSeen?: DateTimeFieldUpdateOperationsInput | Date | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type LocatorEtalonUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    selector?: StringFieldUpdateOperationsInput | string
    strategy?: StringFieldUpdateOperationsInput | string
    attributes?: StringFieldUpdateOperationsInput | string
    nodeName?: StringFieldUpdateOperationsInput | string
    lastSeen?: DateTimeFieldUpdateOperationsInput | Date | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type PortLeaseCreateInput = {
    port: number
    purpose: string
    leasedToUdid: string
    leasedToHost?: string
    leaseId?: string | null
    leasedToPid?: number | null
    leasedAt: number
    expiresAt: number
  }

  export type PortLeaseUncheckedCreateInput = {
    port: number
    purpose: string
    leasedToUdid: string
    leasedToHost?: string
    leaseId?: string | null
    leasedToPid?: number | null
    leasedAt: number
    expiresAt: number
  }

  export type PortLeaseUpdateInput = {
    port?: IntFieldUpdateOperationsInput | number
    purpose?: StringFieldUpdateOperationsInput | string
    leasedToUdid?: StringFieldUpdateOperationsInput | string
    leasedToHost?: StringFieldUpdateOperationsInput | string
    leaseId?: NullableStringFieldUpdateOperationsInput | string | null
    leasedToPid?: NullableIntFieldUpdateOperationsInput | number | null
    leasedAt?: FloatFieldUpdateOperationsInput | number
    expiresAt?: FloatFieldUpdateOperationsInput | number
  }

  export type PortLeaseUncheckedUpdateInput = {
    port?: IntFieldUpdateOperationsInput | number
    purpose?: StringFieldUpdateOperationsInput | string
    leasedToUdid?: StringFieldUpdateOperationsInput | string
    leasedToHost?: StringFieldUpdateOperationsInput | string
    leaseId?: NullableStringFieldUpdateOperationsInput | string | null
    leasedToPid?: NullableIntFieldUpdateOperationsInput | number | null
    leasedAt?: FloatFieldUpdateOperationsInput | number
    expiresAt?: FloatFieldUpdateOperationsInput | number
  }

  export type PortLeaseCreateManyInput = {
    port: number
    purpose: string
    leasedToUdid: string
    leasedToHost?: string
    leaseId?: string | null
    leasedToPid?: number | null
    leasedAt: number
    expiresAt: number
  }

  export type PortLeaseUpdateManyMutationInput = {
    port?: IntFieldUpdateOperationsInput | number
    purpose?: StringFieldUpdateOperationsInput | string
    leasedToUdid?: StringFieldUpdateOperationsInput | string
    leasedToHost?: StringFieldUpdateOperationsInput | string
    leaseId?: NullableStringFieldUpdateOperationsInput | string | null
    leasedToPid?: NullableIntFieldUpdateOperationsInput | number | null
    leasedAt?: FloatFieldUpdateOperationsInput | number
    expiresAt?: FloatFieldUpdateOperationsInput | number
  }

  export type PortLeaseUncheckedUpdateManyInput = {
    port?: IntFieldUpdateOperationsInput | number
    purpose?: StringFieldUpdateOperationsInput | string
    leasedToUdid?: StringFieldUpdateOperationsInput | string
    leasedToHost?: StringFieldUpdateOperationsInput | string
    leaseId?: NullableStringFieldUpdateOperationsInput | string | null
    leasedToPid?: NullableIntFieldUpdateOperationsInput | number | null
    leasedAt?: FloatFieldUpdateOperationsInput | number
    expiresAt?: FloatFieldUpdateOperationsInput | number
  }

  export type LeaseCreateInput = {
    id?: string
    tokenHash: string
    deviceUdid: string
    deviceHost: string
    actorId: string
    teamId?: string | null
    buildId?: string | null
    reason?: string | null
    status?: string
    createdAt?: Date | string
    expiresAt: number
    heartbeatSeconds?: number
    lastHeartbeatAt: number
    allocatedPorts: string
    capabilityBag: string
  }

  export type LeaseUncheckedCreateInput = {
    id?: string
    tokenHash: string
    deviceUdid: string
    deviceHost: string
    actorId: string
    teamId?: string | null
    buildId?: string | null
    reason?: string | null
    status?: string
    createdAt?: Date | string
    expiresAt: number
    heartbeatSeconds?: number
    lastHeartbeatAt: number
    allocatedPorts: string
    capabilityBag: string
  }

  export type LeaseUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    tokenHash?: StringFieldUpdateOperationsInput | string
    deviceUdid?: StringFieldUpdateOperationsInput | string
    deviceHost?: StringFieldUpdateOperationsInput | string
    actorId?: StringFieldUpdateOperationsInput | string
    teamId?: NullableStringFieldUpdateOperationsInput | string | null
    buildId?: NullableStringFieldUpdateOperationsInput | string | null
    reason?: NullableStringFieldUpdateOperationsInput | string | null
    status?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    expiresAt?: FloatFieldUpdateOperationsInput | number
    heartbeatSeconds?: IntFieldUpdateOperationsInput | number
    lastHeartbeatAt?: FloatFieldUpdateOperationsInput | number
    allocatedPorts?: StringFieldUpdateOperationsInput | string
    capabilityBag?: StringFieldUpdateOperationsInput | string
  }

  export type LeaseUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    tokenHash?: StringFieldUpdateOperationsInput | string
    deviceUdid?: StringFieldUpdateOperationsInput | string
    deviceHost?: StringFieldUpdateOperationsInput | string
    actorId?: StringFieldUpdateOperationsInput | string
    teamId?: NullableStringFieldUpdateOperationsInput | string | null
    buildId?: NullableStringFieldUpdateOperationsInput | string | null
    reason?: NullableStringFieldUpdateOperationsInput | string | null
    status?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    expiresAt?: FloatFieldUpdateOperationsInput | number
    heartbeatSeconds?: IntFieldUpdateOperationsInput | number
    lastHeartbeatAt?: FloatFieldUpdateOperationsInput | number
    allocatedPorts?: StringFieldUpdateOperationsInput | string
    capabilityBag?: StringFieldUpdateOperationsInput | string
  }

  export type LeaseCreateManyInput = {
    id?: string
    tokenHash: string
    deviceUdid: string
    deviceHost: string
    actorId: string
    teamId?: string | null
    buildId?: string | null
    reason?: string | null
    status?: string
    createdAt?: Date | string
    expiresAt: number
    heartbeatSeconds?: number
    lastHeartbeatAt: number
    allocatedPorts: string
    capabilityBag: string
  }

  export type LeaseUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    tokenHash?: StringFieldUpdateOperationsInput | string
    deviceUdid?: StringFieldUpdateOperationsInput | string
    deviceHost?: StringFieldUpdateOperationsInput | string
    actorId?: StringFieldUpdateOperationsInput | string
    teamId?: NullableStringFieldUpdateOperationsInput | string | null
    buildId?: NullableStringFieldUpdateOperationsInput | string | null
    reason?: NullableStringFieldUpdateOperationsInput | string | null
    status?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    expiresAt?: FloatFieldUpdateOperationsInput | number
    heartbeatSeconds?: IntFieldUpdateOperationsInput | number
    lastHeartbeatAt?: FloatFieldUpdateOperationsInput | number
    allocatedPorts?: StringFieldUpdateOperationsInput | string
    capabilityBag?: StringFieldUpdateOperationsInput | string
  }

  export type LeaseUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    tokenHash?: StringFieldUpdateOperationsInput | string
    deviceUdid?: StringFieldUpdateOperationsInput | string
    deviceHost?: StringFieldUpdateOperationsInput | string
    actorId?: StringFieldUpdateOperationsInput | string
    teamId?: NullableStringFieldUpdateOperationsInput | string | null
    buildId?: NullableStringFieldUpdateOperationsInput | string | null
    reason?: NullableStringFieldUpdateOperationsInput | string | null
    status?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    expiresAt?: FloatFieldUpdateOperationsInput | number
    heartbeatSeconds?: IntFieldUpdateOperationsInput | number
    lastHeartbeatAt?: FloatFieldUpdateOperationsInput | number
    allocatedPorts?: StringFieldUpdateOperationsInput | string
    capabilityBag?: StringFieldUpdateOperationsInput | string
  }

  export type ApiKeyCreateInput = {
    id?: string
    name: string
    keyHash: string
    scopes: string
    rateLimit?: number
    createdAt?: Date | string
    revokedAt?: Date | string | null
    lastUsedAt?: Date | string | null
    expiresAt?: Date | string | null
    role?: string
    team?: TeamCreateNestedOneWithoutApiKeysInput
    user: UserCreateNestedOneWithoutApiKeysInput
  }

  export type ApiKeyUncheckedCreateInput = {
    id?: string
    name: string
    keyHash: string
    scopes: string
    rateLimit?: number
    createdAt?: Date | string
    revokedAt?: Date | string | null
    lastUsedAt?: Date | string | null
    expiresAt?: Date | string | null
    teamId?: string | null
    role?: string
    userId: string
  }

  export type ApiKeyUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    keyHash?: StringFieldUpdateOperationsInput | string
    scopes?: StringFieldUpdateOperationsInput | string
    rateLimit?: IntFieldUpdateOperationsInput | number
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    revokedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    lastUsedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    expiresAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    role?: StringFieldUpdateOperationsInput | string
    team?: TeamUpdateOneWithoutApiKeysNestedInput
    user?: UserUpdateOneRequiredWithoutApiKeysNestedInput
  }

  export type ApiKeyUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    keyHash?: StringFieldUpdateOperationsInput | string
    scopes?: StringFieldUpdateOperationsInput | string
    rateLimit?: IntFieldUpdateOperationsInput | number
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    revokedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    lastUsedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    expiresAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    teamId?: NullableStringFieldUpdateOperationsInput | string | null
    role?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
  }

  export type ApiKeyCreateManyInput = {
    id?: string
    name: string
    keyHash: string
    scopes: string
    rateLimit?: number
    createdAt?: Date | string
    revokedAt?: Date | string | null
    lastUsedAt?: Date | string | null
    expiresAt?: Date | string | null
    teamId?: string | null
    role?: string
    userId: string
  }

  export type ApiKeyUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    keyHash?: StringFieldUpdateOperationsInput | string
    scopes?: StringFieldUpdateOperationsInput | string
    rateLimit?: IntFieldUpdateOperationsInput | number
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    revokedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    lastUsedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    expiresAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    role?: StringFieldUpdateOperationsInput | string
  }

  export type ApiKeyUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    keyHash?: StringFieldUpdateOperationsInput | string
    scopes?: StringFieldUpdateOperationsInput | string
    rateLimit?: IntFieldUpdateOperationsInput | number
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    revokedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    lastUsedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    expiresAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    teamId?: NullableStringFieldUpdateOperationsInput | string | null
    role?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
  }

  export type TeamCreateInput = {
    id?: string
    name: string
    createdAt?: Date | string
    devices?: DeviceCreateNestedManyWithoutTeamInput
    apiKeys?: ApiKeyCreateNestedManyWithoutTeamInput
    members?: TeamMemberCreateNestedManyWithoutTeamInput
  }

  export type TeamUncheckedCreateInput = {
    id?: string
    name: string
    createdAt?: Date | string
    devices?: DeviceUncheckedCreateNestedManyWithoutTeamInput
    apiKeys?: ApiKeyUncheckedCreateNestedManyWithoutTeamInput
    members?: TeamMemberUncheckedCreateNestedManyWithoutTeamInput
  }

  export type TeamUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    devices?: DeviceUpdateManyWithoutTeamNestedInput
    apiKeys?: ApiKeyUpdateManyWithoutTeamNestedInput
    members?: TeamMemberUpdateManyWithoutTeamNestedInput
  }

  export type TeamUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    devices?: DeviceUncheckedUpdateManyWithoutTeamNestedInput
    apiKeys?: ApiKeyUncheckedUpdateManyWithoutTeamNestedInput
    members?: TeamMemberUncheckedUpdateManyWithoutTeamNestedInput
  }

  export type TeamCreateManyInput = {
    id?: string
    name: string
    createdAt?: Date | string
  }

  export type TeamUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type TeamUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type SelectorStateCreateInput = {
    id?: string
    original_strategy: string
    original_selector: string
    status: string
    fixed_at?: Date | string | null
    fixed_by_api_key?: string | null
    resolved_at?: Date | string | null
    muted_at?: Date | string | null
    muted_by_api_key?: string | null
    regression_count?: number
    clean_builds_count?: number
    last_event_at?: Date | string
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type SelectorStateUncheckedCreateInput = {
    id?: string
    original_strategy: string
    original_selector: string
    status: string
    fixed_at?: Date | string | null
    fixed_by_api_key?: string | null
    resolved_at?: Date | string | null
    muted_at?: Date | string | null
    muted_by_api_key?: string | null
    regression_count?: number
    clean_builds_count?: number
    last_event_at?: Date | string
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type SelectorStateUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    original_strategy?: StringFieldUpdateOperationsInput | string
    original_selector?: StringFieldUpdateOperationsInput | string
    status?: StringFieldUpdateOperationsInput | string
    fixed_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    fixed_by_api_key?: NullableStringFieldUpdateOperationsInput | string | null
    resolved_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    muted_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    muted_by_api_key?: NullableStringFieldUpdateOperationsInput | string | null
    regression_count?: IntFieldUpdateOperationsInput | number
    clean_builds_count?: IntFieldUpdateOperationsInput | number
    last_event_at?: DateTimeFieldUpdateOperationsInput | Date | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type SelectorStateUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    original_strategy?: StringFieldUpdateOperationsInput | string
    original_selector?: StringFieldUpdateOperationsInput | string
    status?: StringFieldUpdateOperationsInput | string
    fixed_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    fixed_by_api_key?: NullableStringFieldUpdateOperationsInput | string | null
    resolved_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    muted_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    muted_by_api_key?: NullableStringFieldUpdateOperationsInput | string | null
    regression_count?: IntFieldUpdateOperationsInput | number
    clean_builds_count?: IntFieldUpdateOperationsInput | number
    last_event_at?: DateTimeFieldUpdateOperationsInput | Date | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type SelectorStateCreateManyInput = {
    id?: string
    original_strategy: string
    original_selector: string
    status: string
    fixed_at?: Date | string | null
    fixed_by_api_key?: string | null
    resolved_at?: Date | string | null
    muted_at?: Date | string | null
    muted_by_api_key?: string | null
    regression_count?: number
    clean_builds_count?: number
    last_event_at?: Date | string
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type SelectorStateUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    original_strategy?: StringFieldUpdateOperationsInput | string
    original_selector?: StringFieldUpdateOperationsInput | string
    status?: StringFieldUpdateOperationsInput | string
    fixed_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    fixed_by_api_key?: NullableStringFieldUpdateOperationsInput | string | null
    resolved_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    muted_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    muted_by_api_key?: NullableStringFieldUpdateOperationsInput | string | null
    regression_count?: IntFieldUpdateOperationsInput | number
    clean_builds_count?: IntFieldUpdateOperationsInput | number
    last_event_at?: DateTimeFieldUpdateOperationsInput | Date | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type SelectorStateUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    original_strategy?: StringFieldUpdateOperationsInput | string
    original_selector?: StringFieldUpdateOperationsInput | string
    status?: StringFieldUpdateOperationsInput | string
    fixed_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    fixed_by_api_key?: NullableStringFieldUpdateOperationsInput | string | null
    resolved_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    muted_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    muted_by_api_key?: NullableStringFieldUpdateOperationsInput | string | null
    regression_count?: IntFieldUpdateOperationsInput | number
    clean_builds_count?: IntFieldUpdateOperationsInput | number
    last_event_at?: DateTimeFieldUpdateOperationsInput | Date | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type RecordingCreateInput = {
    id?: string
    group_id: string
    device_udid: string
    device_host?: string
    started_at: Date | string
    ended_at?: Date | string | null
    status: string
    file_path: string
    duration_ms?: number | null
    size_bytes?: number | null
    device_snapshot?: string | null
    fail_reason?: string | null
    bookmarks?: BookmarkCreateNestedManyWithoutRecordingInput
    annotations?: AnnotationCreateNestedManyWithoutRecordingInput
    Session?: SessionCreateNestedOneWithoutRecordingInput
  }

  export type RecordingUncheckedCreateInput = {
    id?: string
    group_id: string
    device_udid: string
    device_host?: string
    session_id?: string | null
    started_at: Date | string
    ended_at?: Date | string | null
    status: string
    file_path: string
    duration_ms?: number | null
    size_bytes?: number | null
    device_snapshot?: string | null
    fail_reason?: string | null
    bookmarks?: BookmarkUncheckedCreateNestedManyWithoutRecordingInput
    annotations?: AnnotationUncheckedCreateNestedManyWithoutRecordingInput
  }

  export type RecordingUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    group_id?: StringFieldUpdateOperationsInput | string
    device_udid?: StringFieldUpdateOperationsInput | string
    device_host?: StringFieldUpdateOperationsInput | string
    started_at?: DateTimeFieldUpdateOperationsInput | Date | string
    ended_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    status?: StringFieldUpdateOperationsInput | string
    file_path?: StringFieldUpdateOperationsInput | string
    duration_ms?: NullableIntFieldUpdateOperationsInput | number | null
    size_bytes?: NullableIntFieldUpdateOperationsInput | number | null
    device_snapshot?: NullableStringFieldUpdateOperationsInput | string | null
    fail_reason?: NullableStringFieldUpdateOperationsInput | string | null
    bookmarks?: BookmarkUpdateManyWithoutRecordingNestedInput
    annotations?: AnnotationUpdateManyWithoutRecordingNestedInput
    Session?: SessionUpdateOneWithoutRecordingNestedInput
  }

  export type RecordingUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    group_id?: StringFieldUpdateOperationsInput | string
    device_udid?: StringFieldUpdateOperationsInput | string
    device_host?: StringFieldUpdateOperationsInput | string
    session_id?: NullableStringFieldUpdateOperationsInput | string | null
    started_at?: DateTimeFieldUpdateOperationsInput | Date | string
    ended_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    status?: StringFieldUpdateOperationsInput | string
    file_path?: StringFieldUpdateOperationsInput | string
    duration_ms?: NullableIntFieldUpdateOperationsInput | number | null
    size_bytes?: NullableIntFieldUpdateOperationsInput | number | null
    device_snapshot?: NullableStringFieldUpdateOperationsInput | string | null
    fail_reason?: NullableStringFieldUpdateOperationsInput | string | null
    bookmarks?: BookmarkUncheckedUpdateManyWithoutRecordingNestedInput
    annotations?: AnnotationUncheckedUpdateManyWithoutRecordingNestedInput
  }

  export type RecordingCreateManyInput = {
    id?: string
    group_id: string
    device_udid: string
    device_host?: string
    session_id?: string | null
    started_at: Date | string
    ended_at?: Date | string | null
    status: string
    file_path: string
    duration_ms?: number | null
    size_bytes?: number | null
    device_snapshot?: string | null
    fail_reason?: string | null
  }

  export type RecordingUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    group_id?: StringFieldUpdateOperationsInput | string
    device_udid?: StringFieldUpdateOperationsInput | string
    device_host?: StringFieldUpdateOperationsInput | string
    started_at?: DateTimeFieldUpdateOperationsInput | Date | string
    ended_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    status?: StringFieldUpdateOperationsInput | string
    file_path?: StringFieldUpdateOperationsInput | string
    duration_ms?: NullableIntFieldUpdateOperationsInput | number | null
    size_bytes?: NullableIntFieldUpdateOperationsInput | number | null
    device_snapshot?: NullableStringFieldUpdateOperationsInput | string | null
    fail_reason?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type RecordingUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    group_id?: StringFieldUpdateOperationsInput | string
    device_udid?: StringFieldUpdateOperationsInput | string
    device_host?: StringFieldUpdateOperationsInput | string
    session_id?: NullableStringFieldUpdateOperationsInput | string | null
    started_at?: DateTimeFieldUpdateOperationsInput | Date | string
    ended_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    status?: StringFieldUpdateOperationsInput | string
    file_path?: StringFieldUpdateOperationsInput | string
    duration_ms?: NullableIntFieldUpdateOperationsInput | number | null
    size_bytes?: NullableIntFieldUpdateOperationsInput | number | null
    device_snapshot?: NullableStringFieldUpdateOperationsInput | string | null
    fail_reason?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type BookmarkCreateInput = {
    id?: string
    timecode_ms: number
    label: string
    note?: string | null
    created_at?: Date | string
    Recording: RecordingCreateNestedOneWithoutBookmarksInput
  }

  export type BookmarkUncheckedCreateInput = {
    id?: string
    recording_id: string
    timecode_ms: number
    label: string
    note?: string | null
    created_at?: Date | string
  }

  export type BookmarkUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    timecode_ms?: IntFieldUpdateOperationsInput | number
    label?: StringFieldUpdateOperationsInput | string
    note?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    Recording?: RecordingUpdateOneRequiredWithoutBookmarksNestedInput
  }

  export type BookmarkUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    recording_id?: StringFieldUpdateOperationsInput | string
    timecode_ms?: IntFieldUpdateOperationsInput | number
    label?: StringFieldUpdateOperationsInput | string
    note?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type BookmarkCreateManyInput = {
    id?: string
    recording_id: string
    timecode_ms: number
    label: string
    note?: string | null
    created_at?: Date | string
  }

  export type BookmarkUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    timecode_ms?: IntFieldUpdateOperationsInput | number
    label?: StringFieldUpdateOperationsInput | string
    note?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type BookmarkUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    recording_id?: StringFieldUpdateOperationsInput | string
    timecode_ms?: IntFieldUpdateOperationsInput | number
    label?: StringFieldUpdateOperationsInput | string
    note?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type AnnotationCreateInput = {
    id?: string
    timecode_ms: number
    shape: string
    geometry: string
    color: string
    text?: string | null
    author?: string | null
    created_at?: Date | string
    Recording: RecordingCreateNestedOneWithoutAnnotationsInput
  }

  export type AnnotationUncheckedCreateInput = {
    id?: string
    recording_id: string
    timecode_ms: number
    shape: string
    geometry: string
    color: string
    text?: string | null
    author?: string | null
    created_at?: Date | string
  }

  export type AnnotationUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    timecode_ms?: IntFieldUpdateOperationsInput | number
    shape?: StringFieldUpdateOperationsInput | string
    geometry?: StringFieldUpdateOperationsInput | string
    color?: StringFieldUpdateOperationsInput | string
    text?: NullableStringFieldUpdateOperationsInput | string | null
    author?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    Recording?: RecordingUpdateOneRequiredWithoutAnnotationsNestedInput
  }

  export type AnnotationUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    recording_id?: StringFieldUpdateOperationsInput | string
    timecode_ms?: IntFieldUpdateOperationsInput | number
    shape?: StringFieldUpdateOperationsInput | string
    geometry?: StringFieldUpdateOperationsInput | string
    color?: StringFieldUpdateOperationsInput | string
    text?: NullableStringFieldUpdateOperationsInput | string | null
    author?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type AnnotationCreateManyInput = {
    id?: string
    recording_id: string
    timecode_ms: number
    shape: string
    geometry: string
    color: string
    text?: string | null
    author?: string | null
    created_at?: Date | string
  }

  export type AnnotationUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    timecode_ms?: IntFieldUpdateOperationsInput | number
    shape?: StringFieldUpdateOperationsInput | string
    geometry?: StringFieldUpdateOperationsInput | string
    color?: StringFieldUpdateOperationsInput | string
    text?: NullableStringFieldUpdateOperationsInput | string | null
    author?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type AnnotationUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    recording_id?: StringFieldUpdateOperationsInput | string
    timecode_ms?: IntFieldUpdateOperationsInput | number
    shape?: StringFieldUpdateOperationsInput | string
    geometry?: StringFieldUpdateOperationsInput | string
    color?: StringFieldUpdateOperationsInput | string
    text?: NullableStringFieldUpdateOperationsInput | string | null
    author?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type UserCreateInput = {
    id?: string
    email: string
    name: string
    passwordHash: string
    accessKey: string
    role?: string
    status?: string
    createdAt?: Date | string
    updatedAt?: Date | string
    lastLoginAt?: Date | string | null
    passwordChangedAt?: Date | string | null
    apiKeys?: ApiKeyCreateNestedManyWithoutUserInput
    sessions?: UserSessionCreateNestedManyWithoutUserInput
    passwordResetTokens?: PasswordResetTokenCreateNestedManyWithoutUserInput
    teamMemberships?: TeamMemberCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateInput = {
    id?: string
    email: string
    name: string
    passwordHash: string
    accessKey: string
    role?: string
    status?: string
    createdAt?: Date | string
    updatedAt?: Date | string
    lastLoginAt?: Date | string | null
    passwordChangedAt?: Date | string | null
    apiKeys?: ApiKeyUncheckedCreateNestedManyWithoutUserInput
    sessions?: UserSessionUncheckedCreateNestedManyWithoutUserInput
    passwordResetTokens?: PasswordResetTokenUncheckedCreateNestedManyWithoutUserInput
    teamMemberships?: TeamMemberUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    passwordHash?: StringFieldUpdateOperationsInput | string
    accessKey?: StringFieldUpdateOperationsInput | string
    role?: StringFieldUpdateOperationsInput | string
    status?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    lastLoginAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    passwordChangedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    apiKeys?: ApiKeyUpdateManyWithoutUserNestedInput
    sessions?: UserSessionUpdateManyWithoutUserNestedInput
    passwordResetTokens?: PasswordResetTokenUpdateManyWithoutUserNestedInput
    teamMemberships?: TeamMemberUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    passwordHash?: StringFieldUpdateOperationsInput | string
    accessKey?: StringFieldUpdateOperationsInput | string
    role?: StringFieldUpdateOperationsInput | string
    status?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    lastLoginAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    passwordChangedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    apiKeys?: ApiKeyUncheckedUpdateManyWithoutUserNestedInput
    sessions?: UserSessionUncheckedUpdateManyWithoutUserNestedInput
    passwordResetTokens?: PasswordResetTokenUncheckedUpdateManyWithoutUserNestedInput
    teamMemberships?: TeamMemberUncheckedUpdateManyWithoutUserNestedInput
  }

  export type UserCreateManyInput = {
    id?: string
    email: string
    name: string
    passwordHash: string
    accessKey: string
    role?: string
    status?: string
    createdAt?: Date | string
    updatedAt?: Date | string
    lastLoginAt?: Date | string | null
    passwordChangedAt?: Date | string | null
  }

  export type UserUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    passwordHash?: StringFieldUpdateOperationsInput | string
    accessKey?: StringFieldUpdateOperationsInput | string
    role?: StringFieldUpdateOperationsInput | string
    status?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    lastLoginAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    passwordChangedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type UserUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    passwordHash?: StringFieldUpdateOperationsInput | string
    accessKey?: StringFieldUpdateOperationsInput | string
    role?: StringFieldUpdateOperationsInput | string
    status?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    lastLoginAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    passwordChangedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type UserSessionCreateInput = {
    id?: string
    createdAt?: Date | string
    expiresAt: Date | string
    lastSeenAt?: Date | string
    userAgent?: string | null
    ipHash?: string | null
    user: UserCreateNestedOneWithoutSessionsInput
  }

  export type UserSessionUncheckedCreateInput = {
    id?: string
    userId: string
    createdAt?: Date | string
    expiresAt: Date | string
    lastSeenAt?: Date | string
    userAgent?: string | null
    ipHash?: string | null
  }

  export type UserSessionUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    expiresAt?: DateTimeFieldUpdateOperationsInput | Date | string
    lastSeenAt?: DateTimeFieldUpdateOperationsInput | Date | string
    userAgent?: NullableStringFieldUpdateOperationsInput | string | null
    ipHash?: NullableStringFieldUpdateOperationsInput | string | null
    user?: UserUpdateOneRequiredWithoutSessionsNestedInput
  }

  export type UserSessionUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    expiresAt?: DateTimeFieldUpdateOperationsInput | Date | string
    lastSeenAt?: DateTimeFieldUpdateOperationsInput | Date | string
    userAgent?: NullableStringFieldUpdateOperationsInput | string | null
    ipHash?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type UserSessionCreateManyInput = {
    id?: string
    userId: string
    createdAt?: Date | string
    expiresAt: Date | string
    lastSeenAt?: Date | string
    userAgent?: string | null
    ipHash?: string | null
  }

  export type UserSessionUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    expiresAt?: DateTimeFieldUpdateOperationsInput | Date | string
    lastSeenAt?: DateTimeFieldUpdateOperationsInput | Date | string
    userAgent?: NullableStringFieldUpdateOperationsInput | string | null
    ipHash?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type UserSessionUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    expiresAt?: DateTimeFieldUpdateOperationsInput | Date | string
    lastSeenAt?: DateTimeFieldUpdateOperationsInput | Date | string
    userAgent?: NullableStringFieldUpdateOperationsInput | string | null
    ipHash?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type PasswordResetTokenCreateInput = {
    id?: string
    tokenHash: string
    createdAt?: Date | string
    expiresAt: Date | string
    usedAt?: Date | string | null
    user: UserCreateNestedOneWithoutPasswordResetTokensInput
  }

  export type PasswordResetTokenUncheckedCreateInput = {
    id?: string
    userId: string
    tokenHash: string
    createdAt?: Date | string
    expiresAt: Date | string
    usedAt?: Date | string | null
  }

  export type PasswordResetTokenUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    tokenHash?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    expiresAt?: DateTimeFieldUpdateOperationsInput | Date | string
    usedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    user?: UserUpdateOneRequiredWithoutPasswordResetTokensNestedInput
  }

  export type PasswordResetTokenUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    tokenHash?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    expiresAt?: DateTimeFieldUpdateOperationsInput | Date | string
    usedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type PasswordResetTokenCreateManyInput = {
    id?: string
    userId: string
    tokenHash: string
    createdAt?: Date | string
    expiresAt: Date | string
    usedAt?: Date | string | null
  }

  export type PasswordResetTokenUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    tokenHash?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    expiresAt?: DateTimeFieldUpdateOperationsInput | Date | string
    usedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type PasswordResetTokenUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    tokenHash?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    expiresAt?: DateTimeFieldUpdateOperationsInput | Date | string
    usedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type TeamMemberCreateInput = {
    createdAt?: Date | string
    team: TeamCreateNestedOneWithoutMembersInput
    user: UserCreateNestedOneWithoutTeamMembershipsInput
  }

  export type TeamMemberUncheckedCreateInput = {
    teamId: string
    userId: string
    createdAt?: Date | string
  }

  export type TeamMemberUpdateInput = {
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    team?: TeamUpdateOneRequiredWithoutMembersNestedInput
    user?: UserUpdateOneRequiredWithoutTeamMembershipsNestedInput
  }

  export type TeamMemberUncheckedUpdateInput = {
    teamId?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type TeamMemberCreateManyInput = {
    teamId: string
    userId: string
    createdAt?: Date | string
  }

  export type TeamMemberUpdateManyMutationInput = {
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type TeamMemberUncheckedUpdateManyInput = {
    teamId?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type EventLogCreateInput = {
    id?: string
    type: string
    payload: string
    correlationId?: string | null
    teamId?: string | null
    occurredAt?: Date | string
  }

  export type EventLogUncheckedCreateInput = {
    id?: string
    type: string
    payload: string
    correlationId?: string | null
    teamId?: string | null
    occurredAt?: Date | string
  }

  export type EventLogUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    type?: StringFieldUpdateOperationsInput | string
    payload?: StringFieldUpdateOperationsInput | string
    correlationId?: NullableStringFieldUpdateOperationsInput | string | null
    teamId?: NullableStringFieldUpdateOperationsInput | string | null
    occurredAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type EventLogUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    type?: StringFieldUpdateOperationsInput | string
    payload?: StringFieldUpdateOperationsInput | string
    correlationId?: NullableStringFieldUpdateOperationsInput | string | null
    teamId?: NullableStringFieldUpdateOperationsInput | string | null
    occurredAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type EventLogCreateManyInput = {
    id?: string
    type: string
    payload: string
    correlationId?: string | null
    teamId?: string | null
    occurredAt?: Date | string
  }

  export type EventLogUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    type?: StringFieldUpdateOperationsInput | string
    payload?: StringFieldUpdateOperationsInput | string
    correlationId?: NullableStringFieldUpdateOperationsInput | string | null
    teamId?: NullableStringFieldUpdateOperationsInput | string | null
    occurredAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type EventLogUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    type?: StringFieldUpdateOperationsInput | string
    payload?: StringFieldUpdateOperationsInput | string
    correlationId?: NullableStringFieldUpdateOperationsInput | string | null
    teamId?: NullableStringFieldUpdateOperationsInput | string | null
    occurredAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type ProjectCreateInput = {
    id?: string
    name: string
    teamId?: string | null
    createdAt?: Date | string
  }

  export type ProjectUncheckedCreateInput = {
    id?: string
    name: string
    teamId?: string | null
    createdAt?: Date | string
  }

  export type ProjectUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    teamId?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type ProjectUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    teamId?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type ProjectCreateManyInput = {
    id?: string
    name: string
    teamId?: string | null
    createdAt?: Date | string
  }

  export type ProjectUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    teamId?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type ProjectUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    teamId?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  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>
    not?: NestedStringFilter<$PrismaModel> | string
  }

  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>
    not?: NestedStringNullableFilter<$PrismaModel> | 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 SessionListRelationFilter = {
    every?: SessionWhereInput
    some?: SessionWhereInput
    none?: SessionWhereInput
  }

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

  export type SessionOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type BuildCountOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type BuildMaxOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type BuildMinOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    createdAt?: SortOrder
    updatedAt?: 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>
    not?: NestedStringWithAggregatesFilter<$PrismaModel> | string
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedStringFilter<$PrismaModel>
    _max?: NestedStringFilter<$PrismaModel>
  }

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

  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 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 LogListRelationFilter = {
    every?: LogWhereInput
    some?: LogWhereInput
    none?: LogWhereInput
  }

  export type ProfilingListRelationFilter = {
    every?: ProfilingWhereInput
    some?: ProfilingWhereInput
    none?: ProfilingWhereInput
  }

  export type BuildNullableRelationFilter = {
    is?: BuildWhereInput | null
    isNot?: BuildWhereInput | null
  }

  export type SessionLogListRelationFilter = {
    every?: SessionLogWhereInput
    some?: SessionLogWhereInput
    none?: SessionLogWhereInput
  }

  export type RecordingListRelationFilter = {
    every?: RecordingWhereInput
    some?: RecordingWhereInput
    none?: RecordingWhereInput
  }

  export type LogOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type ProfilingOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type SessionLogOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type RecordingOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type SessionCountOrderByAggregateInput = {
    id?: SortOrder
    build_id?: SortOrder
    name?: SortOrder
    status?: SortOrder
    desired_capabilities?: SortOrder
    session_capabilities?: SortOrder
    node_id?: SortOrder
    has_live_video?: SortOrder
    video_recording_enabled?: SortOrder
    video_recording?: SortOrder
    startTime?: SortOrder
    endTime?: SortOrder
    failure_reason?: SortOrder
    is_profiling_available?: SortOrder
    device_info?: SortOrder
    device_udid?: SortOrder
    device_platform?: SortOrder
    device_version?: SortOrder
    device_name?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    performance_trace?: SortOrder
    failure_category?: SortOrder
    ai_analysis?: SortOrder
    tags?: SortOrder
    trace_id?: SortOrder
    last_heartbeat_at?: SortOrder
    heartbeat_pid?: SortOrder
    heartbeat_host?: SortOrder
    api_key_id?: SortOrder
    user_id?: SortOrder
  }

  export type SessionAvgOrderByAggregateInput = {
    heartbeat_pid?: SortOrder
  }

  export type SessionMaxOrderByAggregateInput = {
    id?: SortOrder
    build_id?: SortOrder
    name?: SortOrder
    status?: SortOrder
    desired_capabilities?: SortOrder
    session_capabilities?: SortOrder
    node_id?: SortOrder
    has_live_video?: SortOrder
    video_recording_enabled?: SortOrder
    video_recording?: SortOrder
    startTime?: SortOrder
    endTime?: SortOrder
    failure_reason?: SortOrder
    is_profiling_available?: SortOrder
    device_info?: SortOrder
    device_udid?: SortOrder
    device_platform?: SortOrder
    device_version?: SortOrder
    device_name?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    performance_trace?: SortOrder
    failure_category?: SortOrder
    ai_analysis?: SortOrder
    tags?: SortOrder
    trace_id?: SortOrder
    last_heartbeat_at?: SortOrder
    heartbeat_pid?: SortOrder
    heartbeat_host?: SortOrder
    api_key_id?: SortOrder
    user_id?: SortOrder
  }

  export type SessionMinOrderByAggregateInput = {
    id?: SortOrder
    build_id?: SortOrder
    name?: SortOrder
    status?: SortOrder
    desired_capabilities?: SortOrder
    session_capabilities?: SortOrder
    node_id?: SortOrder
    has_live_video?: SortOrder
    video_recording_enabled?: SortOrder
    video_recording?: SortOrder
    startTime?: SortOrder
    endTime?: SortOrder
    failure_reason?: SortOrder
    is_profiling_available?: SortOrder
    device_info?: SortOrder
    device_udid?: SortOrder
    device_platform?: SortOrder
    device_version?: SortOrder
    device_name?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    performance_trace?: SortOrder
    failure_category?: SortOrder
    ai_analysis?: SortOrder
    tags?: SortOrder
    trace_id?: SortOrder
    last_heartbeat_at?: SortOrder
    heartbeat_pid?: SortOrder
    heartbeat_host?: SortOrder
    api_key_id?: SortOrder
    user_id?: SortOrder
  }

  export type SessionSumOrderByAggregateInput = {
    heartbeat_pid?: SortOrder
  }

  export type BoolWithAggregatesFilter<$PrismaModel = never> = {
    equals?: boolean | BooleanFieldRefInput<$PrismaModel>
    not?: NestedBoolWithAggregatesFilter<$PrismaModel> | boolean
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedBoolFilter<$PrismaModel>
    _max?: NestedBoolFilter<$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 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 BoolNullableFilter<$PrismaModel = never> = {
    equals?: boolean | BooleanFieldRefInput<$PrismaModel> | null
    not?: NestedBoolNullableFilter<$PrismaModel> | boolean | null
  }

  export type FloatNullableFilter<$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 SessionRelationFilter = {
    is?: SessionWhereInput
    isNot?: SessionWhereInput
  }

  export type SessionLogCountOrderByAggregateInput = {
    id?: SortOrder
    session_id?: SortOrder
    command_name?: SortOrder
    url?: SortOrder
    method?: SortOrder
    title?: SortOrder
    subtitle?: SortOrder
    body?: SortOrder
    response?: SortOrder
    screenshot?: SortOrder
    is_success?: SortOrder
    is_error?: SortOrder
    is_healed?: SortOrder
    original_selector?: SortOrder
    healed_selector?: SortOrder
    healing_confidence?: SortOrder
    healing_tier?: SortOrder
    original_strategy?: SortOrder
    healed_strategy?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    duration?: SortOrder
    span_id?: SortOrder
    trace_id?: SortOrder
  }

  export type SessionLogAvgOrderByAggregateInput = {
    healing_confidence?: SortOrder
    duration?: SortOrder
  }

  export type SessionLogMaxOrderByAggregateInput = {
    id?: SortOrder
    session_id?: SortOrder
    command_name?: SortOrder
    url?: SortOrder
    method?: SortOrder
    title?: SortOrder
    subtitle?: SortOrder
    body?: SortOrder
    response?: SortOrder
    screenshot?: SortOrder
    is_success?: SortOrder
    is_error?: SortOrder
    is_healed?: SortOrder
    original_selector?: SortOrder
    healed_selector?: SortOrder
    healing_confidence?: SortOrder
    healing_tier?: SortOrder
    original_strategy?: SortOrder
    healed_strategy?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    duration?: SortOrder
    span_id?: SortOrder
    trace_id?: SortOrder
  }

  export type SessionLogMinOrderByAggregateInput = {
    id?: SortOrder
    session_id?: SortOrder
    command_name?: SortOrder
    url?: SortOrder
    method?: SortOrder
    title?: SortOrder
    subtitle?: SortOrder
    body?: SortOrder
    response?: SortOrder
    screenshot?: SortOrder
    is_success?: SortOrder
    is_error?: SortOrder
    is_healed?: SortOrder
    original_selector?: SortOrder
    healed_selector?: SortOrder
    healing_confidence?: SortOrder
    healing_tier?: SortOrder
    original_strategy?: SortOrder
    healed_strategy?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    duration?: SortOrder
    span_id?: SortOrder
    trace_id?: SortOrder
  }

  export type SessionLogSumOrderByAggregateInput = {
    healing_confidence?: SortOrder
    duration?: SortOrder
  }

  export type BoolNullableWithAggregatesFilter<$PrismaModel = never> = {
    equals?: boolean | BooleanFieldRefInput<$PrismaModel> | null
    not?: NestedBoolNullableWithAggregatesFilter<$PrismaModel> | boolean | null
    _count?: NestedIntNullableFilter<$PrismaModel>
    _min?: NestedBoolNullableFilter<$PrismaModel>
    _max?: NestedBoolNullableFilter<$PrismaModel>
  }

  export type FloatNullableWithAggregatesFilter<$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?: NestedFloatNullableWithAggregatesFilter<$PrismaModel> | number | null
    _count?: NestedIntNullableFilter<$PrismaModel>
    _avg?: NestedFloatNullableFilter<$PrismaModel>
    _sum?: NestedFloatNullableFilter<$PrismaModel>
    _min?: NestedFloatNullableFilter<$PrismaModel>
    _max?: NestedFloatNullableFilter<$PrismaModel>
  }

  export type LogCountOrderByAggregateInput = {
    id?: SortOrder
    session_id?: SortOrder
    log_type?: SortOrder
    message?: SortOrder
    timestamp?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type LogMaxOrderByAggregateInput = {
    id?: SortOrder
    session_id?: SortOrder
    log_type?: SortOrder
    message?: SortOrder
    timestamp?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type LogMinOrderByAggregateInput = {
    id?: SortOrder
    session_id?: SortOrder
    log_type?: SortOrder
    message?: SortOrder
    timestamp?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  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 ProfilingCountOrderByAggregateInput = {
    id?: SortOrder
    session_id?: SortOrder
    cpu?: SortOrder
    memory?: SortOrder
    total_cpu_used?: SortOrder
    total_memory_used?: SortOrder
    raw_cpu_log?: SortOrder
    raw_memory_log?: SortOrder
    timestamp?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type ProfilingAvgOrderByAggregateInput = {
    id?: SortOrder
  }

  export type ProfilingMaxOrderByAggregateInput = {
    id?: SortOrder
    session_id?: SortOrder
    cpu?: SortOrder
    memory?: SortOrder
    total_cpu_used?: SortOrder
    total_memory_used?: SortOrder
    raw_cpu_log?: SortOrder
    raw_memory_log?: SortOrder
    timestamp?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type ProfilingMinOrderByAggregateInput = {
    id?: SortOrder
    session_id?: SortOrder
    cpu?: SortOrder
    memory?: SortOrder
    total_cpu_used?: SortOrder
    total_memory_used?: SortOrder
    raw_cpu_log?: SortOrder
    raw_memory_log?: SortOrder
    timestamp?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type ProfilingSumOrderByAggregateInput = {
    id?: 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 AppCountOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    filename?: SortOrder
    filepath?: SortOrder
    mimetype?: SortOrder
    size?: SortOrder
    packageName?: SortOrder
    version?: SortOrder
    platform?: SortOrder
    md5?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type AppAvgOrderByAggregateInput = {
    size?: SortOrder
  }

  export type AppMaxOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    filename?: SortOrder
    filepath?: SortOrder
    mimetype?: SortOrder
    size?: SortOrder
    packageName?: SortOrder
    version?: SortOrder
    platform?: SortOrder
    md5?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type AppMinOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    filename?: SortOrder
    filepath?: SortOrder
    mimetype?: SortOrder
    size?: SortOrder
    packageName?: SortOrder
    version?: SortOrder
    platform?: SortOrder
    md5?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type AppSumOrderByAggregateInput = {
    size?: SortOrder
  }

  export type FloatFilter<$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 TeamNullableRelationFilter = {
    is?: TeamWhereInput | null
    isNot?: TeamWhereInput | null
  }

  export type DeviceUdidHostCompoundUniqueInput = {
    udid: string
    host: string
  }

  export type DeviceCountOrderByAggregateInput = {
    udid?: SortOrder
    host?: SortOrder
    systemPort?: SortOrder
    proxyPort?: SortOrder
    proxyHost?: SortOrder
    wdaLocalPort?: SortOrder
    name?: SortOrder
    state?: SortOrder
    sdk?: SortOrder
    platform?: SortOrder
    deviceType?: SortOrder
    busy?: SortOrder
    userBlocked?: SortOrder
    realDevice?: SortOrder
    session_id?: SortOrder
    offline?: SortOrder
    mjpegServerPort?: SortOrder
    lastCmdExecutedAt?: SortOrder
    totalUtilizationTimeMilliSec?: SortOrder
    sessionStartTime?: SortOrder
    newCommandTimeout?: SortOrder
    cloud?: SortOrder
    derivedDataPath?: SortOrder
    chromeDriverPath?: SortOrder
    capability?: SortOrder
    adbRemoteHost?: SortOrder
    adbPort?: SortOrder
    nodeId?: SortOrder
    screenWidth?: SortOrder
    screenHeight?: SortOrder
    dashboard_link?: SortOrder
    total_session_count?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    healthCheckError?: SortOrder
    healthStatus?: SortOrder
    lastHealthCheckAt?: SortOrder
    batteryLevel?: SortOrder
    reservationReason?: SortOrder
    reservedBy?: SortOrder
    reservedUntil?: SortOrder
    storageFree?: SortOrder
    tags?: SortOrder
    thermalStatus?: SortOrder
    sessionProgress?: SortOrder
    totalHealedCount?: SortOrder
    ip?: SortOrder
    cpuArchitecture?: SortOrder
    owningSessionId?: SortOrder
    lockedAt?: SortOrder
    teamId?: SortOrder
  }

  export type DeviceAvgOrderByAggregateInput = {
    systemPort?: SortOrder
    proxyPort?: SortOrder
    wdaLocalPort?: SortOrder
    mjpegServerPort?: SortOrder
    lastCmdExecutedAt?: SortOrder
    totalUtilizationTimeMilliSec?: SortOrder
    sessionStartTime?: SortOrder
    newCommandTimeout?: SortOrder
    adbPort?: SortOrder
    total_session_count?: SortOrder
    lastHealthCheckAt?: SortOrder
    batteryLevel?: SortOrder
    reservedUntil?: SortOrder
    totalHealedCount?: SortOrder
    lockedAt?: SortOrder
  }

  export type DeviceMaxOrderByAggregateInput = {
    udid?: SortOrder
    host?: SortOrder
    systemPort?: SortOrder
    proxyPort?: SortOrder
    proxyHost?: SortOrder
    wdaLocalPort?: SortOrder
    name?: SortOrder
    state?: SortOrder
    sdk?: SortOrder
    platform?: SortOrder
    deviceType?: SortOrder
    busy?: SortOrder
    userBlocked?: SortOrder
    realDevice?: SortOrder
    session_id?: SortOrder
    offline?: SortOrder
    mjpegServerPort?: SortOrder
    lastCmdExecutedAt?: SortOrder
    totalUtilizationTimeMilliSec?: SortOrder
    sessionStartTime?: SortOrder
    newCommandTimeout?: SortOrder
    cloud?: SortOrder
    derivedDataPath?: SortOrder
    chromeDriverPath?: SortOrder
    capability?: SortOrder
    adbRemoteHost?: SortOrder
    adbPort?: SortOrder
    nodeId?: SortOrder
    screenWidth?: SortOrder
    screenHeight?: SortOrder
    dashboard_link?: SortOrder
    total_session_count?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    healthCheckError?: SortOrder
    healthStatus?: SortOrder
    lastHealthCheckAt?: SortOrder
    batteryLevel?: SortOrder
    reservationReason?: SortOrder
    reservedBy?: SortOrder
    reservedUntil?: SortOrder
    storageFree?: SortOrder
    tags?: SortOrder
    thermalStatus?: SortOrder
    sessionProgress?: SortOrder
    totalHealedCount?: SortOrder
    ip?: SortOrder
    cpuArchitecture?: SortOrder
    owningSessionId?: SortOrder
    lockedAt?: SortOrder
    teamId?: SortOrder
  }

  export type DeviceMinOrderByAggregateInput = {
    udid?: SortOrder
    host?: SortOrder
    systemPort?: SortOrder
    proxyPort?: SortOrder
    proxyHost?: SortOrder
    wdaLocalPort?: SortOrder
    name?: SortOrder
    state?: SortOrder
    sdk?: SortOrder
    platform?: SortOrder
    deviceType?: SortOrder
    busy?: SortOrder
    userBlocked?: SortOrder
    realDevice?: SortOrder
    session_id?: SortOrder
    offline?: SortOrder
    mjpegServerPort?: SortOrder
    lastCmdExecutedAt?: SortOrder
    totalUtilizationTimeMilliSec?: SortOrder
    sessionStartTime?: SortOrder
    newCommandTimeout?: SortOrder
    cloud?: SortOrder
    derivedDataPath?: SortOrder
    chromeDriverPath?: SortOrder
    capability?: SortOrder
    adbRemoteHost?: SortOrder
    adbPort?: SortOrder
    nodeId?: SortOrder
    screenWidth?: SortOrder
    screenHeight?: SortOrder
    dashboard_link?: SortOrder
    total_session_count?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    healthCheckError?: SortOrder
    healthStatus?: SortOrder
    lastHealthCheckAt?: SortOrder
    batteryLevel?: SortOrder
    reservationReason?: SortOrder
    reservedBy?: SortOrder
    reservedUntil?: SortOrder
    storageFree?: SortOrder
    tags?: SortOrder
    thermalStatus?: SortOrder
    sessionProgress?: SortOrder
    totalHealedCount?: SortOrder
    ip?: SortOrder
    cpuArchitecture?: SortOrder
    owningSessionId?: SortOrder
    lockedAt?: SortOrder
    teamId?: SortOrder
  }

  export type DeviceSumOrderByAggregateInput = {
    systemPort?: SortOrder
    proxyPort?: SortOrder
    wdaLocalPort?: SortOrder
    mjpegServerPort?: SortOrder
    lastCmdExecutedAt?: SortOrder
    totalUtilizationTimeMilliSec?: SortOrder
    sessionStartTime?: SortOrder
    newCommandTimeout?: SortOrder
    adbPort?: SortOrder
    total_session_count?: SortOrder
    lastHealthCheckAt?: SortOrder
    batteryLevel?: SortOrder
    reservedUntil?: SortOrder
    totalHealedCount?: SortOrder
    lockedAt?: SortOrder
  }

  export type FloatWithAggregatesFilter<$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?: NestedFloatWithAggregatesFilter<$PrismaModel> | number
    _count?: NestedIntFilter<$PrismaModel>
    _avg?: NestedFloatFilter<$PrismaModel>
    _sum?: NestedFloatFilter<$PrismaModel>
    _min?: NestedFloatFilter<$PrismaModel>
    _max?: NestedFloatFilter<$PrismaModel>
  }

  export type PendingSessionCountOrderByAggregateInput = {
    id?: SortOrder
    capability_id?: SortOrder
    capability?: SortOrder
    createdAt?: SortOrder
  }

  export type PendingSessionAvgOrderByAggregateInput = {
    id?: SortOrder
    createdAt?: SortOrder
  }

  export type PendingSessionMaxOrderByAggregateInput = {
    id?: SortOrder
    capability_id?: SortOrder
    capability?: SortOrder
    createdAt?: SortOrder
  }

  export type PendingSessionMinOrderByAggregateInput = {
    id?: SortOrder
    capability_id?: SortOrder
    capability?: SortOrder
    createdAt?: SortOrder
  }

  export type PendingSessionSumOrderByAggregateInput = {
    id?: SortOrder
    createdAt?: SortOrder
  }

  export type CLIArgsCountOrderByAggregateInput = {
    id?: SortOrder
    args?: SortOrder
    createdAt?: SortOrder
  }

  export type CLIArgsAvgOrderByAggregateInput = {
    id?: SortOrder
  }

  export type CLIArgsMaxOrderByAggregateInput = {
    id?: SortOrder
    args?: SortOrder
    createdAt?: SortOrder
  }

  export type CLIArgsMinOrderByAggregateInput = {
    id?: SortOrder
    args?: SortOrder
    createdAt?: SortOrder
  }

  export type CLIArgsSumOrderByAggregateInput = {
    id?: SortOrder
  }

  export type WebhookConfigCountOrderByAggregateInput = {
    id?: SortOrder
    url?: SortOrder
    type?: SortOrder
    events?: SortOrder
    active?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    payloadTemplate?: SortOrder
  }

  export type WebhookConfigMaxOrderByAggregateInput = {
    id?: SortOrder
    url?: SortOrder
    type?: SortOrder
    events?: SortOrder
    active?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    payloadTemplate?: SortOrder
  }

  export type WebhookConfigMinOrderByAggregateInput = {
    id?: SortOrder
    url?: SortOrder
    type?: SortOrder
    events?: SortOrder
    active?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    payloadTemplate?: SortOrder
  }

  export type WebConfigCountOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    value?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type WebConfigMaxOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    value?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type WebConfigMinOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    value?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type LocatorEtalonCountOrderByAggregateInput = {
    id?: SortOrder
    selector?: SortOrder
    strategy?: SortOrder
    attributes?: SortOrder
    nodeName?: SortOrder
    lastSeen?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type LocatorEtalonMaxOrderByAggregateInput = {
    id?: SortOrder
    selector?: SortOrder
    strategy?: SortOrder
    attributes?: SortOrder
    nodeName?: SortOrder
    lastSeen?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type LocatorEtalonMinOrderByAggregateInput = {
    id?: SortOrder
    selector?: SortOrder
    strategy?: SortOrder
    attributes?: SortOrder
    nodeName?: SortOrder
    lastSeen?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type PortLeaseCountOrderByAggregateInput = {
    port?: SortOrder
    purpose?: SortOrder
    leasedToUdid?: SortOrder
    leasedToHost?: SortOrder
    leaseId?: SortOrder
    leasedToPid?: SortOrder
    leasedAt?: SortOrder
    expiresAt?: SortOrder
  }

  export type PortLeaseAvgOrderByAggregateInput = {
    port?: SortOrder
    leasedToPid?: SortOrder
    leasedAt?: SortOrder
    expiresAt?: SortOrder
  }

  export type PortLeaseMaxOrderByAggregateInput = {
    port?: SortOrder
    purpose?: SortOrder
    leasedToUdid?: SortOrder
    leasedToHost?: SortOrder
    leaseId?: SortOrder
    leasedToPid?: SortOrder
    leasedAt?: SortOrder
    expiresAt?: SortOrder
  }

  export type PortLeaseMinOrderByAggregateInput = {
    port?: SortOrder
    purpose?: SortOrder
    leasedToUdid?: SortOrder
    leasedToHost?: SortOrder
    leaseId?: SortOrder
    leasedToPid?: SortOrder
    leasedAt?: SortOrder
    expiresAt?: SortOrder
  }

  export type PortLeaseSumOrderByAggregateInput = {
    port?: SortOrder
    leasedToPid?: SortOrder
    leasedAt?: SortOrder
    expiresAt?: SortOrder
  }

  export type LeaseCountOrderByAggregateInput = {
    id?: SortOrder
    tokenHash?: SortOrder
    deviceUdid?: SortOrder
    deviceHost?: SortOrder
    actorId?: SortOrder
    teamId?: SortOrder
    buildId?: SortOrder
    reason?: SortOrder
    status?: SortOrder
    createdAt?: SortOrder
    expiresAt?: SortOrder
    heartbeatSeconds?: SortOrder
    lastHeartbeatAt?: SortOrder
    allocatedPorts?: SortOrder
    capabilityBag?: SortOrder
  }

  export type LeaseAvgOrderByAggregateInput = {
    expiresAt?: SortOrder
    heartbeatSeconds?: SortOrder
    lastHeartbeatAt?: SortOrder
  }

  export type LeaseMaxOrderByAggregateInput = {
    id?: SortOrder
    tokenHash?: SortOrder
    deviceUdid?: SortOrder
    deviceHost?: SortOrder
    actorId?: SortOrder
    teamId?: SortOrder
    buildId?: SortOrder
    reason?: SortOrder
    status?: SortOrder
    createdAt?: SortOrder
    expiresAt?: SortOrder
    heartbeatSeconds?: SortOrder
    lastHeartbeatAt?: SortOrder
    allocatedPorts?: SortOrder
    capabilityBag?: SortOrder
  }

  export type LeaseMinOrderByAggregateInput = {
    id?: SortOrder
    tokenHash?: SortOrder
    deviceUdid?: SortOrder
    deviceHost?: SortOrder
    actorId?: SortOrder
    teamId?: SortOrder
    buildId?: SortOrder
    reason?: SortOrder
    status?: SortOrder
    createdAt?: SortOrder
    expiresAt?: SortOrder
    heartbeatSeconds?: SortOrder
    lastHeartbeatAt?: SortOrder
    allocatedPorts?: SortOrder
    capabilityBag?: SortOrder
  }

  export type LeaseSumOrderByAggregateInput = {
    expiresAt?: SortOrder
    heartbeatSeconds?: SortOrder
    lastHeartbeatAt?: SortOrder
  }

  export type UserRelationFilter = {
    is?: UserWhereInput
    isNot?: UserWhereInput
  }

  export type ApiKeyCountOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    keyHash?: SortOrder
    scopes?: SortOrder
    rateLimit?: SortOrder
    createdAt?: SortOrder
    revokedAt?: SortOrder
    lastUsedAt?: SortOrder
    expiresAt?: SortOrder
    teamId?: SortOrder
    role?: SortOrder
    userId?: SortOrder
  }

  export type ApiKeyAvgOrderByAggregateInput = {
    rateLimit?: SortOrder
  }

  export type ApiKeyMaxOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    keyHash?: SortOrder
    scopes?: SortOrder
    rateLimit?: SortOrder
    createdAt?: SortOrder
    revokedAt?: SortOrder
    lastUsedAt?: SortOrder
    expiresAt?: SortOrder
    teamId?: SortOrder
    role?: SortOrder
    userId?: SortOrder
  }

  export type ApiKeyMinOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    keyHash?: SortOrder
    scopes?: SortOrder
    rateLimit?: SortOrder
    createdAt?: SortOrder
    revokedAt?: SortOrder
    lastUsedAt?: SortOrder
    expiresAt?: SortOrder
    teamId?: SortOrder
    role?: SortOrder
    userId?: SortOrder
  }

  export type ApiKeySumOrderByAggregateInput = {
    rateLimit?: SortOrder
  }

  export type DeviceListRelationFilter = {
    every?: DeviceWhereInput
    some?: DeviceWhereInput
    none?: DeviceWhereInput
  }

  export type ApiKeyListRelationFilter = {
    every?: ApiKeyWhereInput
    some?: ApiKeyWhereInput
    none?: ApiKeyWhereInput
  }

  export type TeamMemberListRelationFilter = {
    every?: TeamMemberWhereInput
    some?: TeamMemberWhereInput
    none?: TeamMemberWhereInput
  }

  export type DeviceOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type ApiKeyOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type TeamMemberOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type TeamCountOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    createdAt?: SortOrder
  }

  export type TeamMaxOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    createdAt?: SortOrder
  }

  export type TeamMinOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    createdAt?: SortOrder
  }

  export type SelectorStateOriginal_strategyOriginal_selectorCompoundUniqueInput = {
    original_strategy: string
    original_selector: string
  }

  export type SelectorStateCountOrderByAggregateInput = {
    id?: SortOrder
    original_strategy?: SortOrder
    original_selector?: SortOrder
    status?: SortOrder
    fixed_at?: SortOrder
    fixed_by_api_key?: SortOrder
    resolved_at?: SortOrder
    muted_at?: SortOrder
    muted_by_api_key?: SortOrder
    regression_count?: SortOrder
    clean_builds_count?: SortOrder
    last_event_at?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type SelectorStateAvgOrderByAggregateInput = {
    regression_count?: SortOrder
    clean_builds_count?: SortOrder
  }

  export type SelectorStateMaxOrderByAggregateInput = {
    id?: SortOrder
    original_strategy?: SortOrder
    original_selector?: SortOrder
    status?: SortOrder
    fixed_at?: SortOrder
    fixed_by_api_key?: SortOrder
    resolved_at?: SortOrder
    muted_at?: SortOrder
    muted_by_api_key?: SortOrder
    regression_count?: SortOrder
    clean_builds_count?: SortOrder
    last_event_at?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type SelectorStateMinOrderByAggregateInput = {
    id?: SortOrder
    original_strategy?: SortOrder
    original_selector?: SortOrder
    status?: SortOrder
    fixed_at?: SortOrder
    fixed_by_api_key?: SortOrder
    resolved_at?: SortOrder
    muted_at?: SortOrder
    muted_by_api_key?: SortOrder
    regression_count?: SortOrder
    clean_builds_count?: SortOrder
    last_event_at?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type SelectorStateSumOrderByAggregateInput = {
    regression_count?: SortOrder
    clean_builds_count?: SortOrder
  }

  export type BookmarkListRelationFilter = {
    every?: BookmarkWhereInput
    some?: BookmarkWhereInput
    none?: BookmarkWhereInput
  }

  export type AnnotationListRelationFilter = {
    every?: AnnotationWhereInput
    some?: AnnotationWhereInput
    none?: AnnotationWhereInput
  }

  export type SessionNullableRelationFilter = {
    is?: SessionWhereInput | null
    isNot?: SessionWhereInput | null
  }

  export type BookmarkOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type AnnotationOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type RecordingCountOrderByAggregateInput = {
    id?: SortOrder
    group_id?: SortOrder
    device_udid?: SortOrder
    device_host?: SortOrder
    session_id?: SortOrder
    started_at?: SortOrder
    ended_at?: SortOrder
    status?: SortOrder
    file_path?: SortOrder
    duration_ms?: SortOrder
    size_bytes?: SortOrder
    device_snapshot?: SortOrder
    fail_reason?: SortOrder
  }

  export type RecordingAvgOrderByAggregateInput = {
    duration_ms?: SortOrder
    size_bytes?: SortOrder
  }

  export type RecordingMaxOrderByAggregateInput = {
    id?: SortOrder
    group_id?: SortOrder
    device_udid?: SortOrder
    device_host?: SortOrder
    session_id?: SortOrder
    started_at?: SortOrder
    ended_at?: SortOrder
    status?: SortOrder
    file_path?: SortOrder
    duration_ms?: SortOrder
    size_bytes?: SortOrder
    device_snapshot?: SortOrder
    fail_reason?: SortOrder
  }

  export type RecordingMinOrderByAggregateInput = {
    id?: SortOrder
    group_id?: SortOrder
    device_udid?: SortOrder
    device_host?: SortOrder
    session_id?: SortOrder
    started_at?: SortOrder
    ended_at?: SortOrder
    status?: SortOrder
    file_path?: SortOrder
    duration_ms?: SortOrder
    size_bytes?: SortOrder
    device_snapshot?: SortOrder
    fail_reason?: SortOrder
  }

  export type RecordingSumOrderByAggregateInput = {
    duration_ms?: SortOrder
    size_bytes?: SortOrder
  }

  export type RecordingRelationFilter = {
    is?: RecordingWhereInput
    isNot?: RecordingWhereInput
  }

  export type BookmarkCountOrderByAggregateInput = {
    id?: SortOrder
    recording_id?: SortOrder
    timecode_ms?: SortOrder
    label?: SortOrder
    note?: SortOrder
    created_at?: SortOrder
  }

  export type BookmarkAvgOrderByAggregateInput = {
    timecode_ms?: SortOrder
  }

  export type BookmarkMaxOrderByAggregateInput = {
    id?: SortOrder
    recording_id?: SortOrder
    timecode_ms?: SortOrder
    label?: SortOrder
    note?: SortOrder
    created_at?: SortOrder
  }

  export type BookmarkMinOrderByAggregateInput = {
    id?: SortOrder
    recording_id?: SortOrder
    timecode_ms?: SortOrder
    label?: SortOrder
    note?: SortOrder
    created_at?: SortOrder
  }

  export type BookmarkSumOrderByAggregateInput = {
    timecode_ms?: SortOrder
  }

  export type AnnotationCountOrderByAggregateInput = {
    id?: SortOrder
    recording_id?: SortOrder
    timecode_ms?: SortOrder
    shape?: SortOrder
    geometry?: SortOrder
    color?: SortOrder
    text?: SortOrder
    author?: SortOrder
    created_at?: SortOrder
  }

  export type AnnotationAvgOrderByAggregateInput = {
    timecode_ms?: SortOrder
  }

  export type AnnotationMaxOrderByAggregateInput = {
    id?: SortOrder
    recording_id?: SortOrder
    timecode_ms?: SortOrder
    shape?: SortOrder
    geometry?: SortOrder
    color?: SortOrder
    text?: SortOrder
    author?: SortOrder
    created_at?: SortOrder
  }

  export type AnnotationMinOrderByAggregateInput = {
    id?: SortOrder
    recording_id?: SortOrder
    timecode_ms?: SortOrder
    shape?: SortOrder
    geometry?: SortOrder
    color?: SortOrder
    text?: SortOrder
    author?: SortOrder
    created_at?: SortOrder
  }

  export type AnnotationSumOrderByAggregateInput = {
    timecode_ms?: SortOrder
  }

  export type UserSessionListRelationFilter = {
    every?: UserSessionWhereInput
    some?: UserSessionWhereInput
    none?: UserSessionWhereInput
  }

  export type PasswordResetTokenListRelationFilter = {
    every?: PasswordResetTokenWhereInput
    some?: PasswordResetTokenWhereInput
    none?: PasswordResetTokenWhereInput
  }

  export type UserSessionOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type PasswordResetTokenOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type UserCountOrderByAggregateInput = {
    id?: SortOrder
    email?: SortOrder
    name?: SortOrder
    passwordHash?: SortOrder
    accessKey?: SortOrder
    role?: SortOrder
    status?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    lastLoginAt?: SortOrder
    passwordChangedAt?: SortOrder
  }

  export type UserMaxOrderByAggregateInput = {
    id?: SortOrder
    email?: SortOrder
    name?: SortOrder
    passwordHash?: SortOrder
    accessKey?: SortOrder
    role?: SortOrder
    status?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    lastLoginAt?: SortOrder
    passwordChangedAt?: SortOrder
  }

  export type UserMinOrderByAggregateInput = {
    id?: SortOrder
    email?: SortOrder
    name?: SortOrder
    passwordHash?: SortOrder
    accessKey?: SortOrder
    role?: SortOrder
    status?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    lastLoginAt?: SortOrder
    passwordChangedAt?: SortOrder
  }

  export type UserSessionCountOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    createdAt?: SortOrder
    expiresAt?: SortOrder
    lastSeenAt?: SortOrder
    userAgent?: SortOrder
    ipHash?: SortOrder
  }

  export type UserSessionMaxOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    createdAt?: SortOrder
    expiresAt?: SortOrder
    lastSeenAt?: SortOrder
    userAgent?: SortOrder
    ipHash?: SortOrder
  }

  export type UserSessionMinOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    createdAt?: SortOrder
    expiresAt?: SortOrder
    lastSeenAt?: SortOrder
    userAgent?: SortOrder
    ipHash?: SortOrder
  }

  export type PasswordResetTokenCountOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    tokenHash?: SortOrder
    createdAt?: SortOrder
    expiresAt?: SortOrder
    usedAt?: SortOrder
  }

  export type PasswordResetTokenMaxOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    tokenHash?: SortOrder
    createdAt?: SortOrder
    expiresAt?: SortOrder
    usedAt?: SortOrder
  }

  export type PasswordResetTokenMinOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    tokenHash?: SortOrder
    createdAt?: SortOrder
    expiresAt?: SortOrder
    usedAt?: SortOrder
  }

  export type TeamRelationFilter = {
    is?: TeamWhereInput
    isNot?: TeamWhereInput
  }

  export type TeamMemberTeamIdUserIdCompoundUniqueInput = {
    teamId: string
    userId: string
  }

  export type TeamMemberCountOrderByAggregateInput = {
    teamId?: SortOrder
    userId?: SortOrder
    createdAt?: SortOrder
  }

  export type TeamMemberMaxOrderByAggregateInput = {
    teamId?: SortOrder
    userId?: SortOrder
    createdAt?: SortOrder
  }

  export type TeamMemberMinOrderByAggregateInput = {
    teamId?: SortOrder
    userId?: SortOrder
    createdAt?: SortOrder
  }

  export type EventLogCountOrderByAggregateInput = {
    id?: SortOrder
    type?: SortOrder
    payload?: SortOrder
    correlationId?: SortOrder
    teamId?: SortOrder
    occurredAt?: SortOrder
  }

  export type EventLogMaxOrderByAggregateInput = {
    id?: SortOrder
    type?: SortOrder
    payload?: SortOrder
    correlationId?: SortOrder
    teamId?: SortOrder
    occurredAt?: SortOrder
  }

  export type EventLogMinOrderByAggregateInput = {
    id?: SortOrder
    type?: SortOrder
    payload?: SortOrder
    correlationId?: SortOrder
    teamId?: SortOrder
    occurredAt?: SortOrder
  }

  export type ProjectCountOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    teamId?: SortOrder
    createdAt?: SortOrder
  }

  export type ProjectMaxOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    teamId?: SortOrder
    createdAt?: SortOrder
  }

  export type ProjectMinOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    teamId?: SortOrder
    createdAt?: SortOrder
  }

  export type SessionCreateNestedManyWithoutBuildInput = {
    create?: XOR<SessionCreateWithoutBuildInput, SessionUncheckedCreateWithoutBuildInput> | SessionCreateWithoutBuildInput[] | SessionUncheckedCreateWithoutBuildInput[]
    connectOrCreate?: SessionCreateOrConnectWithoutBuildInput | SessionCreateOrConnectWithoutBuildInput[]
    createMany?: SessionCreateManyBuildInputEnvelope
    connect?: SessionWhereUniqueInput | SessionWhereUniqueInput[]
  }

  export type SessionUncheckedCreateNestedManyWithoutBuildInput = {
    create?: XOR<SessionCreateWithoutBuildInput, SessionUncheckedCreateWithoutBuildInput> | SessionCreateWithoutBuildInput[] | SessionUncheckedCreateWithoutBuildInput[]
    connectOrCreate?: SessionCreateOrConnectWithoutBuildInput | SessionCreateOrConnectWithoutBuildInput[]
    createMany?: SessionCreateManyBuildInputEnvelope
    connect?: SessionWhereUniqueInput | SessionWhereUniqueInput[]
  }

  export type StringFieldUpdateOperationsInput = {
    set?: string
  }

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

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

  export type SessionUpdateManyWithoutBuildNestedInput = {
    create?: XOR<SessionCreateWithoutBuildInput, SessionUncheckedCreateWithoutBuildInput> | SessionCreateWithoutBuildInput[] | SessionUncheckedCreateWithoutBuildInput[]
    connectOrCreate?: SessionCreateOrConnectWithoutBuildInput | SessionCreateOrConnectWithoutBuildInput[]
    upsert?: SessionUpsertWithWhereUniqueWithoutBuildInput | SessionUpsertWithWhereUniqueWithoutBuildInput[]
    createMany?: SessionCreateManyBuildInputEnvelope
    set?: SessionWhereUniqueInput | SessionWhereUniqueInput[]
    disconnect?: SessionWhereUniqueInput | SessionWhereUniqueInput[]
    delete?: SessionWhereUniqueInput | SessionWhereUniqueInput[]
    connect?: SessionWhereUniqueInput | SessionWhereUniqueInput[]
    update?: SessionUpdateWithWhereUniqueWithoutBuildInput | SessionUpdateWithWhereUniqueWithoutBuildInput[]
    updateMany?: SessionUpdateManyWithWhereWithoutBuildInput | SessionUpdateManyWithWhereWithoutBuildInput[]
    deleteMany?: SessionScalarWhereInput | SessionScalarWhereInput[]
  }

  export type SessionUncheckedUpdateManyWithoutBuildNestedInput = {
    create?: XOR<SessionCreateWithoutBuildInput, SessionUncheckedCreateWithoutBuildInput> | SessionCreateWithoutBuildInput[] | SessionUncheckedCreateWithoutBuildInput[]
    connectOrCreate?: SessionCreateOrConnectWithoutBuildInput | SessionCreateOrConnectWithoutBuildInput[]
    upsert?: SessionUpsertWithWhereUniqueWithoutBuildInput | SessionUpsertWithWhereUniqueWithoutBuildInput[]
    createMany?: SessionCreateManyBuildInputEnvelope
    set?: SessionWhereUniqueInput | SessionWhereUniqueInput[]
    disconnect?: SessionWhereUniqueInput | SessionWhereUniqueInput[]
    delete?: SessionWhereUniqueInput | SessionWhereUniqueInput[]
    connect?: SessionWhereUniqueInput | SessionWhereUniqueInput[]
    update?: SessionUpdateWithWhereUniqueWithoutBuildInput | SessionUpdateWithWhereUniqueWithoutBuildInput[]
    updateMany?: SessionUpdateManyWithWhereWithoutBuildInput | SessionUpdateManyWithWhereWithoutBuildInput[]
    deleteMany?: SessionScalarWhereInput | SessionScalarWhereInput[]
  }

  export type LogCreateNestedManyWithoutSessionInput = {
    create?: XOR<LogCreateWithoutSessionInput, LogUncheckedCreateWithoutSessionInput> | LogCreateWithoutSessionInput[] | LogUncheckedCreateWithoutSessionInput[]
    connectOrCreate?: LogCreateOrConnectWithoutSessionInput | LogCreateOrConnectWithoutSessionInput[]
    createMany?: LogCreateManySessionInputEnvelope
    connect?: LogWhereUniqueInput | LogWhereUniqueInput[]
  }

  export type ProfilingCreateNestedManyWithoutSessionInput = {
    create?: XOR<ProfilingCreateWithoutSessionInput, ProfilingUncheckedCreateWithoutSessionInput> | ProfilingCreateWithoutSessionInput[] | ProfilingUncheckedCreateWithoutSessionInput[]
    connectOrCreate?: ProfilingCreateOrConnectWithoutSessionInput | ProfilingCreateOrConnectWithoutSessionInput[]
    createMany?: ProfilingCreateManySessionInputEnvelope
    connect?: ProfilingWhereUniqueInput | ProfilingWhereUniqueInput[]
  }

  export type BuildCreateNestedOneWithoutSessionsInput = {
    create?: XOR<BuildCreateWithoutSessionsInput, BuildUncheckedCreateWithoutSessionsInput>
    connectOrCreate?: BuildCreateOrConnectWithoutSessionsInput
    connect?: BuildWhereUniqueInput
  }

  export type SessionLogCreateNestedManyWithoutSessionInput = {
    create?: XOR<SessionLogCreateWithoutSessionInput, SessionLogUncheckedCreateWithoutSessionInput> | SessionLogCreateWithoutSessionInput[] | SessionLogUncheckedCreateWithoutSessionInput[]
    connectOrCreate?: SessionLogCreateOrConnectWithoutSessionInput | SessionLogCreateOrConnectWithoutSessionInput[]
    createMany?: SessionLogCreateManySessionInputEnvelope
    connect?: SessionLogWhereUniqueInput | SessionLogWhereUniqueInput[]
  }

  export type RecordingCreateNestedManyWithoutSessionInput = {
    create?: XOR<RecordingCreateWithoutSessionInput, RecordingUncheckedCreateWithoutSessionInput> | RecordingCreateWithoutSessionInput[] | RecordingUncheckedCreateWithoutSessionInput[]
    connectOrCreate?: RecordingCreateOrConnectWithoutSessionInput | RecordingCreateOrConnectWithoutSessionInput[]
    createMany?: RecordingCreateManySessionInputEnvelope
    connect?: RecordingWhereUniqueInput | RecordingWhereUniqueInput[]
  }

  export type LogUncheckedCreateNestedManyWithoutSessionInput = {
    create?: XOR<LogCreateWithoutSessionInput, LogUncheckedCreateWithoutSessionInput> | LogCreateWithoutSessionInput[] | LogUncheckedCreateWithoutSessionInput[]
    connectOrCreate?: LogCreateOrConnectWithoutSessionInput | LogCreateOrConnectWithoutSessionInput[]
    createMany?: LogCreateManySessionInputEnvelope
    connect?: LogWhereUniqueInput | LogWhereUniqueInput[]
  }

  export type ProfilingUncheckedCreateNestedManyWithoutSessionInput = {
    create?: XOR<ProfilingCreateWithoutSessionInput, ProfilingUncheckedCreateWithoutSessionInput> | ProfilingCreateWithoutSessionInput[] | ProfilingUncheckedCreateWithoutSessionInput[]
    connectOrCreate?: ProfilingCreateOrConnectWithoutSessionInput | ProfilingCreateOrConnectWithoutSessionInput[]
    createMany?: ProfilingCreateManySessionInputEnvelope
    connect?: ProfilingWhereUniqueInput | ProfilingWhereUniqueInput[]
  }

  export type SessionLogUncheckedCreateNestedManyWithoutSessionInput = {
    create?: XOR<SessionLogCreateWithoutSessionInput, SessionLogUncheckedCreateWithoutSessionInput> | SessionLogCreateWithoutSessionInput[] | SessionLogUncheckedCreateWithoutSessionInput[]
    connectOrCreate?: SessionLogCreateOrConnectWithoutSessionInput | SessionLogCreateOrConnectWithoutSessionInput[]
    createMany?: SessionLogCreateManySessionInputEnvelope
    connect?: SessionLogWhereUniqueInput | SessionLogWhereUniqueInput[]
  }

  export type RecordingUncheckedCreateNestedManyWithoutSessionInput = {
    create?: XOR<RecordingCreateWithoutSessionInput, RecordingUncheckedCreateWithoutSessionInput> | RecordingCreateWithoutSessionInput[] | RecordingUncheckedCreateWithoutSessionInput[]
    connectOrCreate?: RecordingCreateOrConnectWithoutSessionInput | RecordingCreateOrConnectWithoutSessionInput[]
    createMany?: RecordingCreateManySessionInputEnvelope
    connect?: RecordingWhereUniqueInput | RecordingWhereUniqueInput[]
  }

  export type BoolFieldUpdateOperationsInput = {
    set?: boolean
  }

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

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

  export type LogUpdateManyWithoutSessionNestedInput = {
    create?: XOR<LogCreateWithoutSessionInput, LogUncheckedCreateWithoutSessionInput> | LogCreateWithoutSessionInput[] | LogUncheckedCreateWithoutSessionInput[]
    connectOrCreate?: LogCreateOrConnectWithoutSessionInput | LogCreateOrConnectWithoutSessionInput[]
    upsert?: LogUpsertWithWhereUniqueWithoutSessionInput | LogUpsertWithWhereUniqueWithoutSessionInput[]
    createMany?: LogCreateManySessionInputEnvelope
    set?: LogWhereUniqueInput | LogWhereUniqueInput[]
    disconnect?: LogWhereUniqueInput | LogWhereUniqueInput[]
    delete?: LogWhereUniqueInput | LogWhereUniqueInput[]
    connect?: LogWhereUniqueInput | LogWhereUniqueInput[]
    update?: LogUpdateWithWhereUniqueWithoutSessionInput | LogUpdateWithWhereUniqueWithoutSessionInput[]
    updateMany?: LogUpdateManyWithWhereWithoutSessionInput | LogUpdateManyWithWhereWithoutSessionInput[]
    deleteMany?: LogScalarWhereInput | LogScalarWhereInput[]
  }

  export type ProfilingUpdateManyWithoutSessionNestedInput = {
    create?: XOR<ProfilingCreateWithoutSessionInput, ProfilingUncheckedCreateWithoutSessionInput> | ProfilingCreateWithoutSessionInput[] | ProfilingUncheckedCreateWithoutSessionInput[]
    connectOrCreate?: ProfilingCreateOrConnectWithoutSessionInput | ProfilingCreateOrConnectWithoutSessionInput[]
    upsert?: ProfilingUpsertWithWhereUniqueWithoutSessionInput | ProfilingUpsertWithWhereUniqueWithoutSessionInput[]
    createMany?: ProfilingCreateManySessionInputEnvelope
    set?: ProfilingWhereUniqueInput | ProfilingWhereUniqueInput[]
    disconnect?: ProfilingWhereUniqueInput | ProfilingWhereUniqueInput[]
    delete?: ProfilingWhereUniqueInput | ProfilingWhereUniqueInput[]
    connect?: ProfilingWhereUniqueInput | ProfilingWhereUniqueInput[]
    update?: ProfilingUpdateWithWhereUniqueWithoutSessionInput | ProfilingUpdateWithWhereUniqueWithoutSessionInput[]
    updateMany?: ProfilingUpdateManyWithWhereWithoutSessionInput | ProfilingUpdateManyWithWhereWithoutSessionInput[]
    deleteMany?: ProfilingScalarWhereInput | ProfilingScalarWhereInput[]
  }

  export type BuildUpdateOneWithoutSessionsNestedInput = {
    create?: XOR<BuildCreateWithoutSessionsInput, BuildUncheckedCreateWithoutSessionsInput>
    connectOrCreate?: BuildCreateOrConnectWithoutSessionsInput
    upsert?: BuildUpsertWithoutSessionsInput
    disconnect?: BuildWhereInput | boolean
    delete?: BuildWhereInput | boolean
    connect?: BuildWhereUniqueInput
    update?: XOR<XOR<BuildUpdateToOneWithWhereWithoutSessionsInput, BuildUpdateWithoutSessionsInput>, BuildUncheckedUpdateWithoutSessionsInput>
  }

  export type SessionLogUpdateManyWithoutSessionNestedInput = {
    create?: XOR<SessionLogCreateWithoutSessionInput, SessionLogUncheckedCreateWithoutSessionInput> | SessionLogCreateWithoutSessionInput[] | SessionLogUncheckedCreateWithoutSessionInput[]
    connectOrCreate?: SessionLogCreateOrConnectWithoutSessionInput | SessionLogCreateOrConnectWithoutSessionInput[]
    upsert?: SessionLogUpsertWithWhereUniqueWithoutSessionInput | SessionLogUpsertWithWhereUniqueWithoutSessionInput[]
    createMany?: SessionLogCreateManySessionInputEnvelope
    set?: SessionLogWhereUniqueInput | SessionLogWhereUniqueInput[]
    disconnect?: SessionLogWhereUniqueInput | SessionLogWhereUniqueInput[]
    delete?: SessionLogWhereUniqueInput | SessionLogWhereUniqueInput[]
    connect?: SessionLogWhereUniqueInput | SessionLogWhereUniqueInput[]
    update?: SessionLogUpdateWithWhereUniqueWithoutSessionInput | SessionLogUpdateWithWhereUniqueWithoutSessionInput[]
    updateMany?: SessionLogUpdateManyWithWhereWithoutSessionInput | SessionLogUpdateManyWithWhereWithoutSessionInput[]
    deleteMany?: SessionLogScalarWhereInput | SessionLogScalarWhereInput[]
  }

  export type RecordingUpdateManyWithoutSessionNestedInput = {
    create?: XOR<RecordingCreateWithoutSessionInput, RecordingUncheckedCreateWithoutSessionInput> | RecordingCreateWithoutSessionInput[] | RecordingUncheckedCreateWithoutSessionInput[]
    connectOrCreate?: RecordingCreateOrConnectWithoutSessionInput | RecordingCreateOrConnectWithoutSessionInput[]
    upsert?: RecordingUpsertWithWhereUniqueWithoutSessionInput | RecordingUpsertWithWhereUniqueWithoutSessionInput[]
    createMany?: RecordingCreateManySessionInputEnvelope
    set?: RecordingWhereUniqueInput | RecordingWhereUniqueInput[]
    disconnect?: RecordingWhereUniqueInput | RecordingWhereUniqueInput[]
    delete?: RecordingWhereUniqueInput | RecordingWhereUniqueInput[]
    connect?: RecordingWhereUniqueInput | RecordingWhereUniqueInput[]
    update?: RecordingUpdateWithWhereUniqueWithoutSessionInput | RecordingUpdateWithWhereUniqueWithoutSessionInput[]
    updateMany?: RecordingUpdateManyWithWhereWithoutSessionInput | RecordingUpdateManyWithWhereWithoutSessionInput[]
    deleteMany?: RecordingScalarWhereInput | RecordingScalarWhereInput[]
  }

  export type LogUncheckedUpdateManyWithoutSessionNestedInput = {
    create?: XOR<LogCreateWithoutSessionInput, LogUncheckedCreateWithoutSessionInput> | LogCreateWithoutSessionInput[] | LogUncheckedCreateWithoutSessionInput[]
    connectOrCreate?: LogCreateOrConnectWithoutSessionInput | LogCreateOrConnectWithoutSessionInput[]
    upsert?: LogUpsertWithWhereUniqueWithoutSessionInput | LogUpsertWithWhereUniqueWithoutSessionInput[]
    createMany?: LogCreateManySessionInputEnvelope
    set?: LogWhereUniqueInput | LogWhereUniqueInput[]
    disconnect?: LogWhereUniqueInput | LogWhereUniqueInput[]
    delete?: LogWhereUniqueInput | LogWhereUniqueInput[]
    connect?: LogWhereUniqueInput | LogWhereUniqueInput[]
    update?: LogUpdateWithWhereUniqueWithoutSessionInput | LogUpdateWithWhereUniqueWithoutSessionInput[]
    updateMany?: LogUpdateManyWithWhereWithoutSessionInput | LogUpdateManyWithWhereWithoutSessionInput[]
    deleteMany?: LogScalarWhereInput | LogScalarWhereInput[]
  }

  export type ProfilingUncheckedUpdateManyWithoutSessionNestedInput = {
    create?: XOR<ProfilingCreateWithoutSessionInput, ProfilingUncheckedCreateWithoutSessionInput> | ProfilingCreateWithoutSessionInput[] | ProfilingUncheckedCreateWithoutSessionInput[]
    connectOrCreate?: ProfilingCreateOrConnectWithoutSessionInput | ProfilingCreateOrConnectWithoutSessionInput[]
    upsert?: ProfilingUpsertWithWhereUniqueWithoutSessionInput | ProfilingUpsertWithWhereUniqueWithoutSessionInput[]
    createMany?: ProfilingCreateManySessionInputEnvelope
    set?: ProfilingWhereUniqueInput | ProfilingWhereUniqueInput[]
    disconnect?: ProfilingWhereUniqueInput | ProfilingWhereUniqueInput[]
    delete?: ProfilingWhereUniqueInput | ProfilingWhereUniqueInput[]
    connect?: ProfilingWhereUniqueInput | ProfilingWhereUniqueInput[]
    update?: ProfilingUpdateWithWhereUniqueWithoutSessionInput | ProfilingUpdateWithWhereUniqueWithoutSessionInput[]
    updateMany?: ProfilingUpdateManyWithWhereWithoutSessionInput | ProfilingUpdateManyWithWhereWithoutSessionInput[]
    deleteMany?: ProfilingScalarWhereInput | ProfilingScalarWhereInput[]
  }

  export type SessionLogUncheckedUpdateManyWithoutSessionNestedInput = {
    create?: XOR<SessionLogCreateWithoutSessionInput, SessionLogUncheckedCreateWithoutSessionInput> | SessionLogCreateWithoutSessionInput[] | SessionLogUncheckedCreateWithoutSessionInput[]
    connectOrCreate?: SessionLogCreateOrConnectWithoutSessionInput | SessionLogCreateOrConnectWithoutSessionInput[]
    upsert?: SessionLogUpsertWithWhereUniqueWithoutSessionInput | SessionLogUpsertWithWhereUniqueWithoutSessionInput[]
    createMany?: SessionLogCreateManySessionInputEnvelope
    set?: SessionLogWhereUniqueInput | SessionLogWhereUniqueInput[]
    disconnect?: SessionLogWhereUniqueInput | SessionLogWhereUniqueInput[]
    delete?: SessionLogWhereUniqueInput | SessionLogWhereUniqueInput[]
    connect?: SessionLogWhereUniqueInput | SessionLogWhereUniqueInput[]
    update?: SessionLogUpdateWithWhereUniqueWithoutSessionInput | SessionLogUpdateWithWhereUniqueWithoutSessionInput[]
    updateMany?: SessionLogUpdateManyWithWhereWithoutSessionInput | SessionLogUpdateManyWithWhereWithoutSessionInput[]
    deleteMany?: SessionLogScalarWhereInput | SessionLogScalarWhereInput[]
  }

  export type RecordingUncheckedUpdateManyWithoutSessionNestedInput = {
    create?: XOR<RecordingCreateWithoutSessionInput, RecordingUncheckedCreateWithoutSessionInput> | RecordingCreateWithoutSessionInput[] | RecordingUncheckedCreateWithoutSessionInput[]
    connectOrCreate?: RecordingCreateOrConnectWithoutSessionInput | RecordingCreateOrConnectWithoutSessionInput[]
    upsert?: RecordingUpsertWithWhereUniqueWithoutSessionInput | RecordingUpsertWithWhereUniqueWithoutSessionInput[]
    createMany?: RecordingCreateManySessionInputEnvelope
    set?: RecordingWhereUniqueInput | RecordingWhereUniqueInput[]
    disconnect?: RecordingWhereUniqueInput | RecordingWhereUniqueInput[]
    delete?: RecordingWhereUniqueInput | RecordingWhereUniqueInput[]
    connect?: RecordingWhereUniqueInput | RecordingWhereUniqueInput[]
    update?: RecordingUpdateWithWhereUniqueWithoutSessionInput | RecordingUpdateWithWhereUniqueWithoutSessionInput[]
    updateMany?: RecordingUpdateManyWithWhereWithoutSessionInput | RecordingUpdateManyWithWhereWithoutSessionInput[]
    deleteMany?: RecordingScalarWhereInput | RecordingScalarWhereInput[]
  }

  export type SessionCreateNestedOneWithoutSessionLogInput = {
    create?: XOR<SessionCreateWithoutSessionLogInput, SessionUncheckedCreateWithoutSessionLogInput>
    connectOrCreate?: SessionCreateOrConnectWithoutSessionLogInput
    connect?: SessionWhereUniqueInput
  }

  export type NullableBoolFieldUpdateOperationsInput = {
    set?: boolean | null
  }

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

  export type SessionUpdateOneRequiredWithoutSessionLogNestedInput = {
    create?: XOR<SessionCreateWithoutSessionLogInput, SessionUncheckedCreateWithoutSessionLogInput>
    connectOrCreate?: SessionCreateOrConnectWithoutSessionLogInput
    upsert?: SessionUpsertWithoutSessionLogInput
    connect?: SessionWhereUniqueInput
    update?: XOR<XOR<SessionUpdateToOneWithWhereWithoutSessionLogInput, SessionUpdateWithoutSessionLogInput>, SessionUncheckedUpdateWithoutSessionLogInput>
  }

  export type SessionCreateNestedOneWithoutLogInput = {
    create?: XOR<SessionCreateWithoutLogInput, SessionUncheckedCreateWithoutLogInput>
    connectOrCreate?: SessionCreateOrConnectWithoutLogInput
    connect?: SessionWhereUniqueInput
  }

  export type SessionUpdateOneRequiredWithoutLogNestedInput = {
    create?: XOR<SessionCreateWithoutLogInput, SessionUncheckedCreateWithoutLogInput>
    connectOrCreate?: SessionCreateOrConnectWithoutLogInput
    upsert?: SessionUpsertWithoutLogInput
    connect?: SessionWhereUniqueInput
    update?: XOR<XOR<SessionUpdateToOneWithWhereWithoutLogInput, SessionUpdateWithoutLogInput>, SessionUncheckedUpdateWithoutLogInput>
  }

  export type SessionCreateNestedOneWithoutProfilingInput = {
    create?: XOR<SessionCreateWithoutProfilingInput, SessionUncheckedCreateWithoutProfilingInput>
    connectOrCreate?: SessionCreateOrConnectWithoutProfilingInput
    connect?: SessionWhereUniqueInput
  }

  export type SessionUpdateOneRequiredWithoutProfilingNestedInput = {
    create?: XOR<SessionCreateWithoutProfilingInput, SessionUncheckedCreateWithoutProfilingInput>
    connectOrCreate?: SessionCreateOrConnectWithoutProfilingInput
    upsert?: SessionUpsertWithoutProfilingInput
    connect?: SessionWhereUniqueInput
    update?: XOR<XOR<SessionUpdateToOneWithWhereWithoutProfilingInput, SessionUpdateWithoutProfilingInput>, SessionUncheckedUpdateWithoutProfilingInput>
  }

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

  export type TeamCreateNestedOneWithoutDevicesInput = {
    create?: XOR<TeamCreateWithoutDevicesInput, TeamUncheckedCreateWithoutDevicesInput>
    connectOrCreate?: TeamCreateOrConnectWithoutDevicesInput
    connect?: TeamWhereUniqueInput
  }

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

  export type TeamUpdateOneWithoutDevicesNestedInput = {
    create?: XOR<TeamCreateWithoutDevicesInput, TeamUncheckedCreateWithoutDevicesInput>
    connectOrCreate?: TeamCreateOrConnectWithoutDevicesInput
    upsert?: TeamUpsertWithoutDevicesInput
    disconnect?: TeamWhereInput | boolean
    delete?: TeamWhereInput | boolean
    connect?: TeamWhereUniqueInput
    update?: XOR<XOR<TeamUpdateToOneWithWhereWithoutDevicesInput, TeamUpdateWithoutDevicesInput>, TeamUncheckedUpdateWithoutDevicesInput>
  }

  export type TeamCreateNestedOneWithoutApiKeysInput = {
    create?: XOR<TeamCreateWithoutApiKeysInput, TeamUncheckedCreateWithoutApiKeysInput>
    connectOrCreate?: TeamCreateOrConnectWithoutApiKeysInput
    connect?: TeamWhereUniqueInput
  }

  export type UserCreateNestedOneWithoutApiKeysInput = {
    create?: XOR<UserCreateWithoutApiKeysInput, UserUncheckedCreateWithoutApiKeysInput>
    connectOrCreate?: UserCreateOrConnectWithoutApiKeysInput
    connect?: UserWhereUniqueInput
  }

  export type TeamUpdateOneWithoutApiKeysNestedInput = {
    create?: XOR<TeamCreateWithoutApiKeysInput, TeamUncheckedCreateWithoutApiKeysInput>
    connectOrCreate?: TeamCreateOrConnectWithoutApiKeysInput
    upsert?: TeamUpsertWithoutApiKeysInput
    disconnect?: TeamWhereInput | boolean
    delete?: TeamWhereInput | boolean
    connect?: TeamWhereUniqueInput
    update?: XOR<XOR<TeamUpdateToOneWithWhereWithoutApiKeysInput, TeamUpdateWithoutApiKeysInput>, TeamUncheckedUpdateWithoutApiKeysInput>
  }

  export type UserUpdateOneRequiredWithoutApiKeysNestedInput = {
    create?: XOR<UserCreateWithoutApiKeysInput, UserUncheckedCreateWithoutApiKeysInput>
    connectOrCreate?: UserCreateOrConnectWithoutApiKeysInput
    upsert?: UserUpsertWithoutApiKeysInput
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutApiKeysInput, UserUpdateWithoutApiKeysInput>, UserUncheckedUpdateWithoutApiKeysInput>
  }

  export type DeviceCreateNestedManyWithoutTeamInput = {
    create?: XOR<DeviceCreateWithoutTeamInput, DeviceUncheckedCreateWithoutTeamInput> | DeviceCreateWithoutTeamInput[] | DeviceUncheckedCreateWithoutTeamInput[]
    connectOrCreate?: DeviceCreateOrConnectWithoutTeamInput | DeviceCreateOrConnectWithoutTeamInput[]
    createMany?: DeviceCreateManyTeamInputEnvelope
    connect?: DeviceWhereUniqueInput | DeviceWhereUniqueInput[]
  }

  export type ApiKeyCreateNestedManyWithoutTeamInput = {
    create?: XOR<ApiKeyCreateWithoutTeamInput, ApiKeyUncheckedCreateWithoutTeamInput> | ApiKeyCreateWithoutTeamInput[] | ApiKeyUncheckedCreateWithoutTeamInput[]
    connectOrCreate?: ApiKeyCreateOrConnectWithoutTeamInput | ApiKeyCreateOrConnectWithoutTeamInput[]
    createMany?: ApiKeyCreateManyTeamInputEnvelope
    connect?: ApiKeyWhereUniqueInput | ApiKeyWhereUniqueInput[]
  }

  export type TeamMemberCreateNestedManyWithoutTeamInput = {
    create?: XOR<TeamMemberCreateWithoutTeamInput, TeamMemberUncheckedCreateWithoutTeamInput> | TeamMemberCreateWithoutTeamInput[] | TeamMemberUncheckedCreateWithoutTeamInput[]
    connectOrCreate?: TeamMemberCreateOrConnectWithoutTeamInput | TeamMemberCreateOrConnectWithoutTeamInput[]
    createMany?: TeamMemberCreateManyTeamInputEnvelope
    connect?: TeamMemberWhereUniqueInput | TeamMemberWhereUniqueInput[]
  }

  export type DeviceUncheckedCreateNestedManyWithoutTeamInput = {
    create?: XOR<DeviceCreateWithoutTeamInput, DeviceUncheckedCreateWithoutTeamInput> | DeviceCreateWithoutTeamInput[] | DeviceUncheckedCreateWithoutTeamInput[]
    connectOrCreate?: DeviceCreateOrConnectWithoutTeamInput | DeviceCreateOrConnectWithoutTeamInput[]
    createMany?: DeviceCreateManyTeamInputEnvelope
    connect?: DeviceWhereUniqueInput | DeviceWhereUniqueInput[]
  }

  export type ApiKeyUncheckedCreateNestedManyWithoutTeamInput = {
    create?: XOR<ApiKeyCreateWithoutTeamInput, ApiKeyUncheckedCreateWithoutTeamInput> | ApiKeyCreateWithoutTeamInput[] | ApiKeyUncheckedCreateWithoutTeamInput[]
    connectOrCreate?: ApiKeyCreateOrConnectWithoutTeamInput | ApiKeyCreateOrConnectWithoutTeamInput[]
    createMany?: ApiKeyCreateManyTeamInputEnvelope
    connect?: ApiKeyWhereUniqueInput | ApiKeyWhereUniqueInput[]
  }

  export type TeamMemberUncheckedCreateNestedManyWithoutTeamInput = {
    create?: XOR<TeamMemberCreateWithoutTeamInput, TeamMemberUncheckedCreateWithoutTeamInput> | TeamMemberCreateWithoutTeamInput[] | TeamMemberUncheckedCreateWithoutTeamInput[]
    connectOrCreate?: TeamMemberCreateOrConnectWithoutTeamInput | TeamMemberCreateOrConnectWithoutTeamInput[]
    createMany?: TeamMemberCreateManyTeamInputEnvelope
    connect?: TeamMemberWhereUniqueInput | TeamMemberWhereUniqueInput[]
  }

  export type DeviceUpdateManyWithoutTeamNestedInput = {
    create?: XOR<DeviceCreateWithoutTeamInput, DeviceUncheckedCreateWithoutTeamInput> | DeviceCreateWithoutTeamInput[] | DeviceUncheckedCreateWithoutTeamInput[]
    connectOrCreate?: DeviceCreateOrConnectWithoutTeamInput | DeviceCreateOrConnectWithoutTeamInput[]
    upsert?: DeviceUpsertWithWhereUniqueWithoutTeamInput | DeviceUpsertWithWhereUniqueWithoutTeamInput[]
    createMany?: DeviceCreateManyTeamInputEnvelope
    set?: DeviceWhereUniqueInput | DeviceWhereUniqueInput[]
    disconnect?: DeviceWhereUniqueInput | DeviceWhereUniqueInput[]
    delete?: DeviceWhereUniqueInput | DeviceWhereUniqueInput[]
    connect?: DeviceWhereUniqueInput | DeviceWhereUniqueInput[]
    update?: DeviceUpdateWithWhereUniqueWithoutTeamInput | DeviceUpdateWithWhereUniqueWithoutTeamInput[]
    updateMany?: DeviceUpdateManyWithWhereWithoutTeamInput | DeviceUpdateManyWithWhereWithoutTeamInput[]
    deleteMany?: DeviceScalarWhereInput | DeviceScalarWhereInput[]
  }

  export type ApiKeyUpdateManyWithoutTeamNestedInput = {
    create?: XOR<ApiKeyCreateWithoutTeamInput, ApiKeyUncheckedCreateWithoutTeamInput> | ApiKeyCreateWithoutTeamInput[] | ApiKeyUncheckedCreateWithoutTeamInput[]
    connectOrCreate?: ApiKeyCreateOrConnectWithoutTeamInput | ApiKeyCreateOrConnectWithoutTeamInput[]
    upsert?: ApiKeyUpsertWithWhereUniqueWithoutTeamInput | ApiKeyUpsertWithWhereUniqueWithoutTeamInput[]
    createMany?: ApiKeyCreateManyTeamInputEnvelope
    set?: ApiKeyWhereUniqueInput | ApiKeyWhereUniqueInput[]
    disconnect?: ApiKeyWhereUniqueInput | ApiKeyWhereUniqueInput[]
    delete?: ApiKeyWhereUniqueInput | ApiKeyWhereUniqueInput[]
    connect?: ApiKeyWhereUniqueInput | ApiKeyWhereUniqueInput[]
    update?: ApiKeyUpdateWithWhereUniqueWithoutTeamInput | ApiKeyUpdateWithWhereUniqueWithoutTeamInput[]
    updateMany?: ApiKeyUpdateManyWithWhereWithoutTeamInput | ApiKeyUpdateManyWithWhereWithoutTeamInput[]
    deleteMany?: ApiKeyScalarWhereInput | ApiKeyScalarWhereInput[]
  }

  export type TeamMemberUpdateManyWithoutTeamNestedInput = {
    create?: XOR<TeamMemberCreateWithoutTeamInput, TeamMemberUncheckedCreateWithoutTeamInput> | TeamMemberCreateWithoutTeamInput[] | TeamMemberUncheckedCreateWithoutTeamInput[]
    connectOrCreate?: TeamMemberCreateOrConnectWithoutTeamInput | TeamMemberCreateOrConnectWithoutTeamInput[]
    upsert?: TeamMemberUpsertWithWhereUniqueWithoutTeamInput | TeamMemberUpsertWithWhereUniqueWithoutTeamInput[]
    createMany?: TeamMemberCreateManyTeamInputEnvelope
    set?: TeamMemberWhereUniqueInput | TeamMemberWhereUniqueInput[]
    disconnect?: TeamMemberWhereUniqueInput | TeamMemberWhereUniqueInput[]
    delete?: TeamMemberWhereUniqueInput | TeamMemberWhereUniqueInput[]
    connect?: TeamMemberWhereUniqueInput | TeamMemberWhereUniqueInput[]
    update?: TeamMemberUpdateWithWhereUniqueWithoutTeamInput | TeamMemberUpdateWithWhereUniqueWithoutTeamInput[]
    updateMany?: TeamMemberUpdateManyWithWhereWithoutTeamInput | TeamMemberUpdateManyWithWhereWithoutTeamInput[]
    deleteMany?: TeamMemberScalarWhereInput | TeamMemberScalarWhereInput[]
  }

  export type DeviceUncheckedUpdateManyWithoutTeamNestedInput = {
    create?: XOR<DeviceCreateWithoutTeamInput, DeviceUncheckedCreateWithoutTeamInput> | DeviceCreateWithoutTeamInput[] | DeviceUncheckedCreateWithoutTeamInput[]
    connectOrCreate?: DeviceCreateOrConnectWithoutTeamInput | DeviceCreateOrConnectWithoutTeamInput[]
    upsert?: DeviceUpsertWithWhereUniqueWithoutTeamInput | DeviceUpsertWithWhereUniqueWithoutTeamInput[]
    createMany?: DeviceCreateManyTeamInputEnvelope
    set?: DeviceWhereUniqueInput | DeviceWhereUniqueInput[]
    disconnect?: DeviceWhereUniqueInput | DeviceWhereUniqueInput[]
    delete?: DeviceWhereUniqueInput | DeviceWhereUniqueInput[]
    connect?: DeviceWhereUniqueInput | DeviceWhereUniqueInput[]
    update?: DeviceUpdateWithWhereUniqueWithoutTeamInput | DeviceUpdateWithWhereUniqueWithoutTeamInput[]
    updateMany?: DeviceUpdateManyWithWhereWithoutTeamInput | DeviceUpdateManyWithWhereWithoutTeamInput[]
    deleteMany?: DeviceScalarWhereInput | DeviceScalarWhereInput[]
  }

  export type ApiKeyUncheckedUpdateManyWithoutTeamNestedInput = {
    create?: XOR<ApiKeyCreateWithoutTeamInput, ApiKeyUncheckedCreateWithoutTeamInput> | ApiKeyCreateWithoutTeamInput[] | ApiKeyUncheckedCreateWithoutTeamInput[]
    connectOrCreate?: ApiKeyCreateOrConnectWithoutTeamInput | ApiKeyCreateOrConnectWithoutTeamInput[]
    upsert?: ApiKeyUpsertWithWhereUniqueWithoutTeamInput | ApiKeyUpsertWithWhereUniqueWithoutTeamInput[]
    createMany?: ApiKeyCreateManyTeamInputEnvelope
    set?: ApiKeyWhereUniqueInput | ApiKeyWhereUniqueInput[]
    disconnect?: ApiKeyWhereUniqueInput | ApiKeyWhereUniqueInput[]
    delete?: ApiKeyWhereUniqueInput | ApiKeyWhereUniqueInput[]
    connect?: ApiKeyWhereUniqueInput | ApiKeyWhereUniqueInput[]
    update?: ApiKeyUpdateWithWhereUniqueWithoutTeamInput | ApiKeyUpdateWithWhereUniqueWithoutTeamInput[]
    updateMany?: ApiKeyUpdateManyWithWhereWithoutTeamInput | ApiKeyUpdateManyWithWhereWithoutTeamInput[]
    deleteMany?: ApiKeyScalarWhereInput | ApiKeyScalarWhereInput[]
  }

  export type TeamMemberUncheckedUpdateManyWithoutTeamNestedInput = {
    create?: XOR<TeamMemberCreateWithoutTeamInput, TeamMemberUncheckedCreateWithoutTeamInput> | TeamMemberCreateWithoutTeamInput[] | TeamMemberUncheckedCreateWithoutTeamInput[]
    connectOrCreate?: TeamMemberCreateOrConnectWithoutTeamInput | TeamMemberCreateOrConnectWithoutTeamInput[]
    upsert?: TeamMemberUpsertWithWhereUniqueWithoutTeamInput | TeamMemberUpsertWithWhereUniqueWithoutTeamInput[]
    createMany?: TeamMemberCreateManyTeamInputEnvelope
    set?: TeamMemberWhereUniqueInput | TeamMemberWhereUniqueInput[]
    disconnect?: TeamMemberWhereUniqueInput | TeamMemberWhereUniqueInput[]
    delete?: TeamMemberWhereUniqueInput | TeamMemberWhereUniqueInput[]
    connect?: TeamMemberWhereUniqueInput | TeamMemberWhereUniqueInput[]
    update?: TeamMemberUpdateWithWhereUniqueWithoutTeamInput | TeamMemberUpdateWithWhereUniqueWithoutTeamInput[]
    updateMany?: TeamMemberUpdateManyWithWhereWithoutTeamInput | TeamMemberUpdateManyWithWhereWithoutTeamInput[]
    deleteMany?: TeamMemberScalarWhereInput | TeamMemberScalarWhereInput[]
  }

  export type BookmarkCreateNestedManyWithoutRecordingInput = {
    create?: XOR<BookmarkCreateWithoutRecordingInput, BookmarkUncheckedCreateWithoutRecordingInput> | BookmarkCreateWithoutRecordingInput[] | BookmarkUncheckedCreateWithoutRecordingInput[]
    connectOrCreate?: BookmarkCreateOrConnectWithoutRecordingInput | BookmarkCreateOrConnectWithoutRecordingInput[]
    createMany?: BookmarkCreateManyRecordingInputEnvelope
    connect?: BookmarkWhereUniqueInput | BookmarkWhereUniqueInput[]
  }

  export type AnnotationCreateNestedManyWithoutRecordingInput = {
    create?: XOR<AnnotationCreateWithoutRecordingInput, AnnotationUncheckedCreateWithoutRecordingInput> | AnnotationCreateWithoutRecordingInput[] | AnnotationUncheckedCreateWithoutRecordingInput[]
    connectOrCreate?: AnnotationCreateOrConnectWithoutRecordingInput | AnnotationCreateOrConnectWithoutRecordingInput[]
    createMany?: AnnotationCreateManyRecordingInputEnvelope
    connect?: AnnotationWhereUniqueInput | AnnotationWhereUniqueInput[]
  }

  export type SessionCreateNestedOneWithoutRecordingInput = {
    create?: XOR<SessionCreateWithoutRecordingInput, SessionUncheckedCreateWithoutRecordingInput>
    connectOrCreate?: SessionCreateOrConnectWithoutRecordingInput
    connect?: SessionWhereUniqueInput
  }

  export type BookmarkUncheckedCreateNestedManyWithoutRecordingInput = {
    create?: XOR<BookmarkCreateWithoutRecordingInput, BookmarkUncheckedCreateWithoutRecordingInput> | BookmarkCreateWithoutRecordingInput[] | BookmarkUncheckedCreateWithoutRecordingInput[]
    connectOrCreate?: BookmarkCreateOrConnectWithoutRecordingInput | BookmarkCreateOrConnectWithoutRecordingInput[]
    createMany?: BookmarkCreateManyRecordingInputEnvelope
    connect?: BookmarkWhereUniqueInput | BookmarkWhereUniqueInput[]
  }

  export type AnnotationUncheckedCreateNestedManyWithoutRecordingInput = {
    create?: XOR<AnnotationCreateWithoutRecordingInput, AnnotationUncheckedCreateWithoutRecordingInput> | AnnotationCreateWithoutRecordingInput[] | AnnotationUncheckedCreateWithoutRecordingInput[]
    connectOrCreate?: AnnotationCreateOrConnectWithoutRecordingInput | AnnotationCreateOrConnectWithoutRecordingInput[]
    createMany?: AnnotationCreateManyRecordingInputEnvelope
    connect?: AnnotationWhereUniqueInput | AnnotationWhereUniqueInput[]
  }

  export type BookmarkUpdateManyWithoutRecordingNestedInput = {
    create?: XOR<BookmarkCreateWithoutRecordingInput, BookmarkUncheckedCreateWithoutRecordingInput> | BookmarkCreateWithoutRecordingInput[] | BookmarkUncheckedCreateWithoutRecordingInput[]
    connectOrCreate?: BookmarkCreateOrConnectWithoutRecordingInput | BookmarkCreateOrConnectWithoutRecordingInput[]
    upsert?: BookmarkUpsertWithWhereUniqueWithoutRecordingInput | BookmarkUpsertWithWhereUniqueWithoutRecordingInput[]
    createMany?: BookmarkCreateManyRecordingInputEnvelope
    set?: BookmarkWhereUniqueInput | BookmarkWhereUniqueInput[]
    disconnect?: BookmarkWhereUniqueInput | BookmarkWhereUniqueInput[]
    delete?: BookmarkWhereUniqueInput | BookmarkWhereUniqueInput[]
    connect?: BookmarkWhereUniqueInput | BookmarkWhereUniqueInput[]
    update?: BookmarkUpdateWithWhereUniqueWithoutRecordingInput | BookmarkUpdateWithWhereUniqueWithoutRecordingInput[]
    updateMany?: BookmarkUpdateManyWithWhereWithoutRecordingInput | BookmarkUpdateManyWithWhereWithoutRecordingInput[]
    deleteMany?: BookmarkScalarWhereInput | BookmarkScalarWhereInput[]
  }

  export type AnnotationUpdateManyWithoutRecordingNestedInput = {
    create?: XOR<AnnotationCreateWithoutRecordingInput, AnnotationUncheckedCreateWithoutRecordingInput> | AnnotationCreateWithoutRecordingInput[] | AnnotationUncheckedCreateWithoutRecordingInput[]
    connectOrCreate?: AnnotationCreateOrConnectWithoutRecordingInput | AnnotationCreateOrConnectWithoutRecordingInput[]
    upsert?: AnnotationUpsertWithWhereUniqueWithoutRecordingInput | AnnotationUpsertWithWhereUniqueWithoutRecordingInput[]
    createMany?: AnnotationCreateManyRecordingInputEnvelope
    set?: AnnotationWhereUniqueInput | AnnotationWhereUniqueInput[]
    disconnect?: AnnotationWhereUniqueInput | AnnotationWhereUniqueInput[]
    delete?: AnnotationWhereUniqueInput | AnnotationWhereUniqueInput[]
    connect?: AnnotationWhereUniqueInput | AnnotationWhereUniqueInput[]
    update?: AnnotationUpdateWithWhereUniqueWithoutRecordingInput | AnnotationUpdateWithWhereUniqueWithoutRecordingInput[]
    updateMany?: AnnotationUpdateManyWithWhereWithoutRecordingInput | AnnotationUpdateManyWithWhereWithoutRecordingInput[]
    deleteMany?: AnnotationScalarWhereInput | AnnotationScalarWhereInput[]
  }

  export type SessionUpdateOneWithoutRecordingNestedInput = {
    create?: XOR<SessionCreateWithoutRecordingInput, SessionUncheckedCreateWithoutRecordingInput>
    connectOrCreate?: SessionCreateOrConnectWithoutRecordingInput
    upsert?: SessionUpsertWithoutRecordingInput
    disconnect?: SessionWhereInput | boolean
    delete?: SessionWhereInput | boolean
    connect?: SessionWhereUniqueInput
    update?: XOR<XOR<SessionUpdateToOneWithWhereWithoutRecordingInput, SessionUpdateWithoutRecordingInput>, SessionUncheckedUpdateWithoutRecordingInput>
  }

  export type BookmarkUncheckedUpdateManyWithoutRecordingNestedInput = {
    create?: XOR<BookmarkCreateWithoutRecordingInput, BookmarkUncheckedCreateWithoutRecordingInput> | BookmarkCreateWithoutRecordingInput[] | BookmarkUncheckedCreateWithoutRecordingInput[]
    connectOrCreate?: BookmarkCreateOrConnectWithoutRecordingInput | BookmarkCreateOrConnectWithoutRecordingInput[]
    upsert?: BookmarkUpsertWithWhereUniqueWithoutRecordingInput | BookmarkUpsertWithWhereUniqueWithoutRecordingInput[]
    createMany?: BookmarkCreateManyRecordingInputEnvelope
    set?: BookmarkWhereUniqueInput | BookmarkWhereUniqueInput[]
    disconnect?: BookmarkWhereUniqueInput | BookmarkWhereUniqueInput[]
    delete?: BookmarkWhereUniqueInput | BookmarkWhereUniqueInput[]
    connect?: BookmarkWhereUniqueInput | BookmarkWhereUniqueInput[]
    update?: BookmarkUpdateWithWhereUniqueWithoutRecordingInput | BookmarkUpdateWithWhereUniqueWithoutRecordingInput[]
    updateMany?: BookmarkUpdateManyWithWhereWithoutRecordingInput | BookmarkUpdateManyWithWhereWithoutRecordingInput[]
    deleteMany?: BookmarkScalarWhereInput | BookmarkScalarWhereInput[]
  }

  export type AnnotationUncheckedUpdateManyWithoutRecordingNestedInput = {
    create?: XOR<AnnotationCreateWithoutRecordingInput, AnnotationUncheckedCreateWithoutRecordingInput> | AnnotationCreateWithoutRecordingInput[] | AnnotationUncheckedCreateWithoutRecordingInput[]
    connectOrCreate?: AnnotationCreateOrConnectWithoutRecordingInput | AnnotationCreateOrConnectWithoutRecordingInput[]
    upsert?: AnnotationUpsertWithWhereUniqueWithoutRecordingInput | AnnotationUpsertWithWhereUniqueWithoutRecordingInput[]
    createMany?: AnnotationCreateManyRecordingInputEnvelope
    set?: AnnotationWhereUniqueInput | AnnotationWhereUniqueInput[]
    disconnect?: AnnotationWhereUniqueInput | AnnotationWhereUniqueInput[]
    delete?: AnnotationWhereUniqueInput | AnnotationWhereUniqueInput[]
    connect?: AnnotationWhereUniqueInput | AnnotationWhereUniqueInput[]
    update?: AnnotationUpdateWithWhereUniqueWithoutRecordingInput | AnnotationUpdateWithWhereUniqueWithoutRecordingInput[]
    updateMany?: AnnotationUpdateManyWithWhereWithoutRecordingInput | AnnotationUpdateManyWithWhereWithoutRecordingInput[]
    deleteMany?: AnnotationScalarWhereInput | AnnotationScalarWhereInput[]
  }

  export type RecordingCreateNestedOneWithoutBookmarksInput = {
    create?: XOR<RecordingCreateWithoutBookmarksInput, RecordingUncheckedCreateWithoutBookmarksInput>
    connectOrCreate?: RecordingCreateOrConnectWithoutBookmarksInput
    connect?: RecordingWhereUniqueInput
  }

  export type RecordingUpdateOneRequiredWithoutBookmarksNestedInput = {
    create?: XOR<RecordingCreateWithoutBookmarksInput, RecordingUncheckedCreateWithoutBookmarksInput>
    connectOrCreate?: RecordingCreateOrConnectWithoutBookmarksInput
    upsert?: RecordingUpsertWithoutBookmarksInput
    connect?: RecordingWhereUniqueInput
    update?: XOR<XOR<RecordingUpdateToOneWithWhereWithoutBookmarksInput, RecordingUpdateWithoutBookmarksInput>, RecordingUncheckedUpdateWithoutBookmarksInput>
  }

  export type RecordingCreateNestedOneWithoutAnnotationsInput = {
    create?: XOR<RecordingCreateWithoutAnnotationsInput, RecordingUncheckedCreateWithoutAnnotationsInput>
    connectOrCreate?: RecordingCreateOrConnectWithoutAnnotationsInput
    connect?: RecordingWhereUniqueInput
  }

  export type RecordingUpdateOneRequiredWithoutAnnotationsNestedInput = {
    create?: XOR<RecordingCreateWithoutAnnotationsInput, RecordingUncheckedCreateWithoutAnnotationsInput>
    connectOrCreate?: RecordingCreateOrConnectWithoutAnnotationsInput
    upsert?: RecordingUpsertWithoutAnnotationsInput
    connect?: RecordingWhereUniqueInput
    update?: XOR<XOR<RecordingUpdateToOneWithWhereWithoutAnnotationsInput, RecordingUpdateWithoutAnnotationsInput>, RecordingUncheckedUpdateWithoutAnnotationsInput>
  }

  export type ApiKeyCreateNestedManyWithoutUserInput = {
    create?: XOR<ApiKeyCreateWithoutUserInput, ApiKeyUncheckedCreateWithoutUserInput> | ApiKeyCreateWithoutUserInput[] | ApiKeyUncheckedCreateWithoutUserInput[]
    connectOrCreate?: ApiKeyCreateOrConnectWithoutUserInput | ApiKeyCreateOrConnectWithoutUserInput[]
    createMany?: ApiKeyCreateManyUserInputEnvelope
    connect?: ApiKeyWhereUniqueInput | ApiKeyWhereUniqueInput[]
  }

  export type UserSessionCreateNestedManyWithoutUserInput = {
    create?: XOR<UserSessionCreateWithoutUserInput, UserSessionUncheckedCreateWithoutUserInput> | UserSessionCreateWithoutUserInput[] | UserSessionUncheckedCreateWithoutUserInput[]
    connectOrCreate?: UserSessionCreateOrConnectWithoutUserInput | UserSessionCreateOrConnectWithoutUserInput[]
    createMany?: UserSessionCreateManyUserInputEnvelope
    connect?: UserSessionWhereUniqueInput | UserSessionWhereUniqueInput[]
  }

  export type PasswordResetTokenCreateNestedManyWithoutUserInput = {
    create?: XOR<PasswordResetTokenCreateWithoutUserInput, PasswordResetTokenUncheckedCreateWithoutUserInput> | PasswordResetTokenCreateWithoutUserInput[] | PasswordResetTokenUncheckedCreateWithoutUserInput[]
    connectOrCreate?: PasswordResetTokenCreateOrConnectWithoutUserInput | PasswordResetTokenCreateOrConnectWithoutUserInput[]
    createMany?: PasswordResetTokenCreateManyUserInputEnvelope
    connect?: PasswordResetTokenWhereUniqueInput | PasswordResetTokenWhereUniqueInput[]
  }

  export type TeamMemberCreateNestedManyWithoutUserInput = {
    create?: XOR<TeamMemberCreateWithoutUserInput, TeamMemberUncheckedCreateWithoutUserInput> | TeamMemberCreateWithoutUserInput[] | TeamMemberUncheckedCreateWithoutUserInput[]
    connectOrCreate?: TeamMemberCreateOrConnectWithoutUserInput | TeamMemberCreateOrConnectWithoutUserInput[]
    createMany?: TeamMemberCreateManyUserInputEnvelope
    connect?: TeamMemberWhereUniqueInput | TeamMemberWhereUniqueInput[]
  }

  export type ApiKeyUncheckedCreateNestedManyWithoutUserInput = {
    create?: XOR<ApiKeyCreateWithoutUserInput, ApiKeyUncheckedCreateWithoutUserInput> | ApiKeyCreateWithoutUserInput[] | ApiKeyUncheckedCreateWithoutUserInput[]
    connectOrCreate?: ApiKeyCreateOrConnectWithoutUserInput | ApiKeyCreateOrConnectWithoutUserInput[]
    createMany?: ApiKeyCreateManyUserInputEnvelope
    connect?: ApiKeyWhereUniqueInput | ApiKeyWhereUniqueInput[]
  }

  export type UserSessionUncheckedCreateNestedManyWithoutUserInput = {
    create?: XOR<UserSessionCreateWithoutUserInput, UserSessionUncheckedCreateWithoutUserInput> | UserSessionCreateWithoutUserInput[] | UserSessionUncheckedCreateWithoutUserInput[]
    connectOrCreate?: UserSessionCreateOrConnectWithoutUserInput | UserSessionCreateOrConnectWithoutUserInput[]
    createMany?: UserSessionCreateManyUserInputEnvelope
    connect?: UserSessionWhereUniqueInput | UserSessionWhereUniqueInput[]
  }

  export type PasswordResetTokenUncheckedCreateNestedManyWithoutUserInput = {
    create?: XOR<PasswordResetTokenCreateWithoutUserInput, PasswordResetTokenUncheckedCreateWithoutUserInput> | PasswordResetTokenCreateWithoutUserInput[] | PasswordResetTokenUncheckedCreateWithoutUserInput[]
    connectOrCreate?: PasswordResetTokenCreateOrConnectWithoutUserInput | PasswordResetTokenCreateOrConnectWithoutUserInput[]
    createMany?: PasswordResetTokenCreateManyUserInputEnvelope
    connect?: PasswordResetTokenWhereUniqueInput | PasswordResetTokenWhereUniqueInput[]
  }

  export type TeamMemberUncheckedCreateNestedManyWithoutUserInput = {
    create?: XOR<TeamMemberCreateWithoutUserInput, TeamMemberUncheckedCreateWithoutUserInput> | TeamMemberCreateWithoutUserInput[] | TeamMemberUncheckedCreateWithoutUserInput[]
    connectOrCreate?: TeamMemberCreateOrConnectWithoutUserInput | TeamMemberCreateOrConnectWithoutUserInput[]
    createMany?: TeamMemberCreateManyUserInputEnvelope
    connect?: TeamMemberWhereUniqueInput | TeamMemberWhereUniqueInput[]
  }

  export type ApiKeyUpdateManyWithoutUserNestedInput = {
    create?: XOR<ApiKeyCreateWithoutUserInput, ApiKeyUncheckedCreateWithoutUserInput> | ApiKeyCreateWithoutUserInput[] | ApiKeyUncheckedCreateWithoutUserInput[]
    connectOrCreate?: ApiKeyCreateOrConnectWithoutUserInput | ApiKeyCreateOrConnectWithoutUserInput[]
    upsert?: ApiKeyUpsertWithWhereUniqueWithoutUserInput | ApiKeyUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: ApiKeyCreateManyUserInputEnvelope
    set?: ApiKeyWhereUniqueInput | ApiKeyWhereUniqueInput[]
    disconnect?: ApiKeyWhereUniqueInput | ApiKeyWhereUniqueInput[]
    delete?: ApiKeyWhereUniqueInput | ApiKeyWhereUniqueInput[]
    connect?: ApiKeyWhereUniqueInput | ApiKeyWhereUniqueInput[]
    update?: ApiKeyUpdateWithWhereUniqueWithoutUserInput | ApiKeyUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: ApiKeyUpdateManyWithWhereWithoutUserInput | ApiKeyUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: ApiKeyScalarWhereInput | ApiKeyScalarWhereInput[]
  }

  export type UserSessionUpdateManyWithoutUserNestedInput = {
    create?: XOR<UserSessionCreateWithoutUserInput, UserSessionUncheckedCreateWithoutUserInput> | UserSessionCreateWithoutUserInput[] | UserSessionUncheckedCreateWithoutUserInput[]
    connectOrCreate?: UserSessionCreateOrConnectWithoutUserInput | UserSessionCreateOrConnectWithoutUserInput[]
    upsert?: UserSessionUpsertWithWhereUniqueWithoutUserInput | UserSessionUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: UserSessionCreateManyUserInputEnvelope
    set?: UserSessionWhereUniqueInput | UserSessionWhereUniqueInput[]
    disconnect?: UserSessionWhereUniqueInput | UserSessionWhereUniqueInput[]
    delete?: UserSessionWhereUniqueInput | UserSessionWhereUniqueInput[]
    connect?: UserSessionWhereUniqueInput | UserSessionWhereUniqueInput[]
    update?: UserSessionUpdateWithWhereUniqueWithoutUserInput | UserSessionUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: UserSessionUpdateManyWithWhereWithoutUserInput | UserSessionUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: UserSessionScalarWhereInput | UserSessionScalarWhereInput[]
  }

  export type PasswordResetTokenUpdateManyWithoutUserNestedInput = {
    create?: XOR<PasswordResetTokenCreateWithoutUserInput, PasswordResetTokenUncheckedCreateWithoutUserInput> | PasswordResetTokenCreateWithoutUserInput[] | PasswordResetTokenUncheckedCreateWithoutUserInput[]
    connectOrCreate?: PasswordResetTokenCreateOrConnectWithoutUserInput | PasswordResetTokenCreateOrConnectWithoutUserInput[]
    upsert?: PasswordResetTokenUpsertWithWhereUniqueWithoutUserInput | PasswordResetTokenUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: PasswordResetTokenCreateManyUserInputEnvelope
    set?: PasswordResetTokenWhereUniqueInput | PasswordResetTokenWhereUniqueInput[]
    disconnect?: PasswordResetTokenWhereUniqueInput | PasswordResetTokenWhereUniqueInput[]
    delete?: PasswordResetTokenWhereUniqueInput | PasswordResetTokenWhereUniqueInput[]
    connect?: PasswordResetTokenWhereUniqueInput | PasswordResetTokenWhereUniqueInput[]
    update?: PasswordResetTokenUpdateWithWhereUniqueWithoutUserInput | PasswordResetTokenUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: PasswordResetTokenUpdateManyWithWhereWithoutUserInput | PasswordResetTokenUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: PasswordResetTokenScalarWhereInput | PasswordResetTokenScalarWhereInput[]
  }

  export type TeamMemberUpdateManyWithoutUserNestedInput = {
    create?: XOR<TeamMemberCreateWithoutUserInput, TeamMemberUncheckedCreateWithoutUserInput> | TeamMemberCreateWithoutUserInput[] | TeamMemberUncheckedCreateWithoutUserInput[]
    connectOrCreate?: TeamMemberCreateOrConnectWithoutUserInput | TeamMemberCreateOrConnectWithoutUserInput[]
    upsert?: TeamMemberUpsertWithWhereUniqueWithoutUserInput | TeamMemberUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: TeamMemberCreateManyUserInputEnvelope
    set?: TeamMemberWhereUniqueInput | TeamMemberWhereUniqueInput[]
    disconnect?: TeamMemberWhereUniqueInput | TeamMemberWhereUniqueInput[]
    delete?: TeamMemberWhereUniqueInput | TeamMemberWhereUniqueInput[]
    connect?: TeamMemberWhereUniqueInput | TeamMemberWhereUniqueInput[]
    update?: TeamMemberUpdateWithWhereUniqueWithoutUserInput | TeamMemberUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: TeamMemberUpdateManyWithWhereWithoutUserInput | TeamMemberUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: TeamMemberScalarWhereInput | TeamMemberScalarWhereInput[]
  }

  export type ApiKeyUncheckedUpdateManyWithoutUserNestedInput = {
    create?: XOR<ApiKeyCreateWithoutUserInput, ApiKeyUncheckedCreateWithoutUserInput> | ApiKeyCreateWithoutUserInput[] | ApiKeyUncheckedCreateWithoutUserInput[]
    connectOrCreate?: ApiKeyCreateOrConnectWithoutUserInput | ApiKeyCreateOrConnectWithoutUserInput[]
    upsert?: ApiKeyUpsertWithWhereUniqueWithoutUserInput | ApiKeyUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: ApiKeyCreateManyUserInputEnvelope
    set?: ApiKeyWhereUniqueInput | ApiKeyWhereUniqueInput[]
    disconnect?: ApiKeyWhereUniqueInput | ApiKeyWhereUniqueInput[]
    delete?: ApiKeyWhereUniqueInput | ApiKeyWhereUniqueInput[]
    connect?: ApiKeyWhereUniqueInput | ApiKeyWhereUniqueInput[]
    update?: ApiKeyUpdateWithWhereUniqueWithoutUserInput | ApiKeyUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: ApiKeyUpdateManyWithWhereWithoutUserInput | ApiKeyUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: ApiKeyScalarWhereInput | ApiKeyScalarWhereInput[]
  }

  export type UserSessionUncheckedUpdateManyWithoutUserNestedInput = {
    create?: XOR<UserSessionCreateWithoutUserInput, UserSessionUncheckedCreateWithoutUserInput> | UserSessionCreateWithoutUserInput[] | UserSessionUncheckedCreateWithoutUserInput[]
    connectOrCreate?: UserSessionCreateOrConnectWithoutUserInput | UserSessionCreateOrConnectWithoutUserInput[]
    upsert?: UserSessionUpsertWithWhereUniqueWithoutUserInput | UserSessionUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: UserSessionCreateManyUserInputEnvelope
    set?: UserSessionWhereUniqueInput | UserSessionWhereUniqueInput[]
    disconnect?: UserSessionWhereUniqueInput | UserSessionWhereUniqueInput[]
    delete?: UserSessionWhereUniqueInput | UserSessionWhereUniqueInput[]
    connect?: UserSessionWhereUniqueInput | UserSessionWhereUniqueInput[]
    update?: UserSessionUpdateWithWhereUniqueWithoutUserInput | UserSessionUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: UserSessionUpdateManyWithWhereWithoutUserInput | UserSessionUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: UserSessionScalarWhereInput | UserSessionScalarWhereInput[]
  }

  export type PasswordResetTokenUncheckedUpdateManyWithoutUserNestedInput = {
    create?: XOR<PasswordResetTokenCreateWithoutUserInput, PasswordResetTokenUncheckedCreateWithoutUserInput> | PasswordResetTokenCreateWithoutUserInput[] | PasswordResetTokenUncheckedCreateWithoutUserInput[]
    connectOrCreate?: PasswordResetTokenCreateOrConnectWithoutUserInput | PasswordResetTokenCreateOrConnectWithoutUserInput[]
    upsert?: PasswordResetTokenUpsertWithWhereUniqueWithoutUserInput | PasswordResetTokenUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: PasswordResetTokenCreateManyUserInputEnvelope
    set?: PasswordResetTokenWhereUniqueInput | PasswordResetTokenWhereUniqueInput[]
    disconnect?: PasswordResetTokenWhereUniqueInput | PasswordResetTokenWhereUniqueInput[]
    delete?: PasswordResetTokenWhereUniqueInput | PasswordResetTokenWhereUniqueInput[]
    connect?: PasswordResetTokenWhereUniqueInput | PasswordResetTokenWhereUniqueInput[]
    update?: PasswordResetTokenUpdateWithWhereUniqueWithoutUserInput | PasswordResetTokenUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: PasswordResetTokenUpdateManyWithWhereWithoutUserInput | PasswordResetTokenUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: PasswordResetTokenScalarWhereInput | PasswordResetTokenScalarWhereInput[]
  }

  export type TeamMemberUncheckedUpdateManyWithoutUserNestedInput = {
    create?: XOR<TeamMemberCreateWithoutUserInput, TeamMemberUncheckedCreateWithoutUserInput> | TeamMemberCreateWithoutUserInput[] | TeamMemberUncheckedCreateWithoutUserInput[]
    connectOrCreate?: TeamMemberCreateOrConnectWithoutUserInput | TeamMemberCreateOrConnectWithoutUserInput[]
    upsert?: TeamMemberUpsertWithWhereUniqueWithoutUserInput | TeamMemberUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: TeamMemberCreateManyUserInputEnvelope
    set?: TeamMemberWhereUniqueInput | TeamMemberWhereUniqueInput[]
    disconnect?: TeamMemberWhereUniqueInput | TeamMemberWhereUniqueInput[]
    delete?: TeamMemberWhereUniqueInput | TeamMemberWhereUniqueInput[]
    connect?: TeamMemberWhereUniqueInput | TeamMemberWhereUniqueInput[]
    update?: TeamMemberUpdateWithWhereUniqueWithoutUserInput | TeamMemberUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: TeamMemberUpdateManyWithWhereWithoutUserInput | TeamMemberUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: TeamMemberScalarWhereInput | TeamMemberScalarWhereInput[]
  }

  export type UserCreateNestedOneWithoutSessionsInput = {
    create?: XOR<UserCreateWithoutSessionsInput, UserUncheckedCreateWithoutSessionsInput>
    connectOrCreate?: UserCreateOrConnectWithoutSessionsInput
    connect?: UserWhereUniqueInput
  }

  export type UserUpdateOneRequiredWithoutSessionsNestedInput = {
    create?: XOR<UserCreateWithoutSessionsInput, UserUncheckedCreateWithoutSessionsInput>
    connectOrCreate?: UserCreateOrConnectWithoutSessionsInput
    upsert?: UserUpsertWithoutSessionsInput
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutSessionsInput, UserUpdateWithoutSessionsInput>, UserUncheckedUpdateWithoutSessionsInput>
  }

  export type UserCreateNestedOneWithoutPasswordResetTokensInput = {
    create?: XOR<UserCreateWithoutPasswordResetTokensInput, UserUncheckedCreateWithoutPasswordResetTokensInput>
    connectOrCreate?: UserCreateOrConnectWithoutPasswordResetTokensInput
    connect?: UserWhereUniqueInput
  }

  export type UserUpdateOneRequiredWithoutPasswordResetTokensNestedInput = {
    create?: XOR<UserCreateWithoutPasswordResetTokensInput, UserUncheckedCreateWithoutPasswordResetTokensInput>
    connectOrCreate?: UserCreateOrConnectWithoutPasswordResetTokensInput
    upsert?: UserUpsertWithoutPasswordResetTokensInput
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutPasswordResetTokensInput, UserUpdateWithoutPasswordResetTokensInput>, UserUncheckedUpdateWithoutPasswordResetTokensInput>
  }

  export type TeamCreateNestedOneWithoutMembersInput = {
    create?: XOR<TeamCreateWithoutMembersInput, TeamUncheckedCreateWithoutMembersInput>
    connectOrCreate?: TeamCreateOrConnectWithoutMembersInput
    connect?: TeamWhereUniqueInput
  }

  export type UserCreateNestedOneWithoutTeamMembershipsInput = {
    create?: XOR<UserCreateWithoutTeamMembershipsInput, UserUncheckedCreateWithoutTeamMembershipsInput>
    connectOrCreate?: UserCreateOrConnectWithoutTeamMembershipsInput
    connect?: UserWhereUniqueInput
  }

  export type TeamUpdateOneRequiredWithoutMembersNestedInput = {
    create?: XOR<TeamCreateWithoutMembersInput, TeamUncheckedCreateWithoutMembersInput>
    connectOrCreate?: TeamCreateOrConnectWithoutMembersInput
    upsert?: TeamUpsertWithoutMembersInput
    connect?: TeamWhereUniqueInput
    update?: XOR<XOR<TeamUpdateToOneWithWhereWithoutMembersInput, TeamUpdateWithoutMembersInput>, TeamUncheckedUpdateWithoutMembersInput>
  }

  export type UserUpdateOneRequiredWithoutTeamMembershipsNestedInput = {
    create?: XOR<UserCreateWithoutTeamMembershipsInput, UserUncheckedCreateWithoutTeamMembershipsInput>
    connectOrCreate?: UserCreateOrConnectWithoutTeamMembershipsInput
    upsert?: UserUpsertWithoutTeamMembershipsInput
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutTeamMembershipsInput, UserUpdateWithoutTeamMembershipsInput>, UserUncheckedUpdateWithoutTeamMembershipsInput>
  }

  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>
    not?: NestedStringFilter<$PrismaModel> | string
  }

  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>
    not?: NestedStringNullableFilter<$PrismaModel> | 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 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>
    not?: NestedStringWithAggregatesFilter<$PrismaModel> | string
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedStringFilter<$PrismaModel>
    _max?: NestedStringFilter<$PrismaModel>
  }

  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 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>
    not?: NestedStringNullableWithAggregatesFilter<$PrismaModel> | string | null
    _count?: NestedIntNullableFilter<$PrismaModel>
    _min?: NestedStringNullableFilter<$PrismaModel>
    _max?: NestedStringNullableFilter<$PrismaModel>
  }

  export type NestedIntNullableFilter<$PrismaModel = never> = {
    equals?: number | IntFieldRefInput<$PrismaModel> | null
    in?: number[] | 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 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 NestedBoolFilter<$PrismaModel = never> = {
    equals?: boolean | BooleanFieldRefInput<$PrismaModel>
    not?: NestedBoolFilter<$PrismaModel> | boolean
  }

  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 NestedBoolWithAggregatesFilter<$PrismaModel = never> = {
    equals?: boolean | BooleanFieldRefInput<$PrismaModel>
    not?: NestedBoolWithAggregatesFilter<$PrismaModel> | boolean
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedBoolFilter<$PrismaModel>
    _max?: NestedBoolFilter<$PrismaModel>
  }

  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 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 NestedBoolNullableFilter<$PrismaModel = never> = {
    equals?: boolean | BooleanFieldRefInput<$PrismaModel> | null
    not?: NestedBoolNullableFilter<$PrismaModel> | boolean | null
  }

  export type NestedBoolNullableWithAggregatesFilter<$PrismaModel = never> = {
    equals?: boolean | BooleanFieldRefInput<$PrismaModel> | null
    not?: NestedBoolNullableWithAggregatesFilter<$PrismaModel> | boolean | null
    _count?: NestedIntNullableFilter<$PrismaModel>
    _min?: NestedBoolNullableFilter<$PrismaModel>
    _max?: NestedBoolNullableFilter<$PrismaModel>
  }

  export type NestedFloatNullableWithAggregatesFilter<$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?: NestedFloatNullableWithAggregatesFilter<$PrismaModel> | number | null
    _count?: NestedIntNullableFilter<$PrismaModel>
    _avg?: NestedFloatNullableFilter<$PrismaModel>
    _sum?: NestedFloatNullableFilter<$PrismaModel>
    _min?: NestedFloatNullableFilter<$PrismaModel>
    _max?: NestedFloatNullableFilter<$PrismaModel>
  }

  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 NestedFloatWithAggregatesFilter<$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?: NestedFloatWithAggregatesFilter<$PrismaModel> | number
    _count?: NestedIntFilter<$PrismaModel>
    _avg?: NestedFloatFilter<$PrismaModel>
    _sum?: NestedFloatFilter<$PrismaModel>
    _min?: NestedFloatFilter<$PrismaModel>
    _max?: NestedFloatFilter<$PrismaModel>
  }

  export type SessionCreateWithoutBuildInput = {
    id: string
    name?: string | null
    status?: string
    desired_capabilities: string
    session_capabilities: string
    node_id: string
    has_live_video: boolean
    video_recording_enabled?: boolean
    video_recording?: string | null
    startTime?: Date | string
    endTime?: Date | string | null
    failure_reason?: string | null
    is_profiling_available?: boolean
    device_info?: string | null
    device_udid: string
    device_platform: string
    device_version: string
    device_name?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    performance_trace?: string | null
    failure_category?: string | null
    ai_analysis?: string | null
    tags?: string | null
    trace_id?: string | null
    last_heartbeat_at?: Date | string | null
    heartbeat_pid?: number | null
    heartbeat_host?: string | null
    api_key_id?: string | null
    user_id?: string | null
    Log?: LogCreateNestedManyWithoutSessionInput
    Profiling?: ProfilingCreateNestedManyWithoutSessionInput
    SessionLog?: SessionLogCreateNestedManyWithoutSessionInput
    Recording?: RecordingCreateNestedManyWithoutSessionInput
  }

  export type SessionUncheckedCreateWithoutBuildInput = {
    id: string
    name?: string | null
    status?: string
    desired_capabilities: string
    session_capabilities: string
    node_id: string
    has_live_video: boolean
    video_recording_enabled?: boolean
    video_recording?: string | null
    startTime?: Date | string
    endTime?: Date | string | null
    failure_reason?: string | null
    is_profiling_available?: boolean
    device_info?: string | null
    device_udid: string
    device_platform: string
    device_version: string
    device_name?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    performance_trace?: string | null
    failure_category?: string | null
    ai_analysis?: string | null
    tags?: string | null
    trace_id?: string | null
    last_heartbeat_at?: Date | string | null
    heartbeat_pid?: number | null
    heartbeat_host?: string | null
    api_key_id?: string | null
    user_id?: string | null
    Log?: LogUncheckedCreateNestedManyWithoutSessionInput
    Profiling?: ProfilingUncheckedCreateNestedManyWithoutSessionInput
    SessionLog?: SessionLogUncheckedCreateNestedManyWithoutSessionInput
    Recording?: RecordingUncheckedCreateNestedManyWithoutSessionInput
  }

  export type SessionCreateOrConnectWithoutBuildInput = {
    where: SessionWhereUniqueInput
    create: XOR<SessionCreateWithoutBuildInput, SessionUncheckedCreateWithoutBuildInput>
  }

  export type SessionCreateManyBuildInputEnvelope = {
    data: SessionCreateManyBuildInput | SessionCreateManyBuildInput[]
  }

  export type SessionUpsertWithWhereUniqueWithoutBuildInput = {
    where: SessionWhereUniqueInput
    update: XOR<SessionUpdateWithoutBuildInput, SessionUncheckedUpdateWithoutBuildInput>
    create: XOR<SessionCreateWithoutBuildInput, SessionUncheckedCreateWithoutBuildInput>
  }

  export type SessionUpdateWithWhereUniqueWithoutBuildInput = {
    where: SessionWhereUniqueInput
    data: XOR<SessionUpdateWithoutBuildInput, SessionUncheckedUpdateWithoutBuildInput>
  }

  export type SessionUpdateManyWithWhereWithoutBuildInput = {
    where: SessionScalarWhereInput
    data: XOR<SessionUpdateManyMutationInput, SessionUncheckedUpdateManyWithoutBuildInput>
  }

  export type SessionScalarWhereInput = {
    AND?: SessionScalarWhereInput | SessionScalarWhereInput[]
    OR?: SessionScalarWhereInput[]
    NOT?: SessionScalarWhereInput | SessionScalarWhereInput[]
    id?: StringFilter<"Session"> | string
    build_id?: StringNullableFilter<"Session"> | string | null
    name?: StringNullableFilter<"Session"> | string | null
    status?: StringFilter<"Session"> | string
    desired_capabilities?: StringFilter<"Session"> | string
    session_capabilities?: StringFilter<"Session"> | string
    node_id?: StringFilter<"Session"> | string
    has_live_video?: BoolFilter<"Session"> | boolean
    video_recording_enabled?: BoolFilter<"Session"> | boolean
    video_recording?: StringNullableFilter<"Session"> | string | null
    startTime?: DateTimeFilter<"Session"> | Date | string
    endTime?: DateTimeNullableFilter<"Session"> | Date | string | null
    failure_reason?: StringNullableFilter<"Session"> | string | null
    is_profiling_available?: BoolFilter<"Session"> | boolean
    device_info?: StringNullableFilter<"Session"> | string | null
    device_udid?: StringFilter<"Session"> | string
    device_platform?: StringFilter<"Session"> | string
    device_version?: StringFilter<"Session"> | string
    device_name?: StringNullableFilter<"Session"> | string | null
    createdAt?: DateTimeFilter<"Session"> | Date | string
    updatedAt?: DateTimeFilter<"Session"> | Date | string
    performance_trace?: StringNullableFilter<"Session"> | string | null
    failure_category?: StringNullableFilter<"Session"> | string | null
    ai_analysis?: StringNullableFilter<"Session"> | string | null
    tags?: StringNullableFilter<"Session"> | string | null
    trace_id?: StringNullableFilter<"Session"> | string | null
    last_heartbeat_at?: DateTimeNullableFilter<"Session"> | Date | string | null
    heartbeat_pid?: IntNullableFilter<"Session"> | number | null
    heartbeat_host?: StringNullableFilter<"Session"> | string | null
    api_key_id?: StringNullableFilter<"Session"> | string | null
    user_id?: StringNullableFilter<"Session"> | string | null
  }

  export type LogCreateWithoutSessionInput = {
    id?: string
    log_type: string
    message: string
    timestamp?: Date | string
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type LogUncheckedCreateWithoutSessionInput = {
    id?: string
    log_type: string
    message: string
    timestamp?: Date | string
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type LogCreateOrConnectWithoutSessionInput = {
    where: LogWhereUniqueInput
    create: XOR<LogCreateWithoutSessionInput, LogUncheckedCreateWithoutSessionInput>
  }

  export type LogCreateManySessionInputEnvelope = {
    data: LogCreateManySessionInput | LogCreateManySessionInput[]
  }

  export type ProfilingCreateWithoutSessionInput = {
    cpu?: string | null
    memory?: string | null
    total_cpu_used?: string | null
    total_memory_used?: string | null
    raw_cpu_log?: string | null
    raw_memory_log?: string | null
    timestamp: Date | string
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type ProfilingUncheckedCreateWithoutSessionInput = {
    id?: number
    cpu?: string | null
    memory?: string | null
    total_cpu_used?: string | null
    total_memory_used?: string | null
    raw_cpu_log?: string | null
    raw_memory_log?: string | null
    timestamp: Date | string
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type ProfilingCreateOrConnectWithoutSessionInput = {
    where: ProfilingWhereUniqueInput
    create: XOR<ProfilingCreateWithoutSessionInput, ProfilingUncheckedCreateWithoutSessionInput>
  }

  export type ProfilingCreateManySessionInputEnvelope = {
    data: ProfilingCreateManySessionInput | ProfilingCreateManySessionInput[]
  }

  export type BuildCreateWithoutSessionsInput = {
    id?: string
    name?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type BuildUncheckedCreateWithoutSessionsInput = {
    id?: string
    name?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type BuildCreateOrConnectWithoutSessionsInput = {
    where: BuildWhereUniqueInput
    create: XOR<BuildCreateWithoutSessionsInput, BuildUncheckedCreateWithoutSessionsInput>
  }

  export type SessionLogCreateWithoutSessionInput = {
    id?: string
    command_name?: string | null
    url: string
    method: string
    title: string
    subtitle?: string | null
    body?: string | null
    response: string
    screenshot?: string | null
    is_success?: boolean | null
    is_error?: boolean
    is_healed?: boolean
    original_selector?: string | null
    healed_selector?: string | null
    healing_confidence?: number | null
    healing_tier?: string | null
    original_strategy?: string | null
    healed_strategy?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    duration?: number | null
    span_id?: string | null
    trace_id?: string | null
  }

  export type SessionLogUncheckedCreateWithoutSessionInput = {
    id?: string
    command_name?: string | null
    url: string
    method: string
    title: string
    subtitle?: string | null
    body?: string | null
    response: string
    screenshot?: string | null
    is_success?: boolean | null
    is_error?: boolean
    is_healed?: boolean
    original_selector?: string | null
    healed_selector?: string | null
    healing_confidence?: number | null
    healing_tier?: string | null
    original_strategy?: string | null
    healed_strategy?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    duration?: number | null
    span_id?: string | null
    trace_id?: string | null
  }

  export type SessionLogCreateOrConnectWithoutSessionInput = {
    where: SessionLogWhereUniqueInput
    create: XOR<SessionLogCreateWithoutSessionInput, SessionLogUncheckedCreateWithoutSessionInput>
  }

  export type SessionLogCreateManySessionInputEnvelope = {
    data: SessionLogCreateManySessionInput | SessionLogCreateManySessionInput[]
  }

  export type RecordingCreateWithoutSessionInput = {
    id?: string
    group_id: string
    device_udid: string
    device_host?: string
    started_at: Date | string
    ended_at?: Date | string | null
    status: string
    file_path: string
    duration_ms?: number | null
    size_bytes?: number | null
    device_snapshot?: string | null
    fail_reason?: string | null
    bookmarks?: BookmarkCreateNestedManyWithoutRecordingInput
    annotations?: AnnotationCreateNestedManyWithoutRecordingInput
  }

  export type RecordingUncheckedCreateWithoutSessionInput = {
    id?: string
    group_id: string
    device_udid: string
    device_host?: string
    started_at: Date | string
    ended_at?: Date | string | null
    status: string
    file_path: string
    duration_ms?: number | null
    size_bytes?: number | null
    device_snapshot?: string | null
    fail_reason?: string | null
    bookmarks?: BookmarkUncheckedCreateNestedManyWithoutRecordingInput
    annotations?: AnnotationUncheckedCreateNestedManyWithoutRecordingInput
  }

  export type RecordingCreateOrConnectWithoutSessionInput = {
    where: RecordingWhereUniqueInput
    create: XOR<RecordingCreateWithoutSessionInput, RecordingUncheckedCreateWithoutSessionInput>
  }

  export type RecordingCreateManySessionInputEnvelope = {
    data: RecordingCreateManySessionInput | RecordingCreateManySessionInput[]
  }

  export type LogUpsertWithWhereUniqueWithoutSessionInput = {
    where: LogWhereUniqueInput
    update: XOR<LogUpdateWithoutSessionInput, LogUncheckedUpdateWithoutSessionInput>
    create: XOR<LogCreateWithoutSessionInput, LogUncheckedCreateWithoutSessionInput>
  }

  export type LogUpdateWithWhereUniqueWithoutSessionInput = {
    where: LogWhereUniqueInput
    data: XOR<LogUpdateWithoutSessionInput, LogUncheckedUpdateWithoutSessionInput>
  }

  export type LogUpdateManyWithWhereWithoutSessionInput = {
    where: LogScalarWhereInput
    data: XOR<LogUpdateManyMutationInput, LogUncheckedUpdateManyWithoutSessionInput>
  }

  export type LogScalarWhereInput = {
    AND?: LogScalarWhereInput | LogScalarWhereInput[]
    OR?: LogScalarWhereInput[]
    NOT?: LogScalarWhereInput | LogScalarWhereInput[]
    id?: StringFilter<"Log"> | string
    session_id?: StringFilter<"Log"> | string
    log_type?: StringFilter<"Log"> | string
    message?: StringFilter<"Log"> | string
    timestamp?: DateTimeFilter<"Log"> | Date | string
    createdAt?: DateTimeFilter<"Log"> | Date | string
    updatedAt?: DateTimeFilter<"Log"> | Date | string
  }

  export type ProfilingUpsertWithWhereUniqueWithoutSessionInput = {
    where: ProfilingWhereUniqueInput
    update: XOR<ProfilingUpdateWithoutSessionInput, ProfilingUncheckedUpdateWithoutSessionInput>
    create: XOR<ProfilingCreateWithoutSessionInput, ProfilingUncheckedCreateWithoutSessionInput>
  }

  export type ProfilingUpdateWithWhereUniqueWithoutSessionInput = {
    where: ProfilingWhereUniqueInput
    data: XOR<ProfilingUpdateWithoutSessionInput, ProfilingUncheckedUpdateWithoutSessionInput>
  }

  export type ProfilingUpdateManyWithWhereWithoutSessionInput = {
    where: ProfilingScalarWhereInput
    data: XOR<ProfilingUpdateManyMutationInput, ProfilingUncheckedUpdateManyWithoutSessionInput>
  }

  export type ProfilingScalarWhereInput = {
    AND?: ProfilingScalarWhereInput | ProfilingScalarWhereInput[]
    OR?: ProfilingScalarWhereInput[]
    NOT?: ProfilingScalarWhereInput | ProfilingScalarWhereInput[]
    id?: IntFilter<"Profiling"> | number
    session_id?: StringFilter<"Profiling"> | string
    cpu?: StringNullableFilter<"Profiling"> | string | null
    memory?: StringNullableFilter<"Profiling"> | string | null
    total_cpu_used?: StringNullableFilter<"Profiling"> | string | null
    total_memory_used?: StringNullableFilter<"Profiling"> | string | null
    raw_cpu_log?: StringNullableFilter<"Profiling"> | string | null
    raw_memory_log?: StringNullableFilter<"Profiling"> | string | null
    timestamp?: DateTimeFilter<"Profiling"> | Date | string
    createdAt?: DateTimeFilter<"Profiling"> | Date | string
    updatedAt?: DateTimeFilter<"Profiling"> | Date | string
  }

  export type BuildUpsertWithoutSessionsInput = {
    update: XOR<BuildUpdateWithoutSessionsInput, BuildUncheckedUpdateWithoutSessionsInput>
    create: XOR<BuildCreateWithoutSessionsInput, BuildUncheckedCreateWithoutSessionsInput>
    where?: BuildWhereInput
  }

  export type BuildUpdateToOneWithWhereWithoutSessionsInput = {
    where?: BuildWhereInput
    data: XOR<BuildUpdateWithoutSessionsInput, BuildUncheckedUpdateWithoutSessionsInput>
  }

  export type BuildUpdateWithoutSessionsInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type BuildUncheckedUpdateWithoutSessionsInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type SessionLogUpsertWithWhereUniqueWithoutSessionInput = {
    where: SessionLogWhereUniqueInput
    update: XOR<SessionLogUpdateWithoutSessionInput, SessionLogUncheckedUpdateWithoutSessionInput>
    create: XOR<SessionLogCreateWithoutSessionInput, SessionLogUncheckedCreateWithoutSessionInput>
  }

  export type SessionLogUpdateWithWhereUniqueWithoutSessionInput = {
    where: SessionLogWhereUniqueInput
    data: XOR<SessionLogUpdateWithoutSessionInput, SessionLogUncheckedUpdateWithoutSessionInput>
  }

  export type SessionLogUpdateManyWithWhereWithoutSessionInput = {
    where: SessionLogScalarWhereInput
    data: XOR<SessionLogUpdateManyMutationInput, SessionLogUncheckedUpdateManyWithoutSessionInput>
  }

  export type SessionLogScalarWhereInput = {
    AND?: SessionLogScalarWhereInput | SessionLogScalarWhereInput[]
    OR?: SessionLogScalarWhereInput[]
    NOT?: SessionLogScalarWhereInput | SessionLogScalarWhereInput[]
    id?: StringFilter<"SessionLog"> | string
    session_id?: StringFilter<"SessionLog"> | string
    command_name?: StringNullableFilter<"SessionLog"> | string | null
    url?: StringFilter<"SessionLog"> | string
    method?: StringFilter<"SessionLog"> | string
    title?: StringFilter<"SessionLog"> | string
    subtitle?: StringNullableFilter<"SessionLog"> | string | null
    body?: StringNullableFilter<"SessionLog"> | string | null
    response?: StringFilter<"SessionLog"> | string
    screenshot?: StringNullableFilter<"SessionLog"> | string | null
    is_success?: BoolNullableFilter<"SessionLog"> | boolean | null
    is_error?: BoolFilter<"SessionLog"> | boolean
    is_healed?: BoolFilter<"SessionLog"> | boolean
    original_selector?: StringNullableFilter<"SessionLog"> | string | null
    healed_selector?: StringNullableFilter<"SessionLog"> | string | null
    healing_confidence?: FloatNullableFilter<"SessionLog"> | number | null
    healing_tier?: StringNullableFilter<"SessionLog"> | string | null
    original_strategy?: StringNullableFilter<"SessionLog"> | string | null
    healed_strategy?: StringNullableFilter<"SessionLog"> | string | null
    createdAt?: DateTimeFilter<"SessionLog"> | Date | string
    updatedAt?: DateTimeFilter<"SessionLog"> | Date | string
    duration?: IntNullableFilter<"SessionLog"> | number | null
    span_id?: StringNullableFilter<"SessionLog"> | string | null
    trace_id?: StringNullableFilter<"SessionLog"> | string | null
  }

  export type RecordingUpsertWithWhereUniqueWithoutSessionInput = {
    where: RecordingWhereUniqueInput
    update: XOR<RecordingUpdateWithoutSessionInput, RecordingUncheckedUpdateWithoutSessionInput>
    create: XOR<RecordingCreateWithoutSessionInput, RecordingUncheckedCreateWithoutSessionInput>
  }

  export type RecordingUpdateWithWhereUniqueWithoutSessionInput = {
    where: RecordingWhereUniqueInput
    data: XOR<RecordingUpdateWithoutSessionInput, RecordingUncheckedUpdateWithoutSessionInput>
  }

  export type RecordingUpdateManyWithWhereWithoutSessionInput = {
    where: RecordingScalarWhereInput
    data: XOR<RecordingUpdateManyMutationInput, RecordingUncheckedUpdateManyWithoutSessionInput>
  }

  export type RecordingScalarWhereInput = {
    AND?: RecordingScalarWhereInput | RecordingScalarWhereInput[]
    OR?: RecordingScalarWhereInput[]
    NOT?: RecordingScalarWhereInput | RecordingScalarWhereInput[]
    id?: StringFilter<"Recording"> | string
    group_id?: StringFilter<"Recording"> | string
    device_udid?: StringFilter<"Recording"> | string
    device_host?: StringFilter<"Recording"> | string
    session_id?: StringNullableFilter<"Recording"> | string | null
    started_at?: DateTimeFilter<"Recording"> | Date | string
    ended_at?: DateTimeNullableFilter<"Recording"> | Date | string | null
    status?: StringFilter<"Recording"> | string
    file_path?: StringFilter<"Recording"> | string
    duration_ms?: IntNullableFilter<"Recording"> | number | null
    size_bytes?: IntNullableFilter<"Recording"> | number | null
    device_snapshot?: StringNullableFilter<"Recording"> | string | null
    fail_reason?: StringNullableFilter<"Recording"> | string | null
  }

  export type SessionCreateWithoutSessionLogInput = {
    id: string
    name?: string | null
    status?: string
    desired_capabilities: string
    session_capabilities: string
    node_id: string
    has_live_video: boolean
    video_recording_enabled?: boolean
    video_recording?: string | null
    startTime?: Date | string
    endTime?: Date | string | null
    failure_reason?: string | null
    is_profiling_available?: boolean
    device_info?: string | null
    device_udid: string
    device_platform: string
    device_version: string
    device_name?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    performance_trace?: string | null
    failure_category?: string | null
    ai_analysis?: string | null
    tags?: string | null
    trace_id?: string | null
    last_heartbeat_at?: Date | string | null
    heartbeat_pid?: number | null
    heartbeat_host?: string | null
    api_key_id?: string | null
    user_id?: string | null
    Log?: LogCreateNestedManyWithoutSessionInput
    Profiling?: ProfilingCreateNestedManyWithoutSessionInput
    build?: BuildCreateNestedOneWithoutSessionsInput
    Recording?: RecordingCreateNestedManyWithoutSessionInput
  }

  export type SessionUncheckedCreateWithoutSessionLogInput = {
    id: string
    build_id?: string | null
    name?: string | null
    status?: string
    desired_capabilities: string
    session_capabilities: string
    node_id: string
    has_live_video: boolean
    video_recording_enabled?: boolean
    video_recording?: string | null
    startTime?: Date | string
    endTime?: Date | string | null
    failure_reason?: string | null
    is_profiling_available?: boolean
    device_info?: string | null
    device_udid: string
    device_platform: string
    device_version: string
    device_name?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    performance_trace?: string | null
    failure_category?: string | null
    ai_analysis?: string | null
    tags?: string | null
    trace_id?: string | null
    last_heartbeat_at?: Date | string | null
    heartbeat_pid?: number | null
    heartbeat_host?: string | null
    api_key_id?: string | null
    user_id?: string | null
    Log?: LogUncheckedCreateNestedManyWithoutSessionInput
    Profiling?: ProfilingUncheckedCreateNestedManyWithoutSessionInput
    Recording?: RecordingUncheckedCreateNestedManyWithoutSessionInput
  }

  export type SessionCreateOrConnectWithoutSessionLogInput = {
    where: SessionWhereUniqueInput
    create: XOR<SessionCreateWithoutSessionLogInput, SessionUncheckedCreateWithoutSessionLogInput>
  }

  export type SessionUpsertWithoutSessionLogInput = {
    update: XOR<SessionUpdateWithoutSessionLogInput, SessionUncheckedUpdateWithoutSessionLogInput>
    create: XOR<SessionCreateWithoutSessionLogInput, SessionUncheckedCreateWithoutSessionLogInput>
    where?: SessionWhereInput
  }

  export type SessionUpdateToOneWithWhereWithoutSessionLogInput = {
    where?: SessionWhereInput
    data: XOR<SessionUpdateWithoutSessionLogInput, SessionUncheckedUpdateWithoutSessionLogInput>
  }

  export type SessionUpdateWithoutSessionLogInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: NullableStringFieldUpdateOperationsInput | string | null
    status?: StringFieldUpdateOperationsInput | string
    desired_capabilities?: StringFieldUpdateOperationsInput | string
    session_capabilities?: StringFieldUpdateOperationsInput | string
    node_id?: StringFieldUpdateOperationsInput | string
    has_live_video?: BoolFieldUpdateOperationsInput | boolean
    video_recording_enabled?: BoolFieldUpdateOperationsInput | boolean
    video_recording?: NullableStringFieldUpdateOperationsInput | string | null
    startTime?: DateTimeFieldUpdateOperationsInput | Date | string
    endTime?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    failure_reason?: NullableStringFieldUpdateOperationsInput | string | null
    is_profiling_available?: BoolFieldUpdateOperationsInput | boolean
    device_info?: NullableStringFieldUpdateOperationsInput | string | null
    device_udid?: StringFieldUpdateOperationsInput | string
    device_platform?: StringFieldUpdateOperationsInput | string
    device_version?: StringFieldUpdateOperationsInput | string
    device_name?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    performance_trace?: NullableStringFieldUpdateOperationsInput | string | null
    failure_category?: NullableStringFieldUpdateOperationsInput | string | null
    ai_analysis?: NullableStringFieldUpdateOperationsInput | string | null
    tags?: NullableStringFieldUpdateOperationsInput | string | null
    trace_id?: NullableStringFieldUpdateOperationsInput | string | null
    last_heartbeat_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    heartbeat_pid?: NullableIntFieldUpdateOperationsInput | number | null
    heartbeat_host?: NullableStringFieldUpdateOperationsInput | string | null
    api_key_id?: NullableStringFieldUpdateOperationsInput | string | null
    user_id?: NullableStringFieldUpdateOperationsInput | string | null
    Log?: LogUpdateManyWithoutSessionNestedInput
    Profiling?: ProfilingUpdateManyWithoutSessionNestedInput
    build?: BuildUpdateOneWithoutSessionsNestedInput
    Recording?: RecordingUpdateManyWithoutSessionNestedInput
  }

  export type SessionUncheckedUpdateWithoutSessionLogInput = {
    id?: StringFieldUpdateOperationsInput | string
    build_id?: NullableStringFieldUpdateOperationsInput | string | null
    name?: NullableStringFieldUpdateOperationsInput | string | null
    status?: StringFieldUpdateOperationsInput | string
    desired_capabilities?: StringFieldUpdateOperationsInput | string
    session_capabilities?: StringFieldUpdateOperationsInput | string
    node_id?: StringFieldUpdateOperationsInput | string
    has_live_video?: BoolFieldUpdateOperationsInput | boolean
    video_recording_enabled?: BoolFieldUpdateOperationsInput | boolean
    video_recording?: NullableStringFieldUpdateOperationsInput | string | null
    startTime?: DateTimeFieldUpdateOperationsInput | Date | string
    endTime?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    failure_reason?: NullableStringFieldUpdateOperationsInput | string | null
    is_profiling_available?: BoolFieldUpdateOperationsInput | boolean
    device_info?: NullableStringFieldUpdateOperationsInput | string | null
    device_udid?: StringFieldUpdateOperationsInput | string
    device_platform?: StringFieldUpdateOperationsInput | string
    device_version?: StringFieldUpdateOperationsInput | string
    device_name?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    performance_trace?: NullableStringFieldUpdateOperationsInput | string | null
    failure_category?: NullableStringFieldUpdateOperationsInput | string | null
    ai_analysis?: NullableStringFieldUpdateOperationsInput | string | null
    tags?: NullableStringFieldUpdateOperationsInput | string | null
    trace_id?: NullableStringFieldUpdateOperationsInput | string | null
    last_heartbeat_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    heartbeat_pid?: NullableIntFieldUpdateOperationsInput | number | null
    heartbeat_host?: NullableStringFieldUpdateOperationsInput | string | null
    api_key_id?: NullableStringFieldUpdateOperationsInput | string | null
    user_id?: NullableStringFieldUpdateOperationsInput | string | null
    Log?: LogUncheckedUpdateManyWithoutSessionNestedInput
    Profiling?: ProfilingUncheckedUpdateManyWithoutSessionNestedInput
    Recording?: RecordingUncheckedUpdateManyWithoutSessionNestedInput
  }

  export type SessionCreateWithoutLogInput = {
    id: string
    name?: string | null
    status?: string
    desired_capabilities: string
    session_capabilities: string
    node_id: string
    has_live_video: boolean
    video_recording_enabled?: boolean
    video_recording?: string | null
    startTime?: Date | string
    endTime?: Date | string | null
    failure_reason?: string | null
    is_profiling_available?: boolean
    device_info?: string | null
    device_udid: string
    device_platform: string
    device_version: string
    device_name?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    performance_trace?: string | null
    failure_category?: string | null
    ai_analysis?: string | null
    tags?: string | null
    trace_id?: string | null
    last_heartbeat_at?: Date | string | null
    heartbeat_pid?: number | null
    heartbeat_host?: string | null
    api_key_id?: string | null
    user_id?: string | null
    Profiling?: ProfilingCreateNestedManyWithoutSessionInput
    build?: BuildCreateNestedOneWithoutSessionsInput
    SessionLog?: SessionLogCreateNestedManyWithoutSessionInput
    Recording?: RecordingCreateNestedManyWithoutSessionInput
  }

  export type SessionUncheckedCreateWithoutLogInput = {
    id: string
    build_id?: string | null
    name?: string | null
    status?: string
    desired_capabilities: string
    session_capabilities: string
    node_id: string
    has_live_video: boolean
    video_recording_enabled?: boolean
    video_recording?: string | null
    startTime?: Date | string
    endTime?: Date | string | null
    failure_reason?: string | null
    is_profiling_available?: boolean
    device_info?: string | null
    device_udid: string
    device_platform: string
    device_version: string
    device_name?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    performance_trace?: string | null
    failure_category?: string | null
    ai_analysis?: string | null
    tags?: string | null
    trace_id?: string | null
    last_heartbeat_at?: Date | string | null
    heartbeat_pid?: number | null
    heartbeat_host?: string | null
    api_key_id?: string | null
    user_id?: string | null
    Profiling?: ProfilingUncheckedCreateNestedManyWithoutSessionInput
    SessionLog?: SessionLogUncheckedCreateNestedManyWithoutSessionInput
    Recording?: RecordingUncheckedCreateNestedManyWithoutSessionInput
  }

  export type SessionCreateOrConnectWithoutLogInput = {
    where: SessionWhereUniqueInput
    create: XOR<SessionCreateWithoutLogInput, SessionUncheckedCreateWithoutLogInput>
  }

  export type SessionUpsertWithoutLogInput = {
    update: XOR<SessionUpdateWithoutLogInput, SessionUncheckedUpdateWithoutLogInput>
    create: XOR<SessionCreateWithoutLogInput, SessionUncheckedCreateWithoutLogInput>
    where?: SessionWhereInput
  }

  export type SessionUpdateToOneWithWhereWithoutLogInput = {
    where?: SessionWhereInput
    data: XOR<SessionUpdateWithoutLogInput, SessionUncheckedUpdateWithoutLogInput>
  }

  export type SessionUpdateWithoutLogInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: NullableStringFieldUpdateOperationsInput | string | null
    status?: StringFieldUpdateOperationsInput | string
    desired_capabilities?: StringFieldUpdateOperationsInput | string
    session_capabilities?: StringFieldUpdateOperationsInput | string
    node_id?: StringFieldUpdateOperationsInput | string
    has_live_video?: BoolFieldUpdateOperationsInput | boolean
    video_recording_enabled?: BoolFieldUpdateOperationsInput | boolean
    video_recording?: NullableStringFieldUpdateOperationsInput | string | null
    startTime?: DateTimeFieldUpdateOperationsInput | Date | string
    endTime?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    failure_reason?: NullableStringFieldUpdateOperationsInput | string | null
    is_profiling_available?: BoolFieldUpdateOperationsInput | boolean
    device_info?: NullableStringFieldUpdateOperationsInput | string | null
    device_udid?: StringFieldUpdateOperationsInput | string
    device_platform?: StringFieldUpdateOperationsInput | string
    device_version?: StringFieldUpdateOperationsInput | string
    device_name?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    performance_trace?: NullableStringFieldUpdateOperationsInput | string | null
    failure_category?: NullableStringFieldUpdateOperationsInput | string | null
    ai_analysis?: NullableStringFieldUpdateOperationsInput | string | null
    tags?: NullableStringFieldUpdateOperationsInput | string | null
    trace_id?: NullableStringFieldUpdateOperationsInput | string | null
    last_heartbeat_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    heartbeat_pid?: NullableIntFieldUpdateOperationsInput | number | null
    heartbeat_host?: NullableStringFieldUpdateOperationsInput | string | null
    api_key_id?: NullableStringFieldUpdateOperationsInput | string | null
    user_id?: NullableStringFieldUpdateOperationsInput | string | null
    Profiling?: ProfilingUpdateManyWithoutSessionNestedInput
    build?: BuildUpdateOneWithoutSessionsNestedInput
    SessionLog?: SessionLogUpdateManyWithoutSessionNestedInput
    Recording?: RecordingUpdateManyWithoutSessionNestedInput
  }

  export type SessionUncheckedUpdateWithoutLogInput = {
    id?: StringFieldUpdateOperationsInput | string
    build_id?: NullableStringFieldUpdateOperationsInput | string | null
    name?: NullableStringFieldUpdateOperationsInput | string | null
    status?: StringFieldUpdateOperationsInput | string
    desired_capabilities?: StringFieldUpdateOperationsInput | string
    session_capabilities?: StringFieldUpdateOperationsInput | string
    node_id?: StringFieldUpdateOperationsInput | string
    has_live_video?: BoolFieldUpdateOperationsInput | boolean
    video_recording_enabled?: BoolFieldUpdateOperationsInput | boolean
    video_recording?: NullableStringFieldUpdateOperationsInput | string | null
    startTime?: DateTimeFieldUpdateOperationsInput | Date | string
    endTime?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    failure_reason?: NullableStringFieldUpdateOperationsInput | string | null
    is_profiling_available?: BoolFieldUpdateOperationsInput | boolean
    device_info?: NullableStringFieldUpdateOperationsInput | string | null
    device_udid?: StringFieldUpdateOperationsInput | string
    device_platform?: StringFieldUpdateOperationsInput | string
    device_version?: StringFieldUpdateOperationsInput | string
    device_name?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    performance_trace?: NullableStringFieldUpdateOperationsInput | string | null
    failure_category?: NullableStringFieldUpdateOperationsInput | string | null
    ai_analysis?: NullableStringFieldUpdateOperationsInput | string | null
    tags?: NullableStringFieldUpdateOperationsInput | string | null
    trace_id?: NullableStringFieldUpdateOperationsInput | string | null
    last_heartbeat_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    heartbeat_pid?: NullableIntFieldUpdateOperationsInput | number | null
    heartbeat_host?: NullableStringFieldUpdateOperationsInput | string | null
    api_key_id?: NullableStringFieldUpdateOperationsInput | string | null
    user_id?: NullableStringFieldUpdateOperationsInput | string | null
    Profiling?: ProfilingUncheckedUpdateManyWithoutSessionNestedInput
    SessionLog?: SessionLogUncheckedUpdateManyWithoutSessionNestedInput
    Recording?: RecordingUncheckedUpdateManyWithoutSessionNestedInput
  }

  export type SessionCreateWithoutProfilingInput = {
    id: string
    name?: string | null
    status?: string
    desired_capabilities: string
    session_capabilities: string
    node_id: string
    has_live_video: boolean
    video_recording_enabled?: boolean
    video_recording?: string | null
    startTime?: Date | string
    endTime?: Date | string | null
    failure_reason?: string | null
    is_profiling_available?: boolean
    device_info?: string | null
    device_udid: string
    device_platform: string
    device_version: string
    device_name?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    performance_trace?: string | null
    failure_category?: string | null
    ai_analysis?: string | null
    tags?: string | null
    trace_id?: string | null
    last_heartbeat_at?: Date | string | null
    heartbeat_pid?: number | null
    heartbeat_host?: string | null
    api_key_id?: string | null
    user_id?: string | null
    Log?: LogCreateNestedManyWithoutSessionInput
    build?: BuildCreateNestedOneWithoutSessionsInput
    SessionLog?: SessionLogCreateNestedManyWithoutSessionInput
    Recording?: RecordingCreateNestedManyWithoutSessionInput
  }

  export type SessionUncheckedCreateWithoutProfilingInput = {
    id: string
    build_id?: string | null
    name?: string | null
    status?: string
    desired_capabilities: string
    session_capabilities: string
    node_id: string
    has_live_video: boolean
    video_recording_enabled?: boolean
    video_recording?: string | null
    startTime?: Date | string
    endTime?: Date | string | null
    failure_reason?: string | null
    is_profiling_available?: boolean
    device_info?: string | null
    device_udid: string
    device_platform: string
    device_version: string
    device_name?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    performance_trace?: string | null
    failure_category?: string | null
    ai_analysis?: string | null
    tags?: string | null
    trace_id?: string | null
    last_heartbeat_at?: Date | string | null
    heartbeat_pid?: number | null
    heartbeat_host?: string | null
    api_key_id?: string | null
    user_id?: string | null
    Log?: LogUncheckedCreateNestedManyWithoutSessionInput
    SessionLog?: SessionLogUncheckedCreateNestedManyWithoutSessionInput
    Recording?: RecordingUncheckedCreateNestedManyWithoutSessionInput
  }

  export type SessionCreateOrConnectWithoutProfilingInput = {
    where: SessionWhereUniqueInput
    create: XOR<SessionCreateWithoutProfilingInput, SessionUncheckedCreateWithoutProfilingInput>
  }

  export type SessionUpsertWithoutProfilingInput = {
    update: XOR<SessionUpdateWithoutProfilingInput, SessionUncheckedUpdateWithoutProfilingInput>
    create: XOR<SessionCreateWithoutProfilingInput, SessionUncheckedCreateWithoutProfilingInput>
    where?: SessionWhereInput
  }

  export type SessionUpdateToOneWithWhereWithoutProfilingInput = {
    where?: SessionWhereInput
    data: XOR<SessionUpdateWithoutProfilingInput, SessionUncheckedUpdateWithoutProfilingInput>
  }

  export type SessionUpdateWithoutProfilingInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: NullableStringFieldUpdateOperationsInput | string | null
    status?: StringFieldUpdateOperationsInput | string
    desired_capabilities?: StringFieldUpdateOperationsInput | string
    session_capabilities?: StringFieldUpdateOperationsInput | string
    node_id?: StringFieldUpdateOperationsInput | string
    has_live_video?: BoolFieldUpdateOperationsInput | boolean
    video_recording_enabled?: BoolFieldUpdateOperationsInput | boolean
    video_recording?: NullableStringFieldUpdateOperationsInput | string | null
    startTime?: DateTimeFieldUpdateOperationsInput | Date | string
    endTime?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    failure_reason?: NullableStringFieldUpdateOperationsInput | string | null
    is_profiling_available?: BoolFieldUpdateOperationsInput | boolean
    device_info?: NullableStringFieldUpdateOperationsInput | string | null
    device_udid?: StringFieldUpdateOperationsInput | string
    device_platform?: StringFieldUpdateOperationsInput | string
    device_version?: StringFieldUpdateOperationsInput | string
    device_name?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    performance_trace?: NullableStringFieldUpdateOperationsInput | string | null
    failure_category?: NullableStringFieldUpdateOperationsInput | string | null
    ai_analysis?: NullableStringFieldUpdateOperationsInput | string | null
    tags?: NullableStringFieldUpdateOperationsInput | string | null
    trace_id?: NullableStringFieldUpdateOperationsInput | string | null
    last_heartbeat_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    heartbeat_pid?: NullableIntFieldUpdateOperationsInput | number | null
    heartbeat_host?: NullableStringFieldUpdateOperationsInput | string | null
    api_key_id?: NullableStringFieldUpdateOperationsInput | string | null
    user_id?: NullableStringFieldUpdateOperationsInput | string | null
    Log?: LogUpdateManyWithoutSessionNestedInput
    build?: BuildUpdateOneWithoutSessionsNestedInput
    SessionLog?: SessionLogUpdateManyWithoutSessionNestedInput
    Recording?: RecordingUpdateManyWithoutSessionNestedInput
  }

  export type SessionUncheckedUpdateWithoutProfilingInput = {
    id?: StringFieldUpdateOperationsInput | string
    build_id?: NullableStringFieldUpdateOperationsInput | string | null
    name?: NullableStringFieldUpdateOperationsInput | string | null
    status?: StringFieldUpdateOperationsInput | string
    desired_capabilities?: StringFieldUpdateOperationsInput | string
    session_capabilities?: StringFieldUpdateOperationsInput | string
    node_id?: StringFieldUpdateOperationsInput | string
    has_live_video?: BoolFieldUpdateOperationsInput | boolean
    video_recording_enabled?: BoolFieldUpdateOperationsInput | boolean
    video_recording?: NullableStringFieldUpdateOperationsInput | string | null
    startTime?: DateTimeFieldUpdateOperationsInput | Date | string
    endTime?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    failure_reason?: NullableStringFieldUpdateOperationsInput | string | null
    is_profiling_available?: BoolFieldUpdateOperationsInput | boolean
    device_info?: NullableStringFieldUpdateOperationsInput | string | null
    device_udid?: StringFieldUpdateOperationsInput | string
    device_platform?: StringFieldUpdateOperationsInput | string
    device_version?: StringFieldUpdateOperationsInput | string
    device_name?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    performance_trace?: NullableStringFieldUpdateOperationsInput | string | null
    failure_category?: NullableStringFieldUpdateOperationsInput | string | null
    ai_analysis?: NullableStringFieldUpdateOperationsInput | string | null
    tags?: NullableStringFieldUpdateOperationsInput | string | null
    trace_id?: NullableStringFieldUpdateOperationsInput | string | null
    last_heartbeat_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    heartbeat_pid?: NullableIntFieldUpdateOperationsInput | number | null
    heartbeat_host?: NullableStringFieldUpdateOperationsInput | string | null
    api_key_id?: NullableStringFieldUpdateOperationsInput | string | null
    user_id?: NullableStringFieldUpdateOperationsInput | string | null
    Log?: LogUncheckedUpdateManyWithoutSessionNestedInput
    SessionLog?: SessionLogUncheckedUpdateManyWithoutSessionNestedInput
    Recording?: RecordingUncheckedUpdateManyWithoutSessionNestedInput
  }

  export type TeamCreateWithoutDevicesInput = {
    id?: string
    name: string
    createdAt?: Date | string
    apiKeys?: ApiKeyCreateNestedManyWithoutTeamInput
    members?: TeamMemberCreateNestedManyWithoutTeamInput
  }

  export type TeamUncheckedCreateWithoutDevicesInput = {
    id?: string
    name: string
    createdAt?: Date | string
    apiKeys?: ApiKeyUncheckedCreateNestedManyWithoutTeamInput
    members?: TeamMemberUncheckedCreateNestedManyWithoutTeamInput
  }

  export type TeamCreateOrConnectWithoutDevicesInput = {
    where: TeamWhereUniqueInput
    create: XOR<TeamCreateWithoutDevicesInput, TeamUncheckedCreateWithoutDevicesInput>
  }

  export type TeamUpsertWithoutDevicesInput = {
    update: XOR<TeamUpdateWithoutDevicesInput, TeamUncheckedUpdateWithoutDevicesInput>
    create: XOR<TeamCreateWithoutDevicesInput, TeamUncheckedCreateWithoutDevicesInput>
    where?: TeamWhereInput
  }

  export type TeamUpdateToOneWithWhereWithoutDevicesInput = {
    where?: TeamWhereInput
    data: XOR<TeamUpdateWithoutDevicesInput, TeamUncheckedUpdateWithoutDevicesInput>
  }

  export type TeamUpdateWithoutDevicesInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    apiKeys?: ApiKeyUpdateManyWithoutTeamNestedInput
    members?: TeamMemberUpdateManyWithoutTeamNestedInput
  }

  export type TeamUncheckedUpdateWithoutDevicesInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    apiKeys?: ApiKeyUncheckedUpdateManyWithoutTeamNestedInput
    members?: TeamMemberUncheckedUpdateManyWithoutTeamNestedInput
  }

  export type TeamCreateWithoutApiKeysInput = {
    id?: string
    name: string
    createdAt?: Date | string
    devices?: DeviceCreateNestedManyWithoutTeamInput
    members?: TeamMemberCreateNestedManyWithoutTeamInput
  }

  export type TeamUncheckedCreateWithoutApiKeysInput = {
    id?: string
    name: string
    createdAt?: Date | string
    devices?: DeviceUncheckedCreateNestedManyWithoutTeamInput
    members?: TeamMemberUncheckedCreateNestedManyWithoutTeamInput
  }

  export type TeamCreateOrConnectWithoutApiKeysInput = {
    where: TeamWhereUniqueInput
    create: XOR<TeamCreateWithoutApiKeysInput, TeamUncheckedCreateWithoutApiKeysInput>
  }

  export type UserCreateWithoutApiKeysInput = {
    id?: string
    email: string
    name: string
    passwordHash: string
    accessKey: string
    role?: string
    status?: string
    createdAt?: Date | string
    updatedAt?: Date | string
    lastLoginAt?: Date | string | null
    passwordChangedAt?: Date | string | null
    sessions?: UserSessionCreateNestedManyWithoutUserInput
    passwordResetTokens?: PasswordResetTokenCreateNestedManyWithoutUserInput
    teamMemberships?: TeamMemberCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutApiKeysInput = {
    id?: string
    email: string
    name: string
    passwordHash: string
    accessKey: string
    role?: string
    status?: string
    createdAt?: Date | string
    updatedAt?: Date | string
    lastLoginAt?: Date | string | null
    passwordChangedAt?: Date | string | null
    sessions?: UserSessionUncheckedCreateNestedManyWithoutUserInput
    passwordResetTokens?: PasswordResetTokenUncheckedCreateNestedManyWithoutUserInput
    teamMemberships?: TeamMemberUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutApiKeysInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutApiKeysInput, UserUncheckedCreateWithoutApiKeysInput>
  }

  export type TeamUpsertWithoutApiKeysInput = {
    update: XOR<TeamUpdateWithoutApiKeysInput, TeamUncheckedUpdateWithoutApiKeysInput>
    create: XOR<TeamCreateWithoutApiKeysInput, TeamUncheckedCreateWithoutApiKeysInput>
    where?: TeamWhereInput
  }

  export type TeamUpdateToOneWithWhereWithoutApiKeysInput = {
    where?: TeamWhereInput
    data: XOR<TeamUpdateWithoutApiKeysInput, TeamUncheckedUpdateWithoutApiKeysInput>
  }

  export type TeamUpdateWithoutApiKeysInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    devices?: DeviceUpdateManyWithoutTeamNestedInput
    members?: TeamMemberUpdateManyWithoutTeamNestedInput
  }

  export type TeamUncheckedUpdateWithoutApiKeysInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    devices?: DeviceUncheckedUpdateManyWithoutTeamNestedInput
    members?: TeamMemberUncheckedUpdateManyWithoutTeamNestedInput
  }

  export type UserUpsertWithoutApiKeysInput = {
    update: XOR<UserUpdateWithoutApiKeysInput, UserUncheckedUpdateWithoutApiKeysInput>
    create: XOR<UserCreateWithoutApiKeysInput, UserUncheckedCreateWithoutApiKeysInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutApiKeysInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutApiKeysInput, UserUncheckedUpdateWithoutApiKeysInput>
  }

  export type UserUpdateWithoutApiKeysInput = {
    id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    passwordHash?: StringFieldUpdateOperationsInput | string
    accessKey?: StringFieldUpdateOperationsInput | string
    role?: StringFieldUpdateOperationsInput | string
    status?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    lastLoginAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    passwordChangedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    sessions?: UserSessionUpdateManyWithoutUserNestedInput
    passwordResetTokens?: PasswordResetTokenUpdateManyWithoutUserNestedInput
    teamMemberships?: TeamMemberUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutApiKeysInput = {
    id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    passwordHash?: StringFieldUpdateOperationsInput | string
    accessKey?: StringFieldUpdateOperationsInput | string
    role?: StringFieldUpdateOperationsInput | string
    status?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    lastLoginAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    passwordChangedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    sessions?: UserSessionUncheckedUpdateManyWithoutUserNestedInput
    passwordResetTokens?: PasswordResetTokenUncheckedUpdateManyWithoutUserNestedInput
    teamMemberships?: TeamMemberUncheckedUpdateManyWithoutUserNestedInput
  }

  export type DeviceCreateWithoutTeamInput = {
    udid: string
    host: string
    systemPort?: number | null
    proxyPort?: number | null
    proxyHost?: string | null
    wdaLocalPort?: number | null
    name?: string | null
    state?: string | null
    sdk?: string | null
    platform?: string | null
    deviceType?: string | null
    busy?: boolean | null
    userBlocked?: boolean | null
    realDevice?: boolean | null
    session_id?: string | null
    offline?: boolean | null
    mjpegServerPort?: number | null
    lastCmdExecutedAt?: number | null
    totalUtilizationTimeMilliSec?: number
    sessionStartTime?: number
    newCommandTimeout?: number | null
    cloud?: string | null
    derivedDataPath?: string | null
    chromeDriverPath?: string | null
    capability?: string | null
    adbRemoteHost?: string | null
    adbPort?: number | null
    nodeId?: string | null
    screenWidth?: string | null
    screenHeight?: string | null
    dashboard_link?: string | null
    total_session_count?: number | null
    createdAt?: Date | string
    updatedAt?: Date | string
    healthCheckError?: string | null
    healthStatus?: string | null
    lastHealthCheckAt?: number | null
    batteryLevel?: number | null
    reservationReason?: string | null
    reservedBy?: string | null
    reservedUntil?: number | null
    storageFree?: string | null
    tags?: string | null
    thermalStatus?: string | null
    sessionProgress?: string | null
    totalHealedCount?: number | null
    ip?: string | null
    cpuArchitecture?: string | null
    owningSessionId?: string | null
    lockedAt?: number | null
  }

  export type DeviceUncheckedCreateWithoutTeamInput = {
    udid: string
    host: string
    systemPort?: number | null
    proxyPort?: number | null
    proxyHost?: string | null
    wdaLocalPort?: number | null
    name?: string | null
    state?: string | null
    sdk?: string | null
    platform?: string | null
    deviceType?: string | null
    busy?: boolean | null
    userBlocked?: boolean | null
    realDevice?: boolean | null
    session_id?: string | null
    offline?: boolean | null
    mjpegServerPort?: number | null
    lastCmdExecutedAt?: number | null
    totalUtilizationTimeMilliSec?: number
    sessionStartTime?: number
    newCommandTimeout?: number | null
    cloud?: string | null
    derivedDataPath?: string | null
    chromeDriverPath?: string | null
    capability?: string | null
    adbRemoteHost?: string | null
    adbPort?: number | null
    nodeId?: string | null
    screenWidth?: string | null
    screenHeight?: string | null
    dashboard_link?: string | null
    total_session_count?: number | null
    createdAt?: Date | string
    updatedAt?: Date | string
    healthCheckError?: string | null
    healthStatus?: string | null
    lastHealthCheckAt?: number | null
    batteryLevel?: number | null
    reservationReason?: string | null
    reservedBy?: string | null
    reservedUntil?: number | null
    storageFree?: string | null
    tags?: string | null
    thermalStatus?: string | null
    sessionProgress?: string | null
    totalHealedCount?: number | null
    ip?: string | null
    cpuArchitecture?: string | null
    owningSessionId?: string | null
    lockedAt?: number | null
  }

  export type DeviceCreateOrConnectWithoutTeamInput = {
    where: DeviceWhereUniqueInput
    create: XOR<DeviceCreateWithoutTeamInput, DeviceUncheckedCreateWithoutTeamInput>
  }

  export type DeviceCreateManyTeamInputEnvelope = {
    data: DeviceCreateManyTeamInput | DeviceCreateManyTeamInput[]
  }

  export type ApiKeyCreateWithoutTeamInput = {
    id?: string
    name: string
    keyHash: string
    scopes: string
    rateLimit?: number
    createdAt?: Date | string
    revokedAt?: Date | string | null
    lastUsedAt?: Date | string | null
    expiresAt?: Date | string | null
    role?: string
    user: UserCreateNestedOneWithoutApiKeysInput
  }

  export type ApiKeyUncheckedCreateWithoutTeamInput = {
    id?: string
    name: string
    keyHash: string
    scopes: string
    rateLimit?: number
    createdAt?: Date | string
    revokedAt?: Date | string | null
    lastUsedAt?: Date | string | null
    expiresAt?: Date | string | null
    role?: string
    userId: string
  }

  export type ApiKeyCreateOrConnectWithoutTeamInput = {
    where: ApiKeyWhereUniqueInput
    create: XOR<ApiKeyCreateWithoutTeamInput, ApiKeyUncheckedCreateWithoutTeamInput>
  }

  export type ApiKeyCreateManyTeamInputEnvelope = {
    data: ApiKeyCreateManyTeamInput | ApiKeyCreateManyTeamInput[]
  }

  export type TeamMemberCreateWithoutTeamInput = {
    createdAt?: Date | string
    user: UserCreateNestedOneWithoutTeamMembershipsInput
  }

  export type TeamMemberUncheckedCreateWithoutTeamInput = {
    userId: string
    createdAt?: Date | string
  }

  export type TeamMemberCreateOrConnectWithoutTeamInput = {
    where: TeamMemberWhereUniqueInput
    create: XOR<TeamMemberCreateWithoutTeamInput, TeamMemberUncheckedCreateWithoutTeamInput>
  }

  export type TeamMemberCreateManyTeamInputEnvelope = {
    data: TeamMemberCreateManyTeamInput | TeamMemberCreateManyTeamInput[]
  }

  export type DeviceUpsertWithWhereUniqueWithoutTeamInput = {
    where: DeviceWhereUniqueInput
    update: XOR<DeviceUpdateWithoutTeamInput, DeviceUncheckedUpdateWithoutTeamInput>
    create: XOR<DeviceCreateWithoutTeamInput, DeviceUncheckedCreateWithoutTeamInput>
  }

  export type DeviceUpdateWithWhereUniqueWithoutTeamInput = {
    where: DeviceWhereUniqueInput
    data: XOR<DeviceUpdateWithoutTeamInput, DeviceUncheckedUpdateWithoutTeamInput>
  }

  export type DeviceUpdateManyWithWhereWithoutTeamInput = {
    where: DeviceScalarWhereInput
    data: XOR<DeviceUpdateManyMutationInput, DeviceUncheckedUpdateManyWithoutTeamInput>
  }

  export type DeviceScalarWhereInput = {
    AND?: DeviceScalarWhereInput | DeviceScalarWhereInput[]
    OR?: DeviceScalarWhereInput[]
    NOT?: DeviceScalarWhereInput | DeviceScalarWhereInput[]
    udid?: StringFilter<"Device"> | string
    host?: StringFilter<"Device"> | string
    systemPort?: IntNullableFilter<"Device"> | number | null
    proxyPort?: IntNullableFilter<"Device"> | number | null
    proxyHost?: StringNullableFilter<"Device"> | string | null
    wdaLocalPort?: IntNullableFilter<"Device"> | number | null
    name?: StringNullableFilter<"Device"> | string | null
    state?: StringNullableFilter<"Device"> | string | null
    sdk?: StringNullableFilter<"Device"> | string | null
    platform?: StringNullableFilter<"Device"> | string | null
    deviceType?: StringNullableFilter<"Device"> | string | null
    busy?: BoolNullableFilter<"Device"> | boolean | null
    userBlocked?: BoolNullableFilter<"Device"> | boolean | null
    realDevice?: BoolNullableFilter<"Device"> | boolean | null
    session_id?: StringNullableFilter<"Device"> | string | null
    offline?: BoolNullableFilter<"Device"> | boolean | null
    mjpegServerPort?: IntNullableFilter<"Device"> | number | null
    lastCmdExecutedAt?: FloatNullableFilter<"Device"> | number | null
    totalUtilizationTimeMilliSec?: FloatFilter<"Device"> | number
    sessionStartTime?: FloatFilter<"Device"> | number
    newCommandTimeout?: IntNullableFilter<"Device"> | number | null
    cloud?: StringNullableFilter<"Device"> | string | null
    derivedDataPath?: StringNullableFilter<"Device"> | string | null
    chromeDriverPath?: StringNullableFilter<"Device"> | string | null
    capability?: StringNullableFilter<"Device"> | string | null
    adbRemoteHost?: StringNullableFilter<"Device"> | string | null
    adbPort?: IntNullableFilter<"Device"> | number | null
    nodeId?: StringNullableFilter<"Device"> | string | null
    screenWidth?: StringNullableFilter<"Device"> | string | null
    screenHeight?: StringNullableFilter<"Device"> | string | null
    dashboard_link?: StringNullableFilter<"Device"> | string | null
    total_session_count?: IntNullableFilter<"Device"> | number | null
    createdAt?: DateTimeFilter<"Device"> | Date | string
    updatedAt?: DateTimeFilter<"Device"> | Date | string
    healthCheckError?: StringNullableFilter<"Device"> | string | null
    healthStatus?: StringNullableFilter<"Device"> | string | null
    lastHealthCheckAt?: FloatNullableFilter<"Device"> | number | null
    batteryLevel?: IntNullableFilter<"Device"> | number | null
    reservationReason?: StringNullableFilter<"Device"> | string | null
    reservedBy?: StringNullableFilter<"Device"> | string | null
    reservedUntil?: FloatNullableFilter<"Device"> | number | null
    storageFree?: StringNullableFilter<"Device"> | string | null
    tags?: StringNullableFilter<"Device"> | string | null
    thermalStatus?: StringNullableFilter<"Device"> | string | null
    sessionProgress?: StringNullableFilter<"Device"> | string | null
    totalHealedCount?: IntNullableFilter<"Device"> | number | null
    ip?: StringNullableFilter<"Device"> | string | null
    cpuArchitecture?: StringNullableFilter<"Device"> | string | null
    owningSessionId?: StringNullableFilter<"Device"> | string | null
    lockedAt?: FloatNullableFilter<"Device"> | number | null
    teamId?: StringNullableFilter<"Device"> | string | null
  }

  export type ApiKeyUpsertWithWhereUniqueWithoutTeamInput = {
    where: ApiKeyWhereUniqueInput
    update: XOR<ApiKeyUpdateWithoutTeamInput, ApiKeyUncheckedUpdateWithoutTeamInput>
    create: XOR<ApiKeyCreateWithoutTeamInput, ApiKeyUncheckedCreateWithoutTeamInput>
  }

  export type ApiKeyUpdateWithWhereUniqueWithoutTeamInput = {
    where: ApiKeyWhereUniqueInput
    data: XOR<ApiKeyUpdateWithoutTeamInput, ApiKeyUncheckedUpdateWithoutTeamInput>
  }

  export type ApiKeyUpdateManyWithWhereWithoutTeamInput = {
    where: ApiKeyScalarWhereInput
    data: XOR<ApiKeyUpdateManyMutationInput, ApiKeyUncheckedUpdateManyWithoutTeamInput>
  }

  export type ApiKeyScalarWhereInput = {
    AND?: ApiKeyScalarWhereInput | ApiKeyScalarWhereInput[]
    OR?: ApiKeyScalarWhereInput[]
    NOT?: ApiKeyScalarWhereInput | ApiKeyScalarWhereInput[]
    id?: StringFilter<"ApiKey"> | string
    name?: StringFilter<"ApiKey"> | string
    keyHash?: StringFilter<"ApiKey"> | string
    scopes?: StringFilter<"ApiKey"> | string
    rateLimit?: IntFilter<"ApiKey"> | number
    createdAt?: DateTimeFilter<"ApiKey"> | Date | string
    revokedAt?: DateTimeNullableFilter<"ApiKey"> | Date | string | null
    lastUsedAt?: DateTimeNullableFilter<"ApiKey"> | Date | string | null
    expiresAt?: DateTimeNullableFilter<"ApiKey"> | Date | string | null
    teamId?: StringNullableFilter<"ApiKey"> | string | null
    role?: StringFilter<"ApiKey"> | string
    userId?: StringFilter<"ApiKey"> | string
  }

  export type TeamMemberUpsertWithWhereUniqueWithoutTeamInput = {
    where: TeamMemberWhereUniqueInput
    update: XOR<TeamMemberUpdateWithoutTeamInput, TeamMemberUncheckedUpdateWithoutTeamInput>
    create: XOR<TeamMemberCreateWithoutTeamInput, TeamMemberUncheckedCreateWithoutTeamInput>
  }

  export type TeamMemberUpdateWithWhereUniqueWithoutTeamInput = {
    where: TeamMemberWhereUniqueInput
    data: XOR<TeamMemberUpdateWithoutTeamInput, TeamMemberUncheckedUpdateWithoutTeamInput>
  }

  export type TeamMemberUpdateManyWithWhereWithoutTeamInput = {
    where: TeamMemberScalarWhereInput
    data: XOR<TeamMemberUpdateManyMutationInput, TeamMemberUncheckedUpdateManyWithoutTeamInput>
  }

  export type TeamMemberScalarWhereInput = {
    AND?: TeamMemberScalarWhereInput | TeamMemberScalarWhereInput[]
    OR?: TeamMemberScalarWhereInput[]
    NOT?: TeamMemberScalarWhereInput | TeamMemberScalarWhereInput[]
    teamId?: StringFilter<"TeamMember"> | string
    userId?: StringFilter<"TeamMember"> | string
    createdAt?: DateTimeFilter<"TeamMember"> | Date | string
  }

  export type BookmarkCreateWithoutRecordingInput = {
    id?: string
    timecode_ms: number
    label: string
    note?: string | null
    created_at?: Date | string
  }

  export type BookmarkUncheckedCreateWithoutRecordingInput = {
    id?: string
    timecode_ms: number
    label: string
    note?: string | null
    created_at?: Date | string
  }

  export type BookmarkCreateOrConnectWithoutRecordingInput = {
    where: BookmarkWhereUniqueInput
    create: XOR<BookmarkCreateWithoutRecordingInput, BookmarkUncheckedCreateWithoutRecordingInput>
  }

  export type BookmarkCreateManyRecordingInputEnvelope = {
    data: BookmarkCreateManyRecordingInput | BookmarkCreateManyRecordingInput[]
  }

  export type AnnotationCreateWithoutRecordingInput = {
    id?: string
    timecode_ms: number
    shape: string
    geometry: string
    color: string
    text?: string | null
    author?: string | null
    created_at?: Date | string
  }

  export type AnnotationUncheckedCreateWithoutRecordingInput = {
    id?: string
    timecode_ms: number
    shape: string
    geometry: string
    color: string
    text?: string | null
    author?: string | null
    created_at?: Date | string
  }

  export type AnnotationCreateOrConnectWithoutRecordingInput = {
    where: AnnotationWhereUniqueInput
    create: XOR<AnnotationCreateWithoutRecordingInput, AnnotationUncheckedCreateWithoutRecordingInput>
  }

  export type AnnotationCreateManyRecordingInputEnvelope = {
    data: AnnotationCreateManyRecordingInput | AnnotationCreateManyRecordingInput[]
  }

  export type SessionCreateWithoutRecordingInput = {
    id: string
    name?: string | null
    status?: string
    desired_capabilities: string
    session_capabilities: string
    node_id: string
    has_live_video: boolean
    video_recording_enabled?: boolean
    video_recording?: string | null
    startTime?: Date | string
    endTime?: Date | string | null
    failure_reason?: string | null
    is_profiling_available?: boolean
    device_info?: string | null
    device_udid: string
    device_platform: string
    device_version: string
    device_name?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    performance_trace?: string | null
    failure_category?: string | null
    ai_analysis?: string | null
    tags?: string | null
    trace_id?: string | null
    last_heartbeat_at?: Date | string | null
    heartbeat_pid?: number | null
    heartbeat_host?: string | null
    api_key_id?: string | null
    user_id?: string | null
    Log?: LogCreateNestedManyWithoutSessionInput
    Profiling?: ProfilingCreateNestedManyWithoutSessionInput
    build?: BuildCreateNestedOneWithoutSessionsInput
    SessionLog?: SessionLogCreateNestedManyWithoutSessionInput
  }

  export type SessionUncheckedCreateWithoutRecordingInput = {
    id: string
    build_id?: string | null
    name?: string | null
    status?: string
    desired_capabilities: string
    session_capabilities: string
    node_id: string
    has_live_video: boolean
    video_recording_enabled?: boolean
    video_recording?: string | null
    startTime?: Date | string
    endTime?: Date | string | null
    failure_reason?: string | null
    is_profiling_available?: boolean
    device_info?: string | null
    device_udid: string
    device_platform: string
    device_version: string
    device_name?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    performance_trace?: string | null
    failure_category?: string | null
    ai_analysis?: string | null
    tags?: string | null
    trace_id?: string | null
    last_heartbeat_at?: Date | string | null
    heartbeat_pid?: number | null
    heartbeat_host?: string | null
    api_key_id?: string | null
    user_id?: string | null
    Log?: LogUncheckedCreateNestedManyWithoutSessionInput
    Profiling?: ProfilingUncheckedCreateNestedManyWithoutSessionInput
    SessionLog?: SessionLogUncheckedCreateNestedManyWithoutSessionInput
  }

  export type SessionCreateOrConnectWithoutRecordingInput = {
    where: SessionWhereUniqueInput
    create: XOR<SessionCreateWithoutRecordingInput, SessionUncheckedCreateWithoutRecordingInput>
  }

  export type BookmarkUpsertWithWhereUniqueWithoutRecordingInput = {
    where: BookmarkWhereUniqueInput
    update: XOR<BookmarkUpdateWithoutRecordingInput, BookmarkUncheckedUpdateWithoutRecordingInput>
    create: XOR<BookmarkCreateWithoutRecordingInput, BookmarkUncheckedCreateWithoutRecordingInput>
  }

  export type BookmarkUpdateWithWhereUniqueWithoutRecordingInput = {
    where: BookmarkWhereUniqueInput
    data: XOR<BookmarkUpdateWithoutRecordingInput, BookmarkUncheckedUpdateWithoutRecordingInput>
  }

  export type BookmarkUpdateManyWithWhereWithoutRecordingInput = {
    where: BookmarkScalarWhereInput
    data: XOR<BookmarkUpdateManyMutationInput, BookmarkUncheckedUpdateManyWithoutRecordingInput>
  }

  export type BookmarkScalarWhereInput = {
    AND?: BookmarkScalarWhereInput | BookmarkScalarWhereInput[]
    OR?: BookmarkScalarWhereInput[]
    NOT?: BookmarkScalarWhereInput | BookmarkScalarWhereInput[]
    id?: StringFilter<"Bookmark"> | string
    recording_id?: StringFilter<"Bookmark"> | string
    timecode_ms?: IntFilter<"Bookmark"> | number
    label?: StringFilter<"Bookmark"> | string
    note?: StringNullableFilter<"Bookmark"> | string | null
    created_at?: DateTimeFilter<"Bookmark"> | Date | string
  }

  export type AnnotationUpsertWithWhereUniqueWithoutRecordingInput = {
    where: AnnotationWhereUniqueInput
    update: XOR<AnnotationUpdateWithoutRecordingInput, AnnotationUncheckedUpdateWithoutRecordingInput>
    create: XOR<AnnotationCreateWithoutRecordingInput, AnnotationUncheckedCreateWithoutRecordingInput>
  }

  export type AnnotationUpdateWithWhereUniqueWithoutRecordingInput = {
    where: AnnotationWhereUniqueInput
    data: XOR<AnnotationUpdateWithoutRecordingInput, AnnotationUncheckedUpdateWithoutRecordingInput>
  }

  export type AnnotationUpdateManyWithWhereWithoutRecordingInput = {
    where: AnnotationScalarWhereInput
    data: XOR<AnnotationUpdateManyMutationInput, AnnotationUncheckedUpdateManyWithoutRecordingInput>
  }

  export type AnnotationScalarWhereInput = {
    AND?: AnnotationScalarWhereInput | AnnotationScalarWhereInput[]
    OR?: AnnotationScalarWhereInput[]
    NOT?: AnnotationScalarWhereInput | AnnotationScalarWhereInput[]
    id?: StringFilter<"Annotation"> | string
    recording_id?: StringFilter<"Annotation"> | string
    timecode_ms?: IntFilter<"Annotation"> | number
    shape?: StringFilter<"Annotation"> | string
    geometry?: StringFilter<"Annotation"> | string
    color?: StringFilter<"Annotation"> | string
    text?: StringNullableFilter<"Annotation"> | string | null
    author?: StringNullableFilter<"Annotation"> | string | null
    created_at?: DateTimeFilter<"Annotation"> | Date | string
  }

  export type SessionUpsertWithoutRecordingInput = {
    update: XOR<SessionUpdateWithoutRecordingInput, SessionUncheckedUpdateWithoutRecordingInput>
    create: XOR<SessionCreateWithoutRecordingInput, SessionUncheckedCreateWithoutRecordingInput>
    where?: SessionWhereInput
  }

  export type SessionUpdateToOneWithWhereWithoutRecordingInput = {
    where?: SessionWhereInput
    data: XOR<SessionUpdateWithoutRecordingInput, SessionUncheckedUpdateWithoutRecordingInput>
  }

  export type SessionUpdateWithoutRecordingInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: NullableStringFieldUpdateOperationsInput | string | null
    status?: StringFieldUpdateOperationsInput | string
    desired_capabilities?: StringFieldUpdateOperationsInput | string
    session_capabilities?: StringFieldUpdateOperationsInput | string
    node_id?: StringFieldUpdateOperationsInput | string
    has_live_video?: BoolFieldUpdateOperationsInput | boolean
    video_recording_enabled?: BoolFieldUpdateOperationsInput | boolean
    video_recording?: NullableStringFieldUpdateOperationsInput | string | null
    startTime?: DateTimeFieldUpdateOperationsInput | Date | string
    endTime?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    failure_reason?: NullableStringFieldUpdateOperationsInput | string | null
    is_profiling_available?: BoolFieldUpdateOperationsInput | boolean
    device_info?: NullableStringFieldUpdateOperationsInput | string | null
    device_udid?: StringFieldUpdateOperationsInput | string
    device_platform?: StringFieldUpdateOperationsInput | string
    device_version?: StringFieldUpdateOperationsInput | string
    device_name?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    performance_trace?: NullableStringFieldUpdateOperationsInput | string | null
    failure_category?: NullableStringFieldUpdateOperationsInput | string | null
    ai_analysis?: NullableStringFieldUpdateOperationsInput | string | null
    tags?: NullableStringFieldUpdateOperationsInput | string | null
    trace_id?: NullableStringFieldUpdateOperationsInput | string | null
    last_heartbeat_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    heartbeat_pid?: NullableIntFieldUpdateOperationsInput | number | null
    heartbeat_host?: NullableStringFieldUpdateOperationsInput | string | null
    api_key_id?: NullableStringFieldUpdateOperationsInput | string | null
    user_id?: NullableStringFieldUpdateOperationsInput | string | null
    Log?: LogUpdateManyWithoutSessionNestedInput
    Profiling?: ProfilingUpdateManyWithoutSessionNestedInput
    build?: BuildUpdateOneWithoutSessionsNestedInput
    SessionLog?: SessionLogUpdateManyWithoutSessionNestedInput
  }

  export type SessionUncheckedUpdateWithoutRecordingInput = {
    id?: StringFieldUpdateOperationsInput | string
    build_id?: NullableStringFieldUpdateOperationsInput | string | null
    name?: NullableStringFieldUpdateOperationsInput | string | null
    status?: StringFieldUpdateOperationsInput | string
    desired_capabilities?: StringFieldUpdateOperationsInput | string
    session_capabilities?: StringFieldUpdateOperationsInput | string
    node_id?: StringFieldUpdateOperationsInput | string
    has_live_video?: BoolFieldUpdateOperationsInput | boolean
    video_recording_enabled?: BoolFieldUpdateOperationsInput | boolean
    video_recording?: NullableStringFieldUpdateOperationsInput | string | null
    startTime?: DateTimeFieldUpdateOperationsInput | Date | string
    endTime?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    failure_reason?: NullableStringFieldUpdateOperationsInput | string | null
    is_profiling_available?: BoolFieldUpdateOperationsInput | boolean
    device_info?: NullableStringFieldUpdateOperationsInput | string | null
    device_udid?: StringFieldUpdateOperationsInput | string
    device_platform?: StringFieldUpdateOperationsInput | string
    device_version?: StringFieldUpdateOperationsInput | string
    device_name?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    performance_trace?: NullableStringFieldUpdateOperationsInput | string | null
    failure_category?: NullableStringFieldUpdateOperationsInput | string | null
    ai_analysis?: NullableStringFieldUpdateOperationsInput | string | null
    tags?: NullableStringFieldUpdateOperationsInput | string | null
    trace_id?: NullableStringFieldUpdateOperationsInput | string | null
    last_heartbeat_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    heartbeat_pid?: NullableIntFieldUpdateOperationsInput | number | null
    heartbeat_host?: NullableStringFieldUpdateOperationsInput | string | null
    api_key_id?: NullableStringFieldUpdateOperationsInput | string | null
    user_id?: NullableStringFieldUpdateOperationsInput | string | null
    Log?: LogUncheckedUpdateManyWithoutSessionNestedInput
    Profiling?: ProfilingUncheckedUpdateManyWithoutSessionNestedInput
    SessionLog?: SessionLogUncheckedUpdateManyWithoutSessionNestedInput
  }

  export type RecordingCreateWithoutBookmarksInput = {
    id?: string
    group_id: string
    device_udid: string
    device_host?: string
    started_at: Date | string
    ended_at?: Date | string | null
    status: string
    file_path: string
    duration_ms?: number | null
    size_bytes?: number | null
    device_snapshot?: string | null
    fail_reason?: string | null
    annotations?: AnnotationCreateNestedManyWithoutRecordingInput
    Session?: SessionCreateNestedOneWithoutRecordingInput
  }

  export type RecordingUncheckedCreateWithoutBookmarksInput = {
    id?: string
    group_id: string
    device_udid: string
    device_host?: string
    session_id?: string | null
    started_at: Date | string
    ended_at?: Date | string | null
    status: string
    file_path: string
    duration_ms?: number | null
    size_bytes?: number | null
    device_snapshot?: string | null
    fail_reason?: string | null
    annotations?: AnnotationUncheckedCreateNestedManyWithoutRecordingInput
  }

  export type RecordingCreateOrConnectWithoutBookmarksInput = {
    where: RecordingWhereUniqueInput
    create: XOR<RecordingCreateWithoutBookmarksInput, RecordingUncheckedCreateWithoutBookmarksInput>
  }

  export type RecordingUpsertWithoutBookmarksInput = {
    update: XOR<RecordingUpdateWithoutBookmarksInput, RecordingUncheckedUpdateWithoutBookmarksInput>
    create: XOR<RecordingCreateWithoutBookmarksInput, RecordingUncheckedCreateWithoutBookmarksInput>
    where?: RecordingWhereInput
  }

  export type RecordingUpdateToOneWithWhereWithoutBookmarksInput = {
    where?: RecordingWhereInput
    data: XOR<RecordingUpdateWithoutBookmarksInput, RecordingUncheckedUpdateWithoutBookmarksInput>
  }

  export type RecordingUpdateWithoutBookmarksInput = {
    id?: StringFieldUpdateOperationsInput | string
    group_id?: StringFieldUpdateOperationsInput | string
    device_udid?: StringFieldUpdateOperationsInput | string
    device_host?: StringFieldUpdateOperationsInput | string
    started_at?: DateTimeFieldUpdateOperationsInput | Date | string
    ended_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    status?: StringFieldUpdateOperationsInput | string
    file_path?: StringFieldUpdateOperationsInput | string
    duration_ms?: NullableIntFieldUpdateOperationsInput | number | null
    size_bytes?: NullableIntFieldUpdateOperationsInput | number | null
    device_snapshot?: NullableStringFieldUpdateOperationsInput | string | null
    fail_reason?: NullableStringFieldUpdateOperationsInput | string | null
    annotations?: AnnotationUpdateManyWithoutRecordingNestedInput
    Session?: SessionUpdateOneWithoutRecordingNestedInput
  }

  export type RecordingUncheckedUpdateWithoutBookmarksInput = {
    id?: StringFieldUpdateOperationsInput | string
    group_id?: StringFieldUpdateOperationsInput | string
    device_udid?: StringFieldUpdateOperationsInput | string
    device_host?: StringFieldUpdateOperationsInput | string
    session_id?: NullableStringFieldUpdateOperationsInput | string | null
    started_at?: DateTimeFieldUpdateOperationsInput | Date | string
    ended_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    status?: StringFieldUpdateOperationsInput | string
    file_path?: StringFieldUpdateOperationsInput | string
    duration_ms?: NullableIntFieldUpdateOperationsInput | number | null
    size_bytes?: NullableIntFieldUpdateOperationsInput | number | null
    device_snapshot?: NullableStringFieldUpdateOperationsInput | string | null
    fail_reason?: NullableStringFieldUpdateOperationsInput | string | null
    annotations?: AnnotationUncheckedUpdateManyWithoutRecordingNestedInput
  }

  export type RecordingCreateWithoutAnnotationsInput = {
    id?: string
    group_id: string
    device_udid: string
    device_host?: string
    started_at: Date | string
    ended_at?: Date | string | null
    status: string
    file_path: string
    duration_ms?: number | null
    size_bytes?: number | null
    device_snapshot?: string | null
    fail_reason?: string | null
    bookmarks?: BookmarkCreateNestedManyWithoutRecordingInput
    Session?: SessionCreateNestedOneWithoutRecordingInput
  }

  export type RecordingUncheckedCreateWithoutAnnotationsInput = {
    id?: string
    group_id: string
    device_udid: string
    device_host?: string
    session_id?: string | null
    started_at: Date | string
    ended_at?: Date | string | null
    status: string
    file_path: string
    duration_ms?: number | null
    size_bytes?: number | null
    device_snapshot?: string | null
    fail_reason?: string | null
    bookmarks?: BookmarkUncheckedCreateNestedManyWithoutRecordingInput
  }

  export type RecordingCreateOrConnectWithoutAnnotationsInput = {
    where: RecordingWhereUniqueInput
    create: XOR<RecordingCreateWithoutAnnotationsInput, RecordingUncheckedCreateWithoutAnnotationsInput>
  }

  export type RecordingUpsertWithoutAnnotationsInput = {
    update: XOR<RecordingUpdateWithoutAnnotationsInput, RecordingUncheckedUpdateWithoutAnnotationsInput>
    create: XOR<RecordingCreateWithoutAnnotationsInput, RecordingUncheckedCreateWithoutAnnotationsInput>
    where?: RecordingWhereInput
  }

  export type RecordingUpdateToOneWithWhereWithoutAnnotationsInput = {
    where?: RecordingWhereInput
    data: XOR<RecordingUpdateWithoutAnnotationsInput, RecordingUncheckedUpdateWithoutAnnotationsInput>
  }

  export type RecordingUpdateWithoutAnnotationsInput = {
    id?: StringFieldUpdateOperationsInput | string
    group_id?: StringFieldUpdateOperationsInput | string
    device_udid?: StringFieldUpdateOperationsInput | string
    device_host?: StringFieldUpdateOperationsInput | string
    started_at?: DateTimeFieldUpdateOperationsInput | Date | string
    ended_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    status?: StringFieldUpdateOperationsInput | string
    file_path?: StringFieldUpdateOperationsInput | string
    duration_ms?: NullableIntFieldUpdateOperationsInput | number | null
    size_bytes?: NullableIntFieldUpdateOperationsInput | number | null
    device_snapshot?: NullableStringFieldUpdateOperationsInput | string | null
    fail_reason?: NullableStringFieldUpdateOperationsInput | string | null
    bookmarks?: BookmarkUpdateManyWithoutRecordingNestedInput
    Session?: SessionUpdateOneWithoutRecordingNestedInput
  }

  export type RecordingUncheckedUpdateWithoutAnnotationsInput = {
    id?: StringFieldUpdateOperationsInput | string
    group_id?: StringFieldUpdateOperationsInput | string
    device_udid?: StringFieldUpdateOperationsInput | string
    device_host?: StringFieldUpdateOperationsInput | string
    session_id?: NullableStringFieldUpdateOperationsInput | string | null
    started_at?: DateTimeFieldUpdateOperationsInput | Date | string
    ended_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    status?: StringFieldUpdateOperationsInput | string
    file_path?: StringFieldUpdateOperationsInput | string
    duration_ms?: NullableIntFieldUpdateOperationsInput | number | null
    size_bytes?: NullableIntFieldUpdateOperationsInput | number | null
    device_snapshot?: NullableStringFieldUpdateOperationsInput | string | null
    fail_reason?: NullableStringFieldUpdateOperationsInput | string | null
    bookmarks?: BookmarkUncheckedUpdateManyWithoutRecordingNestedInput
  }

  export type ApiKeyCreateWithoutUserInput = {
    id?: string
    name: string
    keyHash: string
    scopes: string
    rateLimit?: number
    createdAt?: Date | string
    revokedAt?: Date | string | null
    lastUsedAt?: Date | string | null
    expiresAt?: Date | string | null
    role?: string
    team?: TeamCreateNestedOneWithoutApiKeysInput
  }

  export type ApiKeyUncheckedCreateWithoutUserInput = {
    id?: string
    name: string
    keyHash: string
    scopes: string
    rateLimit?: number
    createdAt?: Date | string
    revokedAt?: Date | string | null
    lastUsedAt?: Date | string | null
    expiresAt?: Date | string | null
    teamId?: string | null
    role?: string
  }

  export type ApiKeyCreateOrConnectWithoutUserInput = {
    where: ApiKeyWhereUniqueInput
    create: XOR<ApiKeyCreateWithoutUserInput, ApiKeyUncheckedCreateWithoutUserInput>
  }

  export type ApiKeyCreateManyUserInputEnvelope = {
    data: ApiKeyCreateManyUserInput | ApiKeyCreateManyUserInput[]
  }

  export type UserSessionCreateWithoutUserInput = {
    id?: string
    createdAt?: Date | string
    expiresAt: Date | string
    lastSeenAt?: Date | string
    userAgent?: string | null
    ipHash?: string | null
  }

  export type UserSessionUncheckedCreateWithoutUserInput = {
    id?: string
    createdAt?: Date | string
    expiresAt: Date | string
    lastSeenAt?: Date | string
    userAgent?: string | null
    ipHash?: string | null
  }

  export type UserSessionCreateOrConnectWithoutUserInput = {
    where: UserSessionWhereUniqueInput
    create: XOR<UserSessionCreateWithoutUserInput, UserSessionUncheckedCreateWithoutUserInput>
  }

  export type UserSessionCreateManyUserInputEnvelope = {
    data: UserSessionCreateManyUserInput | UserSessionCreateManyUserInput[]
  }

  export type PasswordResetTokenCreateWithoutUserInput = {
    id?: string
    tokenHash: string
    createdAt?: Date | string
    expiresAt: Date | string
    usedAt?: Date | string | null
  }

  export type PasswordResetTokenUncheckedCreateWithoutUserInput = {
    id?: string
    tokenHash: string
    createdAt?: Date | string
    expiresAt: Date | string
    usedAt?: Date | string | null
  }

  export type PasswordResetTokenCreateOrConnectWithoutUserInput = {
    where: PasswordResetTokenWhereUniqueInput
    create: XOR<PasswordResetTokenCreateWithoutUserInput, PasswordResetTokenUncheckedCreateWithoutUserInput>
  }

  export type PasswordResetTokenCreateManyUserInputEnvelope = {
    data: PasswordResetTokenCreateManyUserInput | PasswordResetTokenCreateManyUserInput[]
  }

  export type TeamMemberCreateWithoutUserInput = {
    createdAt?: Date | string
    team: TeamCreateNestedOneWithoutMembersInput
  }

  export type TeamMemberUncheckedCreateWithoutUserInput = {
    teamId: string
    createdAt?: Date | string
  }

  export type TeamMemberCreateOrConnectWithoutUserInput = {
    where: TeamMemberWhereUniqueInput
    create: XOR<TeamMemberCreateWithoutUserInput, TeamMemberUncheckedCreateWithoutUserInput>
  }

  export type TeamMemberCreateManyUserInputEnvelope = {
    data: TeamMemberCreateManyUserInput | TeamMemberCreateManyUserInput[]
  }

  export type ApiKeyUpsertWithWhereUniqueWithoutUserInput = {
    where: ApiKeyWhereUniqueInput
    update: XOR<ApiKeyUpdateWithoutUserInput, ApiKeyUncheckedUpdateWithoutUserInput>
    create: XOR<ApiKeyCreateWithoutUserInput, ApiKeyUncheckedCreateWithoutUserInput>
  }

  export type ApiKeyUpdateWithWhereUniqueWithoutUserInput = {
    where: ApiKeyWhereUniqueInput
    data: XOR<ApiKeyUpdateWithoutUserInput, ApiKeyUncheckedUpdateWithoutUserInput>
  }

  export type ApiKeyUpdateManyWithWhereWithoutUserInput = {
    where: ApiKeyScalarWhereInput
    data: XOR<ApiKeyUpdateManyMutationInput, ApiKeyUncheckedUpdateManyWithoutUserInput>
  }

  export type UserSessionUpsertWithWhereUniqueWithoutUserInput = {
    where: UserSessionWhereUniqueInput
    update: XOR<UserSessionUpdateWithoutUserInput, UserSessionUncheckedUpdateWithoutUserInput>
    create: XOR<UserSessionCreateWithoutUserInput, UserSessionUncheckedCreateWithoutUserInput>
  }

  export type UserSessionUpdateWithWhereUniqueWithoutUserInput = {
    where: UserSessionWhereUniqueInput
    data: XOR<UserSessionUpdateWithoutUserInput, UserSessionUncheckedUpdateWithoutUserInput>
  }

  export type UserSessionUpdateManyWithWhereWithoutUserInput = {
    where: UserSessionScalarWhereInput
    data: XOR<UserSessionUpdateManyMutationInput, UserSessionUncheckedUpdateManyWithoutUserInput>
  }

  export type UserSessionScalarWhereInput = {
    AND?: UserSessionScalarWhereInput | UserSessionScalarWhereInput[]
    OR?: UserSessionScalarWhereInput[]
    NOT?: UserSessionScalarWhereInput | UserSessionScalarWhereInput[]
    id?: StringFilter<"UserSession"> | string
    userId?: StringFilter<"UserSession"> | string
    createdAt?: DateTimeFilter<"UserSession"> | Date | string
    expiresAt?: DateTimeFilter<"UserSession"> | Date | string
    lastSeenAt?: DateTimeFilter<"UserSession"> | Date | string
    userAgent?: StringNullableFilter<"UserSession"> | string | null
    ipHash?: StringNullableFilter<"UserSession"> | string | null
  }

  export type PasswordResetTokenUpsertWithWhereUniqueWithoutUserInput = {
    where: PasswordResetTokenWhereUniqueInput
    update: XOR<PasswordResetTokenUpdateWithoutUserInput, PasswordResetTokenUncheckedUpdateWithoutUserInput>
    create: XOR<PasswordResetTokenCreateWithoutUserInput, PasswordResetTokenUncheckedCreateWithoutUserInput>
  }

  export type PasswordResetTokenUpdateWithWhereUniqueWithoutUserInput = {
    where: PasswordResetTokenWhereUniqueInput
    data: XOR<PasswordResetTokenUpdateWithoutUserInput, PasswordResetTokenUncheckedUpdateWithoutUserInput>
  }

  export type PasswordResetTokenUpdateManyWithWhereWithoutUserInput = {
    where: PasswordResetTokenScalarWhereInput
    data: XOR<PasswordResetTokenUpdateManyMutationInput, PasswordResetTokenUncheckedUpdateManyWithoutUserInput>
  }

  export type PasswordResetTokenScalarWhereInput = {
    AND?: PasswordResetTokenScalarWhereInput | PasswordResetTokenScalarWhereInput[]
    OR?: PasswordResetTokenScalarWhereInput[]
    NOT?: PasswordResetTokenScalarWhereInput | PasswordResetTokenScalarWhereInput[]
    id?: StringFilter<"PasswordResetToken"> | string
    userId?: StringFilter<"PasswordResetToken"> | string
    tokenHash?: StringFilter<"PasswordResetToken"> | string
    createdAt?: DateTimeFilter<"PasswordResetToken"> | Date | string
    expiresAt?: DateTimeFilter<"PasswordResetToken"> | Date | string
    usedAt?: DateTimeNullableFilter<"PasswordResetToken"> | Date | string | null
  }

  export type TeamMemberUpsertWithWhereUniqueWithoutUserInput = {
    where: TeamMemberWhereUniqueInput
    update: XOR<TeamMemberUpdateWithoutUserInput, TeamMemberUncheckedUpdateWithoutUserInput>
    create: XOR<TeamMemberCreateWithoutUserInput, TeamMemberUncheckedCreateWithoutUserInput>
  }

  export type TeamMemberUpdateWithWhereUniqueWithoutUserInput = {
    where: TeamMemberWhereUniqueInput
    data: XOR<TeamMemberUpdateWithoutUserInput, TeamMemberUncheckedUpdateWithoutUserInput>
  }

  export type TeamMemberUpdateManyWithWhereWithoutUserInput = {
    where: TeamMemberScalarWhereInput
    data: XOR<TeamMemberUpdateManyMutationInput, TeamMemberUncheckedUpdateManyWithoutUserInput>
  }

  export type UserCreateWithoutSessionsInput = {
    id?: string
    email: string
    name: string
    passwordHash: string
    accessKey: string
    role?: string
    status?: string
    createdAt?: Date | string
    updatedAt?: Date | string
    lastLoginAt?: Date | string | null
    passwordChangedAt?: Date | string | null
    apiKeys?: ApiKeyCreateNestedManyWithoutUserInput
    passwordResetTokens?: PasswordResetTokenCreateNestedManyWithoutUserInput
    teamMemberships?: TeamMemberCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutSessionsInput = {
    id?: string
    email: string
    name: string
    passwordHash: string
    accessKey: string
    role?: string
    status?: string
    createdAt?: Date | string
    updatedAt?: Date | string
    lastLoginAt?: Date | string | null
    passwordChangedAt?: Date | string | null
    apiKeys?: ApiKeyUncheckedCreateNestedManyWithoutUserInput
    passwordResetTokens?: PasswordResetTokenUncheckedCreateNestedManyWithoutUserInput
    teamMemberships?: TeamMemberUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutSessionsInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutSessionsInput, UserUncheckedCreateWithoutSessionsInput>
  }

  export type UserUpsertWithoutSessionsInput = {
    update: XOR<UserUpdateWithoutSessionsInput, UserUncheckedUpdateWithoutSessionsInput>
    create: XOR<UserCreateWithoutSessionsInput, UserUncheckedCreateWithoutSessionsInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutSessionsInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutSessionsInput, UserUncheckedUpdateWithoutSessionsInput>
  }

  export type UserUpdateWithoutSessionsInput = {
    id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    passwordHash?: StringFieldUpdateOperationsInput | string
    accessKey?: StringFieldUpdateOperationsInput | string
    role?: StringFieldUpdateOperationsInput | string
    status?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    lastLoginAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    passwordChangedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    apiKeys?: ApiKeyUpdateManyWithoutUserNestedInput
    passwordResetTokens?: PasswordResetTokenUpdateManyWithoutUserNestedInput
    teamMemberships?: TeamMemberUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutSessionsInput = {
    id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    passwordHash?: StringFieldUpdateOperationsInput | string
    accessKey?: StringFieldUpdateOperationsInput | string
    role?: StringFieldUpdateOperationsInput | string
    status?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    lastLoginAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    passwordChangedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    apiKeys?: ApiKeyUncheckedUpdateManyWithoutUserNestedInput
    passwordResetTokens?: PasswordResetTokenUncheckedUpdateManyWithoutUserNestedInput
    teamMemberships?: TeamMemberUncheckedUpdateManyWithoutUserNestedInput
  }

  export type UserCreateWithoutPasswordResetTokensInput = {
    id?: string
    email: string
    name: string
    passwordHash: string
    accessKey: string
    role?: string
    status?: string
    createdAt?: Date | string
    updatedAt?: Date | string
    lastLoginAt?: Date | string | null
    passwordChangedAt?: Date | string | null
    apiKeys?: ApiKeyCreateNestedManyWithoutUserInput
    sessions?: UserSessionCreateNestedManyWithoutUserInput
    teamMemberships?: TeamMemberCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutPasswordResetTokensInput = {
    id?: string
    email: string
    name: string
    passwordHash: string
    accessKey: string
    role?: string
    status?: string
    createdAt?: Date | string
    updatedAt?: Date | string
    lastLoginAt?: Date | string | null
    passwordChangedAt?: Date | string | null
    apiKeys?: ApiKeyUncheckedCreateNestedManyWithoutUserInput
    sessions?: UserSessionUncheckedCreateNestedManyWithoutUserInput
    teamMemberships?: TeamMemberUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutPasswordResetTokensInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutPasswordResetTokensInput, UserUncheckedCreateWithoutPasswordResetTokensInput>
  }

  export type UserUpsertWithoutPasswordResetTokensInput = {
    update: XOR<UserUpdateWithoutPasswordResetTokensInput, UserUncheckedUpdateWithoutPasswordResetTokensInput>
    create: XOR<UserCreateWithoutPasswordResetTokensInput, UserUncheckedCreateWithoutPasswordResetTokensInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutPasswordResetTokensInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutPasswordResetTokensInput, UserUncheckedUpdateWithoutPasswordResetTokensInput>
  }

  export type UserUpdateWithoutPasswordResetTokensInput = {
    id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    passwordHash?: StringFieldUpdateOperationsInput | string
    accessKey?: StringFieldUpdateOperationsInput | string
    role?: StringFieldUpdateOperationsInput | string
    status?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    lastLoginAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    passwordChangedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    apiKeys?: ApiKeyUpdateManyWithoutUserNestedInput
    sessions?: UserSessionUpdateManyWithoutUserNestedInput
    teamMemberships?: TeamMemberUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutPasswordResetTokensInput = {
    id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    passwordHash?: StringFieldUpdateOperationsInput | string
    accessKey?: StringFieldUpdateOperationsInput | string
    role?: StringFieldUpdateOperationsInput | string
    status?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    lastLoginAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    passwordChangedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    apiKeys?: ApiKeyUncheckedUpdateManyWithoutUserNestedInput
    sessions?: UserSessionUncheckedUpdateManyWithoutUserNestedInput
    teamMemberships?: TeamMemberUncheckedUpdateManyWithoutUserNestedInput
  }

  export type TeamCreateWithoutMembersInput = {
    id?: string
    name: string
    createdAt?: Date | string
    devices?: DeviceCreateNestedManyWithoutTeamInput
    apiKeys?: ApiKeyCreateNestedManyWithoutTeamInput
  }

  export type TeamUncheckedCreateWithoutMembersInput = {
    id?: string
    name: string
    createdAt?: Date | string
    devices?: DeviceUncheckedCreateNestedManyWithoutTeamInput
    apiKeys?: ApiKeyUncheckedCreateNestedManyWithoutTeamInput
  }

  export type TeamCreateOrConnectWithoutMembersInput = {
    where: TeamWhereUniqueInput
    create: XOR<TeamCreateWithoutMembersInput, TeamUncheckedCreateWithoutMembersInput>
  }

  export type UserCreateWithoutTeamMembershipsInput = {
    id?: string
    email: string
    name: string
    passwordHash: string
    accessKey: string
    role?: string
    status?: string
    createdAt?: Date | string
    updatedAt?: Date | string
    lastLoginAt?: Date | string | null
    passwordChangedAt?: Date | string | null
    apiKeys?: ApiKeyCreateNestedManyWithoutUserInput
    sessions?: UserSessionCreateNestedManyWithoutUserInput
    passwordResetTokens?: PasswordResetTokenCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutTeamMembershipsInput = {
    id?: string
    email: string
    name: string
    passwordHash: string
    accessKey: string
    role?: string
    status?: string
    createdAt?: Date | string
    updatedAt?: Date | string
    lastLoginAt?: Date | string | null
    passwordChangedAt?: Date | string | null
    apiKeys?: ApiKeyUncheckedCreateNestedManyWithoutUserInput
    sessions?: UserSessionUncheckedCreateNestedManyWithoutUserInput
    passwordResetTokens?: PasswordResetTokenUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutTeamMembershipsInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutTeamMembershipsInput, UserUncheckedCreateWithoutTeamMembershipsInput>
  }

  export type TeamUpsertWithoutMembersInput = {
    update: XOR<TeamUpdateWithoutMembersInput, TeamUncheckedUpdateWithoutMembersInput>
    create: XOR<TeamCreateWithoutMembersInput, TeamUncheckedCreateWithoutMembersInput>
    where?: TeamWhereInput
  }

  export type TeamUpdateToOneWithWhereWithoutMembersInput = {
    where?: TeamWhereInput
    data: XOR<TeamUpdateWithoutMembersInput, TeamUncheckedUpdateWithoutMembersInput>
  }

  export type TeamUpdateWithoutMembersInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    devices?: DeviceUpdateManyWithoutTeamNestedInput
    apiKeys?: ApiKeyUpdateManyWithoutTeamNestedInput
  }

  export type TeamUncheckedUpdateWithoutMembersInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    devices?: DeviceUncheckedUpdateManyWithoutTeamNestedInput
    apiKeys?: ApiKeyUncheckedUpdateManyWithoutTeamNestedInput
  }

  export type UserUpsertWithoutTeamMembershipsInput = {
    update: XOR<UserUpdateWithoutTeamMembershipsInput, UserUncheckedUpdateWithoutTeamMembershipsInput>
    create: XOR<UserCreateWithoutTeamMembershipsInput, UserUncheckedCreateWithoutTeamMembershipsInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutTeamMembershipsInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutTeamMembershipsInput, UserUncheckedUpdateWithoutTeamMembershipsInput>
  }

  export type UserUpdateWithoutTeamMembershipsInput = {
    id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    passwordHash?: StringFieldUpdateOperationsInput | string
    accessKey?: StringFieldUpdateOperationsInput | string
    role?: StringFieldUpdateOperationsInput | string
    status?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    lastLoginAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    passwordChangedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    apiKeys?: ApiKeyUpdateManyWithoutUserNestedInput
    sessions?: UserSessionUpdateManyWithoutUserNestedInput
    passwordResetTokens?: PasswordResetTokenUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutTeamMembershipsInput = {
    id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    passwordHash?: StringFieldUpdateOperationsInput | string
    accessKey?: StringFieldUpdateOperationsInput | string
    role?: StringFieldUpdateOperationsInput | string
    status?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    lastLoginAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    passwordChangedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    apiKeys?: ApiKeyUncheckedUpdateManyWithoutUserNestedInput
    sessions?: UserSessionUncheckedUpdateManyWithoutUserNestedInput
    passwordResetTokens?: PasswordResetTokenUncheckedUpdateManyWithoutUserNestedInput
  }

  export type SessionCreateManyBuildInput = {
    id: string
    name?: string | null
    status?: string
    desired_capabilities: string
    session_capabilities: string
    node_id: string
    has_live_video: boolean
    video_recording_enabled?: boolean
    video_recording?: string | null
    startTime?: Date | string
    endTime?: Date | string | null
    failure_reason?: string | null
    is_profiling_available?: boolean
    device_info?: string | null
    device_udid: string
    device_platform: string
    device_version: string
    device_name?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    performance_trace?: string | null
    failure_category?: string | null
    ai_analysis?: string | null
    tags?: string | null
    trace_id?: string | null
    last_heartbeat_at?: Date | string | null
    heartbeat_pid?: number | null
    heartbeat_host?: string | null
    api_key_id?: string | null
    user_id?: string | null
  }

  export type SessionUpdateWithoutBuildInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: NullableStringFieldUpdateOperationsInput | string | null
    status?: StringFieldUpdateOperationsInput | string
    desired_capabilities?: StringFieldUpdateOperationsInput | string
    session_capabilities?: StringFieldUpdateOperationsInput | string
    node_id?: StringFieldUpdateOperationsInput | string
    has_live_video?: BoolFieldUpdateOperationsInput | boolean
    video_recording_enabled?: BoolFieldUpdateOperationsInput | boolean
    video_recording?: NullableStringFieldUpdateOperationsInput | string | null
    startTime?: DateTimeFieldUpdateOperationsInput | Date | string
    endTime?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    failure_reason?: NullableStringFieldUpdateOperationsInput | string | null
    is_profiling_available?: BoolFieldUpdateOperationsInput | boolean
    device_info?: NullableStringFieldUpdateOperationsInput | string | null
    device_udid?: StringFieldUpdateOperationsInput | string
    device_platform?: StringFieldUpdateOperationsInput | string
    device_version?: StringFieldUpdateOperationsInput | string
    device_name?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    performance_trace?: NullableStringFieldUpdateOperationsInput | string | null
    failure_category?: NullableStringFieldUpdateOperationsInput | string | null
    ai_analysis?: NullableStringFieldUpdateOperationsInput | string | null
    tags?: NullableStringFieldUpdateOperationsInput | string | null
    trace_id?: NullableStringFieldUpdateOperationsInput | string | null
    last_heartbeat_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    heartbeat_pid?: NullableIntFieldUpdateOperationsInput | number | null
    heartbeat_host?: NullableStringFieldUpdateOperationsInput | string | null
    api_key_id?: NullableStringFieldUpdateOperationsInput | string | null
    user_id?: NullableStringFieldUpdateOperationsInput | string | null
    Log?: LogUpdateManyWithoutSessionNestedInput
    Profiling?: ProfilingUpdateManyWithoutSessionNestedInput
    SessionLog?: SessionLogUpdateManyWithoutSessionNestedInput
    Recording?: RecordingUpdateManyWithoutSessionNestedInput
  }

  export type SessionUncheckedUpdateWithoutBuildInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: NullableStringFieldUpdateOperationsInput | string | null
    status?: StringFieldUpdateOperationsInput | string
    desired_capabilities?: StringFieldUpdateOperationsInput | string
    session_capabilities?: StringFieldUpdateOperationsInput | string
    node_id?: StringFieldUpdateOperationsInput | string
    has_live_video?: BoolFieldUpdateOperationsInput | boolean
    video_recording_enabled?: BoolFieldUpdateOperationsInput | boolean
    video_recording?: NullableStringFieldUpdateOperationsInput | string | null
    startTime?: DateTimeFieldUpdateOperationsInput | Date | string
    endTime?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    failure_reason?: NullableStringFieldUpdateOperationsInput | string | null
    is_profiling_available?: BoolFieldUpdateOperationsInput | boolean
    device_info?: NullableStringFieldUpdateOperationsInput | string | null
    device_udid?: StringFieldUpdateOperationsInput | string
    device_platform?: StringFieldUpdateOperationsInput | string
    device_version?: StringFieldUpdateOperationsInput | string
    device_name?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    performance_trace?: NullableStringFieldUpdateOperationsInput | string | null
    failure_category?: NullableStringFieldUpdateOperationsInput | string | null
    ai_analysis?: NullableStringFieldUpdateOperationsInput | string | null
    tags?: NullableStringFieldUpdateOperationsInput | string | null
    trace_id?: NullableStringFieldUpdateOperationsInput | string | null
    last_heartbeat_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    heartbeat_pid?: NullableIntFieldUpdateOperationsInput | number | null
    heartbeat_host?: NullableStringFieldUpdateOperationsInput | string | null
    api_key_id?: NullableStringFieldUpdateOperationsInput | string | null
    user_id?: NullableStringFieldUpdateOperationsInput | string | null
    Log?: LogUncheckedUpdateManyWithoutSessionNestedInput
    Profiling?: ProfilingUncheckedUpdateManyWithoutSessionNestedInput
    SessionLog?: SessionLogUncheckedUpdateManyWithoutSessionNestedInput
    Recording?: RecordingUncheckedUpdateManyWithoutSessionNestedInput
  }

  export type SessionUncheckedUpdateManyWithoutBuildInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: NullableStringFieldUpdateOperationsInput | string | null
    status?: StringFieldUpdateOperationsInput | string
    desired_capabilities?: StringFieldUpdateOperationsInput | string
    session_capabilities?: StringFieldUpdateOperationsInput | string
    node_id?: StringFieldUpdateOperationsInput | string
    has_live_video?: BoolFieldUpdateOperationsInput | boolean
    video_recording_enabled?: BoolFieldUpdateOperationsInput | boolean
    video_recording?: NullableStringFieldUpdateOperationsInput | string | null
    startTime?: DateTimeFieldUpdateOperationsInput | Date | string
    endTime?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    failure_reason?: NullableStringFieldUpdateOperationsInput | string | null
    is_profiling_available?: BoolFieldUpdateOperationsInput | boolean
    device_info?: NullableStringFieldUpdateOperationsInput | string | null
    device_udid?: StringFieldUpdateOperationsInput | string
    device_platform?: StringFieldUpdateOperationsInput | string
    device_version?: StringFieldUpdateOperationsInput | string
    device_name?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    performance_trace?: NullableStringFieldUpdateOperationsInput | string | null
    failure_category?: NullableStringFieldUpdateOperationsInput | string | null
    ai_analysis?: NullableStringFieldUpdateOperationsInput | string | null
    tags?: NullableStringFieldUpdateOperationsInput | string | null
    trace_id?: NullableStringFieldUpdateOperationsInput | string | null
    last_heartbeat_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    heartbeat_pid?: NullableIntFieldUpdateOperationsInput | number | null
    heartbeat_host?: NullableStringFieldUpdateOperationsInput | string | null
    api_key_id?: NullableStringFieldUpdateOperationsInput | string | null
    user_id?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type LogCreateManySessionInput = {
    id?: string
    log_type: string
    message: string
    timestamp?: Date | string
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type ProfilingCreateManySessionInput = {
    id?: number
    cpu?: string | null
    memory?: string | null
    total_cpu_used?: string | null
    total_memory_used?: string | null
    raw_cpu_log?: string | null
    raw_memory_log?: string | null
    timestamp: Date | string
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type SessionLogCreateManySessionInput = {
    id?: string
    command_name?: string | null
    url: string
    method: string
    title: string
    subtitle?: string | null
    body?: string | null
    response: string
    screenshot?: string | null
    is_success?: boolean | null
    is_error?: boolean
    is_healed?: boolean
    original_selector?: string | null
    healed_selector?: string | null
    healing_confidence?: number | null
    healing_tier?: string | null
    original_strategy?: string | null
    healed_strategy?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    duration?: number | null
    span_id?: string | null
    trace_id?: string | null
  }

  export type RecordingCreateManySessionInput = {
    id?: string
    group_id: string
    device_udid: string
    device_host?: string
    started_at: Date | string
    ended_at?: Date | string | null
    status: string
    file_path: string
    duration_ms?: number | null
    size_bytes?: number | null
    device_snapshot?: string | null
    fail_reason?: string | null
  }

  export type LogUpdateWithoutSessionInput = {
    id?: StringFieldUpdateOperationsInput | string
    log_type?: StringFieldUpdateOperationsInput | string
    message?: StringFieldUpdateOperationsInput | string
    timestamp?: DateTimeFieldUpdateOperationsInput | Date | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type LogUncheckedUpdateWithoutSessionInput = {
    id?: StringFieldUpdateOperationsInput | string
    log_type?: StringFieldUpdateOperationsInput | string
    message?: StringFieldUpdateOperationsInput | string
    timestamp?: DateTimeFieldUpdateOperationsInput | Date | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type LogUncheckedUpdateManyWithoutSessionInput = {
    id?: StringFieldUpdateOperationsInput | string
    log_type?: StringFieldUpdateOperationsInput | string
    message?: StringFieldUpdateOperationsInput | string
    timestamp?: DateTimeFieldUpdateOperationsInput | Date | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type ProfilingUpdateWithoutSessionInput = {
    cpu?: NullableStringFieldUpdateOperationsInput | string | null
    memory?: NullableStringFieldUpdateOperationsInput | string | null
    total_cpu_used?: NullableStringFieldUpdateOperationsInput | string | null
    total_memory_used?: NullableStringFieldUpdateOperationsInput | string | null
    raw_cpu_log?: NullableStringFieldUpdateOperationsInput | string | null
    raw_memory_log?: NullableStringFieldUpdateOperationsInput | string | null
    timestamp?: DateTimeFieldUpdateOperationsInput | Date | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type ProfilingUncheckedUpdateWithoutSessionInput = {
    id?: IntFieldUpdateOperationsInput | number
    cpu?: NullableStringFieldUpdateOperationsInput | string | null
    memory?: NullableStringFieldUpdateOperationsInput | string | null
    total_cpu_used?: NullableStringFieldUpdateOperationsInput | string | null
    total_memory_used?: NullableStringFieldUpdateOperationsInput | string | null
    raw_cpu_log?: NullableStringFieldUpdateOperationsInput | string | null
    raw_memory_log?: NullableStringFieldUpdateOperationsInput | string | null
    timestamp?: DateTimeFieldUpdateOperationsInput | Date | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type ProfilingUncheckedUpdateManyWithoutSessionInput = {
    id?: IntFieldUpdateOperationsInput | number
    cpu?: NullableStringFieldUpdateOperationsInput | string | null
    memory?: NullableStringFieldUpdateOperationsInput | string | null
    total_cpu_used?: NullableStringFieldUpdateOperationsInput | string | null
    total_memory_used?: NullableStringFieldUpdateOperationsInput | string | null
    raw_cpu_log?: NullableStringFieldUpdateOperationsInput | string | null
    raw_memory_log?: NullableStringFieldUpdateOperationsInput | string | null
    timestamp?: DateTimeFieldUpdateOperationsInput | Date | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type SessionLogUpdateWithoutSessionInput = {
    id?: StringFieldUpdateOperationsInput | string
    command_name?: NullableStringFieldUpdateOperationsInput | string | null
    url?: StringFieldUpdateOperationsInput | string
    method?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    subtitle?: NullableStringFieldUpdateOperationsInput | string | null
    body?: NullableStringFieldUpdateOperationsInput | string | null
    response?: StringFieldUpdateOperationsInput | string
    screenshot?: NullableStringFieldUpdateOperationsInput | string | null
    is_success?: NullableBoolFieldUpdateOperationsInput | boolean | null
    is_error?: BoolFieldUpdateOperationsInput | boolean
    is_healed?: BoolFieldUpdateOperationsInput | boolean
    original_selector?: NullableStringFieldUpdateOperationsInput | string | null
    healed_selector?: NullableStringFieldUpdateOperationsInput | string | null
    healing_confidence?: NullableFloatFieldUpdateOperationsInput | number | null
    healing_tier?: NullableStringFieldUpdateOperationsInput | string | null
    original_strategy?: NullableStringFieldUpdateOperationsInput | string | null
    healed_strategy?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    duration?: NullableIntFieldUpdateOperationsInput | number | null
    span_id?: NullableStringFieldUpdateOperationsInput | string | null
    trace_id?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type SessionLogUncheckedUpdateWithoutSessionInput = {
    id?: StringFieldUpdateOperationsInput | string
    command_name?: NullableStringFieldUpdateOperationsInput | string | null
    url?: StringFieldUpdateOperationsInput | string
    method?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    subtitle?: NullableStringFieldUpdateOperationsInput | string | null
    body?: NullableStringFieldUpdateOperationsInput | string | null
    response?: StringFieldUpdateOperationsInput | string
    screenshot?: NullableStringFieldUpdateOperationsInput | string | null
    is_success?: NullableBoolFieldUpdateOperationsInput | boolean | null
    is_error?: BoolFieldUpdateOperationsInput | boolean
    is_healed?: BoolFieldUpdateOperationsInput | boolean
    original_selector?: NullableStringFieldUpdateOperationsInput | string | null
    healed_selector?: NullableStringFieldUpdateOperationsInput | string | null
    healing_confidence?: NullableFloatFieldUpdateOperationsInput | number | null
    healing_tier?: NullableStringFieldUpdateOperationsInput | string | null
    original_strategy?: NullableStringFieldUpdateOperationsInput | string | null
    healed_strategy?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    duration?: NullableIntFieldUpdateOperationsInput | number | null
    span_id?: NullableStringFieldUpdateOperationsInput | string | null
    trace_id?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type SessionLogUncheckedUpdateManyWithoutSessionInput = {
    id?: StringFieldUpdateOperationsInput | string
    command_name?: NullableStringFieldUpdateOperationsInput | string | null
    url?: StringFieldUpdateOperationsInput | string
    method?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    subtitle?: NullableStringFieldUpdateOperationsInput | string | null
    body?: NullableStringFieldUpdateOperationsInput | string | null
    response?: StringFieldUpdateOperationsInput | string
    screenshot?: NullableStringFieldUpdateOperationsInput | string | null
    is_success?: NullableBoolFieldUpdateOperationsInput | boolean | null
    is_error?: BoolFieldUpdateOperationsInput | boolean
    is_healed?: BoolFieldUpdateOperationsInput | boolean
    original_selector?: NullableStringFieldUpdateOperationsInput | string | null
    healed_selector?: NullableStringFieldUpdateOperationsInput | string | null
    healing_confidence?: NullableFloatFieldUpdateOperationsInput | number | null
    healing_tier?: NullableStringFieldUpdateOperationsInput | string | null
    original_strategy?: NullableStringFieldUpdateOperationsInput | string | null
    healed_strategy?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    duration?: NullableIntFieldUpdateOperationsInput | number | null
    span_id?: NullableStringFieldUpdateOperationsInput | string | null
    trace_id?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type RecordingUpdateWithoutSessionInput = {
    id?: StringFieldUpdateOperationsInput | string
    group_id?: StringFieldUpdateOperationsInput | string
    device_udid?: StringFieldUpdateOperationsInput | string
    device_host?: StringFieldUpdateOperationsInput | string
    started_at?: DateTimeFieldUpdateOperationsInput | Date | string
    ended_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    status?: StringFieldUpdateOperationsInput | string
    file_path?: StringFieldUpdateOperationsInput | string
    duration_ms?: NullableIntFieldUpdateOperationsInput | number | null
    size_bytes?: NullableIntFieldUpdateOperationsInput | number | null
    device_snapshot?: NullableStringFieldUpdateOperationsInput | string | null
    fail_reason?: NullableStringFieldUpdateOperationsInput | string | null
    bookmarks?: BookmarkUpdateManyWithoutRecordingNestedInput
    annotations?: AnnotationUpdateManyWithoutRecordingNestedInput
  }

  export type RecordingUncheckedUpdateWithoutSessionInput = {
    id?: StringFieldUpdateOperationsInput | string
    group_id?: StringFieldUpdateOperationsInput | string
    device_udid?: StringFieldUpdateOperationsInput | string
    device_host?: StringFieldUpdateOperationsInput | string
    started_at?: DateTimeFieldUpdateOperationsInput | Date | string
    ended_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    status?: StringFieldUpdateOperationsInput | string
    file_path?: StringFieldUpdateOperationsInput | string
    duration_ms?: NullableIntFieldUpdateOperationsInput | number | null
    size_bytes?: NullableIntFieldUpdateOperationsInput | number | null
    device_snapshot?: NullableStringFieldUpdateOperationsInput | string | null
    fail_reason?: NullableStringFieldUpdateOperationsInput | string | null
    bookmarks?: BookmarkUncheckedUpdateManyWithoutRecordingNestedInput
    annotations?: AnnotationUncheckedUpdateManyWithoutRecordingNestedInput
  }

  export type RecordingUncheckedUpdateManyWithoutSessionInput = {
    id?: StringFieldUpdateOperationsInput | string
    group_id?: StringFieldUpdateOperationsInput | string
    device_udid?: StringFieldUpdateOperationsInput | string
    device_host?: StringFieldUpdateOperationsInput | string
    started_at?: DateTimeFieldUpdateOperationsInput | Date | string
    ended_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    status?: StringFieldUpdateOperationsInput | string
    file_path?: StringFieldUpdateOperationsInput | string
    duration_ms?: NullableIntFieldUpdateOperationsInput | number | null
    size_bytes?: NullableIntFieldUpdateOperationsInput | number | null
    device_snapshot?: NullableStringFieldUpdateOperationsInput | string | null
    fail_reason?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type DeviceCreateManyTeamInput = {
    udid: string
    host: string
    systemPort?: number | null
    proxyPort?: number | null
    proxyHost?: string | null
    wdaLocalPort?: number | null
    name?: string | null
    state?: string | null
    sdk?: string | null
    platform?: string | null
    deviceType?: string | null
    busy?: boolean | null
    userBlocked?: boolean | null
    realDevice?: boolean | null
    session_id?: string | null
    offline?: boolean | null
    mjpegServerPort?: number | null
    lastCmdExecutedAt?: number | null
    totalUtilizationTimeMilliSec?: number
    sessionStartTime?: number
    newCommandTimeout?: number | null
    cloud?: string | null
    derivedDataPath?: string | null
    chromeDriverPath?: string | null
    capability?: string | null
    adbRemoteHost?: string | null
    adbPort?: number | null
    nodeId?: string | null
    screenWidth?: string | null
    screenHeight?: string | null
    dashboard_link?: string | null
    total_session_count?: number | null
    createdAt?: Date | string
    updatedAt?: Date | string
    healthCheckError?: string | null
    healthStatus?: string | null
    lastHealthCheckAt?: number | null
    batteryLevel?: number | null
    reservationReason?: string | null
    reservedBy?: string | null
    reservedUntil?: number | null
    storageFree?: string | null
    tags?: string | null
    thermalStatus?: string | null
    sessionProgress?: string | null
    totalHealedCount?: number | null
    ip?: string | null
    cpuArchitecture?: string | null
    owningSessionId?: string | null
    lockedAt?: number | null
  }

  export type ApiKeyCreateManyTeamInput = {
    id?: string
    name: string
    keyHash: string
    scopes: string
    rateLimit?: number
    createdAt?: Date | string
    revokedAt?: Date | string | null
    lastUsedAt?: Date | string | null
    expiresAt?: Date | string | null
    role?: string
    userId: string
  }

  export type TeamMemberCreateManyTeamInput = {
    userId: string
    createdAt?: Date | string
  }

  export type DeviceUpdateWithoutTeamInput = {
    udid?: StringFieldUpdateOperationsInput | string
    host?: StringFieldUpdateOperationsInput | string
    systemPort?: NullableIntFieldUpdateOperationsInput | number | null
    proxyPort?: NullableIntFieldUpdateOperationsInput | number | null
    proxyHost?: NullableStringFieldUpdateOperationsInput | string | null
    wdaLocalPort?: NullableIntFieldUpdateOperationsInput | number | null
    name?: NullableStringFieldUpdateOperationsInput | string | null
    state?: NullableStringFieldUpdateOperationsInput | string | null
    sdk?: NullableStringFieldUpdateOperationsInput | string | null
    platform?: NullableStringFieldUpdateOperationsInput | string | null
    deviceType?: NullableStringFieldUpdateOperationsInput | string | null
    busy?: NullableBoolFieldUpdateOperationsInput | boolean | null
    userBlocked?: NullableBoolFieldUpdateOperationsInput | boolean | null
    realDevice?: NullableBoolFieldUpdateOperationsInput | boolean | null
    session_id?: NullableStringFieldUpdateOperationsInput | string | null
    offline?: NullableBoolFieldUpdateOperationsInput | boolean | null
    mjpegServerPort?: NullableIntFieldUpdateOperationsInput | number | null
    lastCmdExecutedAt?: NullableFloatFieldUpdateOperationsInput | number | null
    totalUtilizationTimeMilliSec?: FloatFieldUpdateOperationsInput | number
    sessionStartTime?: FloatFieldUpdateOperationsInput | number
    newCommandTimeout?: NullableIntFieldUpdateOperationsInput | number | null
    cloud?: NullableStringFieldUpdateOperationsInput | string | null
    derivedDataPath?: NullableStringFieldUpdateOperationsInput | string | null
    chromeDriverPath?: NullableStringFieldUpdateOperationsInput | string | null
    capability?: NullableStringFieldUpdateOperationsInput | string | null
    adbRemoteHost?: NullableStringFieldUpdateOperationsInput | string | null
    adbPort?: NullableIntFieldUpdateOperationsInput | number | null
    nodeId?: NullableStringFieldUpdateOperationsInput | string | null
    screenWidth?: NullableStringFieldUpdateOperationsInput | string | null
    screenHeight?: NullableStringFieldUpdateOperationsInput | string | null
    dashboard_link?: NullableStringFieldUpdateOperationsInput | string | null
    total_session_count?: NullableIntFieldUpdateOperationsInput | number | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    healthCheckError?: NullableStringFieldUpdateOperationsInput | string | null
    healthStatus?: NullableStringFieldUpdateOperationsInput | string | null
    lastHealthCheckAt?: NullableFloatFieldUpdateOperationsInput | number | null
    batteryLevel?: NullableIntFieldUpdateOperationsInput | number | null
    reservationReason?: NullableStringFieldUpdateOperationsInput | string | null
    reservedBy?: NullableStringFieldUpdateOperationsInput | string | null
    reservedUntil?: NullableFloatFieldUpdateOperationsInput | number | null
    storageFree?: NullableStringFieldUpdateOperationsInput | string | null
    tags?: NullableStringFieldUpdateOperationsInput | string | null
    thermalStatus?: NullableStringFieldUpdateOperationsInput | string | null
    sessionProgress?: NullableStringFieldUpdateOperationsInput | string | null
    totalHealedCount?: NullableIntFieldUpdateOperationsInput | number | null
    ip?: NullableStringFieldUpdateOperationsInput | string | null
    cpuArchitecture?: NullableStringFieldUpdateOperationsInput | string | null
    owningSessionId?: NullableStringFieldUpdateOperationsInput | string | null
    lockedAt?: NullableFloatFieldUpdateOperationsInput | number | null
  }

  export type DeviceUncheckedUpdateWithoutTeamInput = {
    udid?: StringFieldUpdateOperationsInput | string
    host?: StringFieldUpdateOperationsInput | string
    systemPort?: NullableIntFieldUpdateOperationsInput | number | null
    proxyPort?: NullableIntFieldUpdateOperationsInput | number | null
    proxyHost?: NullableStringFieldUpdateOperationsInput | string | null
    wdaLocalPort?: NullableIntFieldUpdateOperationsInput | number | null
    name?: NullableStringFieldUpdateOperationsInput | string | null
    state?: NullableStringFieldUpdateOperationsInput | string | null
    sdk?: NullableStringFieldUpdateOperationsInput | string | null
    platform?: NullableStringFieldUpdateOperationsInput | string | null
    deviceType?: NullableStringFieldUpdateOperationsInput | string | null
    busy?: NullableBoolFieldUpdateOperationsInput | boolean | null
    userBlocked?: NullableBoolFieldUpdateOperationsInput | boolean | null
    realDevice?: NullableBoolFieldUpdateOperationsInput | boolean | null
    session_id?: NullableStringFieldUpdateOperationsInput | string | null
    offline?: NullableBoolFieldUpdateOperationsInput | boolean | null
    mjpegServerPort?: NullableIntFieldUpdateOperationsInput | number | null
    lastCmdExecutedAt?: NullableFloatFieldUpdateOperationsInput | number | null
    totalUtilizationTimeMilliSec?: FloatFieldUpdateOperationsInput | number
    sessionStartTime?: FloatFieldUpdateOperationsInput | number
    newCommandTimeout?: NullableIntFieldUpdateOperationsInput | number | null
    cloud?: NullableStringFieldUpdateOperationsInput | string | null
    derivedDataPath?: NullableStringFieldUpdateOperationsInput | string | null
    chromeDriverPath?: NullableStringFieldUpdateOperationsInput | string | null
    capability?: NullableStringFieldUpdateOperationsInput | string | null
    adbRemoteHost?: NullableStringFieldUpdateOperationsInput | string | null
    adbPort?: NullableIntFieldUpdateOperationsInput | number | null
    nodeId?: NullableStringFieldUpdateOperationsInput | string | null
    screenWidth?: NullableStringFieldUpdateOperationsInput | string | null
    screenHeight?: NullableStringFieldUpdateOperationsInput | string | null
    dashboard_link?: NullableStringFieldUpdateOperationsInput | string | null
    total_session_count?: NullableIntFieldUpdateOperationsInput | number | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    healthCheckError?: NullableStringFieldUpdateOperationsInput | string | null
    healthStatus?: NullableStringFieldUpdateOperationsInput | string | null
    lastHealthCheckAt?: NullableFloatFieldUpdateOperationsInput | number | null
    batteryLevel?: NullableIntFieldUpdateOperationsInput | number | null
    reservationReason?: NullableStringFieldUpdateOperationsInput | string | null
    reservedBy?: NullableStringFieldUpdateOperationsInput | string | null
    reservedUntil?: NullableFloatFieldUpdateOperationsInput | number | null
    storageFree?: NullableStringFieldUpdateOperationsInput | string | null
    tags?: NullableStringFieldUpdateOperationsInput | string | null
    thermalStatus?: NullableStringFieldUpdateOperationsInput | string | null
    sessionProgress?: NullableStringFieldUpdateOperationsInput | string | null
    totalHealedCount?: NullableIntFieldUpdateOperationsInput | number | null
    ip?: NullableStringFieldUpdateOperationsInput | string | null
    cpuArchitecture?: NullableStringFieldUpdateOperationsInput | string | null
    owningSessionId?: NullableStringFieldUpdateOperationsInput | string | null
    lockedAt?: NullableFloatFieldUpdateOperationsInput | number | null
  }

  export type DeviceUncheckedUpdateManyWithoutTeamInput = {
    udid?: StringFieldUpdateOperationsInput | string
    host?: StringFieldUpdateOperationsInput | string
    systemPort?: NullableIntFieldUpdateOperationsInput | number | null
    proxyPort?: NullableIntFieldUpdateOperationsInput | number | null
    proxyHost?: NullableStringFieldUpdateOperationsInput | string | null
    wdaLocalPort?: NullableIntFieldUpdateOperationsInput | number | null
    name?: NullableStringFieldUpdateOperationsInput | string | null
    state?: NullableStringFieldUpdateOperationsInput | string | null
    sdk?: NullableStringFieldUpdateOperationsInput | string | null
    platform?: NullableStringFieldUpdateOperationsInput | string | null
    deviceType?: NullableStringFieldUpdateOperationsInput | string | null
    busy?: NullableBoolFieldUpdateOperationsInput | boolean | null
    userBlocked?: NullableBoolFieldUpdateOperationsInput | boolean | null
    realDevice?: NullableBoolFieldUpdateOperationsInput | boolean | null
    session_id?: NullableStringFieldUpdateOperationsInput | string | null
    offline?: NullableBoolFieldUpdateOperationsInput | boolean | null
    mjpegServerPort?: NullableIntFieldUpdateOperationsInput | number | null
    lastCmdExecutedAt?: NullableFloatFieldUpdateOperationsInput | number | null
    totalUtilizationTimeMilliSec?: FloatFieldUpdateOperationsInput | number
    sessionStartTime?: FloatFieldUpdateOperationsInput | number
    newCommandTimeout?: NullableIntFieldUpdateOperationsInput | number | null
    cloud?: NullableStringFieldUpdateOperationsInput | string | null
    derivedDataPath?: NullableStringFieldUpdateOperationsInput | string | null
    chromeDriverPath?: NullableStringFieldUpdateOperationsInput | string | null
    capability?: NullableStringFieldUpdateOperationsInput | string | null
    adbRemoteHost?: NullableStringFieldUpdateOperationsInput | string | null
    adbPort?: NullableIntFieldUpdateOperationsInput | number | null
    nodeId?: NullableStringFieldUpdateOperationsInput | string | null
    screenWidth?: NullableStringFieldUpdateOperationsInput | string | null
    screenHeight?: NullableStringFieldUpdateOperationsInput | string | null
    dashboard_link?: NullableStringFieldUpdateOperationsInput | string | null
    total_session_count?: NullableIntFieldUpdateOperationsInput | number | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    healthCheckError?: NullableStringFieldUpdateOperationsInput | string | null
    healthStatus?: NullableStringFieldUpdateOperationsInput | string | null
    lastHealthCheckAt?: NullableFloatFieldUpdateOperationsInput | number | null
    batteryLevel?: NullableIntFieldUpdateOperationsInput | number | null
    reservationReason?: NullableStringFieldUpdateOperationsInput | string | null
    reservedBy?: NullableStringFieldUpdateOperationsInput | string | null
    reservedUntil?: NullableFloatFieldUpdateOperationsInput | number | null
    storageFree?: NullableStringFieldUpdateOperationsInput | string | null
    tags?: NullableStringFieldUpdateOperationsInput | string | null
    thermalStatus?: NullableStringFieldUpdateOperationsInput | string | null
    sessionProgress?: NullableStringFieldUpdateOperationsInput | string | null
    totalHealedCount?: NullableIntFieldUpdateOperationsInput | number | null
    ip?: NullableStringFieldUpdateOperationsInput | string | null
    cpuArchitecture?: NullableStringFieldUpdateOperationsInput | string | null
    owningSessionId?: NullableStringFieldUpdateOperationsInput | string | null
    lockedAt?: NullableFloatFieldUpdateOperationsInput | number | null
  }

  export type ApiKeyUpdateWithoutTeamInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    keyHash?: StringFieldUpdateOperationsInput | string
    scopes?: StringFieldUpdateOperationsInput | string
    rateLimit?: IntFieldUpdateOperationsInput | number
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    revokedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    lastUsedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    expiresAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    role?: StringFieldUpdateOperationsInput | string
    user?: UserUpdateOneRequiredWithoutApiKeysNestedInput
  }

  export type ApiKeyUncheckedUpdateWithoutTeamInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    keyHash?: StringFieldUpdateOperationsInput | string
    scopes?: StringFieldUpdateOperationsInput | string
    rateLimit?: IntFieldUpdateOperationsInput | number
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    revokedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    lastUsedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    expiresAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    role?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
  }

  export type ApiKeyUncheckedUpdateManyWithoutTeamInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    keyHash?: StringFieldUpdateOperationsInput | string
    scopes?: StringFieldUpdateOperationsInput | string
    rateLimit?: IntFieldUpdateOperationsInput | number
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    revokedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    lastUsedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    expiresAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    role?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
  }

  export type TeamMemberUpdateWithoutTeamInput = {
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    user?: UserUpdateOneRequiredWithoutTeamMembershipsNestedInput
  }

  export type TeamMemberUncheckedUpdateWithoutTeamInput = {
    userId?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type TeamMemberUncheckedUpdateManyWithoutTeamInput = {
    userId?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type BookmarkCreateManyRecordingInput = {
    id?: string
    timecode_ms: number
    label: string
    note?: string | null
    created_at?: Date | string
  }

  export type AnnotationCreateManyRecordingInput = {
    id?: string
    timecode_ms: number
    shape: string
    geometry: string
    color: string
    text?: string | null
    author?: string | null
    created_at?: Date | string
  }

  export type BookmarkUpdateWithoutRecordingInput = {
    id?: StringFieldUpdateOperationsInput | string
    timecode_ms?: IntFieldUpdateOperationsInput | number
    label?: StringFieldUpdateOperationsInput | string
    note?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type BookmarkUncheckedUpdateWithoutRecordingInput = {
    id?: StringFieldUpdateOperationsInput | string
    timecode_ms?: IntFieldUpdateOperationsInput | number
    label?: StringFieldUpdateOperationsInput | string
    note?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type BookmarkUncheckedUpdateManyWithoutRecordingInput = {
    id?: StringFieldUpdateOperationsInput | string
    timecode_ms?: IntFieldUpdateOperationsInput | number
    label?: StringFieldUpdateOperationsInput | string
    note?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type AnnotationUpdateWithoutRecordingInput = {
    id?: StringFieldUpdateOperationsInput | string
    timecode_ms?: IntFieldUpdateOperationsInput | number
    shape?: StringFieldUpdateOperationsInput | string
    geometry?: StringFieldUpdateOperationsInput | string
    color?: StringFieldUpdateOperationsInput | string
    text?: NullableStringFieldUpdateOperationsInput | string | null
    author?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type AnnotationUncheckedUpdateWithoutRecordingInput = {
    id?: StringFieldUpdateOperationsInput | string
    timecode_ms?: IntFieldUpdateOperationsInput | number
    shape?: StringFieldUpdateOperationsInput | string
    geometry?: StringFieldUpdateOperationsInput | string
    color?: StringFieldUpdateOperationsInput | string
    text?: NullableStringFieldUpdateOperationsInput | string | null
    author?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type AnnotationUncheckedUpdateManyWithoutRecordingInput = {
    id?: StringFieldUpdateOperationsInput | string
    timecode_ms?: IntFieldUpdateOperationsInput | number
    shape?: StringFieldUpdateOperationsInput | string
    geometry?: StringFieldUpdateOperationsInput | string
    color?: StringFieldUpdateOperationsInput | string
    text?: NullableStringFieldUpdateOperationsInput | string | null
    author?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type ApiKeyCreateManyUserInput = {
    id?: string
    name: string
    keyHash: string
    scopes: string
    rateLimit?: number
    createdAt?: Date | string
    revokedAt?: Date | string | null
    lastUsedAt?: Date | string | null
    expiresAt?: Date | string | null
    teamId?: string | null
    role?: string
  }

  export type UserSessionCreateManyUserInput = {
    id?: string
    createdAt?: Date | string
    expiresAt: Date | string
    lastSeenAt?: Date | string
    userAgent?: string | null
    ipHash?: string | null
  }

  export type PasswordResetTokenCreateManyUserInput = {
    id?: string
    tokenHash: string
    createdAt?: Date | string
    expiresAt: Date | string
    usedAt?: Date | string | null
  }

  export type TeamMemberCreateManyUserInput = {
    teamId: string
    createdAt?: Date | string
  }

  export type ApiKeyUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    keyHash?: StringFieldUpdateOperationsInput | string
    scopes?: StringFieldUpdateOperationsInput | string
    rateLimit?: IntFieldUpdateOperationsInput | number
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    revokedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    lastUsedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    expiresAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    role?: StringFieldUpdateOperationsInput | string
    team?: TeamUpdateOneWithoutApiKeysNestedInput
  }

  export type ApiKeyUncheckedUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    keyHash?: StringFieldUpdateOperationsInput | string
    scopes?: StringFieldUpdateOperationsInput | string
    rateLimit?: IntFieldUpdateOperationsInput | number
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    revokedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    lastUsedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    expiresAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    teamId?: NullableStringFieldUpdateOperationsInput | string | null
    role?: StringFieldUpdateOperationsInput | string
  }

  export type ApiKeyUncheckedUpdateManyWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    keyHash?: StringFieldUpdateOperationsInput | string
    scopes?: StringFieldUpdateOperationsInput | string
    rateLimit?: IntFieldUpdateOperationsInput | number
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    revokedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    lastUsedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    expiresAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    teamId?: NullableStringFieldUpdateOperationsInput | string | null
    role?: StringFieldUpdateOperationsInput | string
  }

  export type UserSessionUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    expiresAt?: DateTimeFieldUpdateOperationsInput | Date | string
    lastSeenAt?: DateTimeFieldUpdateOperationsInput | Date | string
    userAgent?: NullableStringFieldUpdateOperationsInput | string | null
    ipHash?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type UserSessionUncheckedUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    expiresAt?: DateTimeFieldUpdateOperationsInput | Date | string
    lastSeenAt?: DateTimeFieldUpdateOperationsInput | Date | string
    userAgent?: NullableStringFieldUpdateOperationsInput | string | null
    ipHash?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type UserSessionUncheckedUpdateManyWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    expiresAt?: DateTimeFieldUpdateOperationsInput | Date | string
    lastSeenAt?: DateTimeFieldUpdateOperationsInput | Date | string
    userAgent?: NullableStringFieldUpdateOperationsInput | string | null
    ipHash?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type PasswordResetTokenUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    tokenHash?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    expiresAt?: DateTimeFieldUpdateOperationsInput | Date | string
    usedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type PasswordResetTokenUncheckedUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    tokenHash?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    expiresAt?: DateTimeFieldUpdateOperationsInput | Date | string
    usedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type PasswordResetTokenUncheckedUpdateManyWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    tokenHash?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    expiresAt?: DateTimeFieldUpdateOperationsInput | Date | string
    usedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type TeamMemberUpdateWithoutUserInput = {
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    team?: TeamUpdateOneRequiredWithoutMembersNestedInput
  }

  export type TeamMemberUncheckedUpdateWithoutUserInput = {
    teamId?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type TeamMemberUncheckedUpdateManyWithoutUserInput = {
    teamId?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }



  /**
   * Aliases for legacy arg types
   */
    /**
     * @deprecated Use BuildCountOutputTypeDefaultArgs instead
     */
    export type BuildCountOutputTypeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = BuildCountOutputTypeDefaultArgs<ExtArgs>
    /**
     * @deprecated Use SessionCountOutputTypeDefaultArgs instead
     */
    export type SessionCountOutputTypeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = SessionCountOutputTypeDefaultArgs<ExtArgs>
    /**
     * @deprecated Use TeamCountOutputTypeDefaultArgs instead
     */
    export type TeamCountOutputTypeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = TeamCountOutputTypeDefaultArgs<ExtArgs>
    /**
     * @deprecated Use RecordingCountOutputTypeDefaultArgs instead
     */
    export type RecordingCountOutputTypeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = RecordingCountOutputTypeDefaultArgs<ExtArgs>
    /**
     * @deprecated Use UserCountOutputTypeDefaultArgs instead
     */
    export type UserCountOutputTypeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = UserCountOutputTypeDefaultArgs<ExtArgs>
    /**
     * @deprecated Use BuildDefaultArgs instead
     */
    export type BuildArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = BuildDefaultArgs<ExtArgs>
    /**
     * @deprecated Use SessionDefaultArgs instead
     */
    export type SessionArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = SessionDefaultArgs<ExtArgs>
    /**
     * @deprecated Use SessionLogDefaultArgs instead
     */
    export type SessionLogArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = SessionLogDefaultArgs<ExtArgs>
    /**
     * @deprecated Use LogDefaultArgs instead
     */
    export type LogArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = LogDefaultArgs<ExtArgs>
    /**
     * @deprecated Use ProfilingDefaultArgs instead
     */
    export type ProfilingArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = ProfilingDefaultArgs<ExtArgs>
    /**
     * @deprecated Use AppDefaultArgs instead
     */
    export type AppArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = AppDefaultArgs<ExtArgs>
    /**
     * @deprecated Use DeviceDefaultArgs instead
     */
    export type DeviceArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = DeviceDefaultArgs<ExtArgs>
    /**
     * @deprecated Use PendingSessionDefaultArgs instead
     */
    export type PendingSessionArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = PendingSessionDefaultArgs<ExtArgs>
    /**
     * @deprecated Use CLIArgsDefaultArgs instead
     */
    export type CLIArgsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = CLIArgsDefaultArgs<ExtArgs>
    /**
     * @deprecated Use WebhookConfigDefaultArgs instead
     */
    export type WebhookConfigArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = WebhookConfigDefaultArgs<ExtArgs>
    /**
     * @deprecated Use WebConfigDefaultArgs instead
     */
    export type WebConfigArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = WebConfigDefaultArgs<ExtArgs>
    /**
     * @deprecated Use LocatorEtalonDefaultArgs instead
     */
    export type LocatorEtalonArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = LocatorEtalonDefaultArgs<ExtArgs>
    /**
     * @deprecated Use PortLeaseDefaultArgs instead
     */
    export type PortLeaseArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = PortLeaseDefaultArgs<ExtArgs>
    /**
     * @deprecated Use LeaseDefaultArgs instead
     */
    export type LeaseArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = LeaseDefaultArgs<ExtArgs>
    /**
     * @deprecated Use ApiKeyDefaultArgs instead
     */
    export type ApiKeyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = ApiKeyDefaultArgs<ExtArgs>
    /**
     * @deprecated Use TeamDefaultArgs instead
     */
    export type TeamArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = TeamDefaultArgs<ExtArgs>
    /**
     * @deprecated Use SelectorStateDefaultArgs instead
     */
    export type SelectorStateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = SelectorStateDefaultArgs<ExtArgs>
    /**
     * @deprecated Use RecordingDefaultArgs instead
     */
    export type RecordingArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = RecordingDefaultArgs<ExtArgs>
    /**
     * @deprecated Use BookmarkDefaultArgs instead
     */
    export type BookmarkArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = BookmarkDefaultArgs<ExtArgs>
    /**
     * @deprecated Use AnnotationDefaultArgs instead
     */
    export type AnnotationArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = AnnotationDefaultArgs<ExtArgs>
    /**
     * @deprecated Use UserDefaultArgs instead
     */
    export type UserArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = UserDefaultArgs<ExtArgs>
    /**
     * @deprecated Use UserSessionDefaultArgs instead
     */
    export type UserSessionArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = UserSessionDefaultArgs<ExtArgs>
    /**
     * @deprecated Use PasswordResetTokenDefaultArgs instead
     */
    export type PasswordResetTokenArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = PasswordResetTokenDefaultArgs<ExtArgs>
    /**
     * @deprecated Use TeamMemberDefaultArgs instead
     */
    export type TeamMemberArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = TeamMemberDefaultArgs<ExtArgs>
    /**
     * @deprecated Use EventLogDefaultArgs instead
     */
    export type EventLogArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = EventLogDefaultArgs<ExtArgs>
    /**
     * @deprecated Use ProjectDefaultArgs instead
     */
    export type ProjectArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = ProjectDefaultArgs<ExtArgs>

  /**
   * Batch Payload for updateMany & deleteMany & createMany
   */

  export type BatchPayload = {
    count: number
  }

  /**
   * DMMF
   */
  export const dmmf: runtime.BaseDMMF
}